|
|
/**
|
|
|
* Copyright (c) 2017-present, Gregory Szorc
|
|
|
* All rights reserved.
|
|
|
*
|
|
|
* This software may be modified and distributed under the terms
|
|
|
* of the BSD license. See the LICENSE file for details.
|
|
|
*/
|
|
|
|
|
|
#include "python-zstandard.h"
|
|
|
|
|
|
extern PyObject* ZstdError;
|
|
|
|
|
|
PyDoc_STRVAR(BufferWithSegments__doc__,
|
|
|
"BufferWithSegments - A memory buffer holding known sub-segments.\n"
|
|
|
"\n"
|
|
|
"This type represents a contiguous chunk of memory containing N discrete\n"
|
|
|
"items within sub-segments of that memory.\n"
|
|
|
"\n"
|
|
|
"Segments within the buffer are stored as an array of\n"
|
|
|
"``(offset, length)`` pairs, where each element is an unsigned 64-bit\n"
|
|
|
"integer using the host/native bit order representation.\n"
|
|
|
"\n"
|
|
|
"The type exists to facilitate operations against N>1 items without the\n"
|
|
|
"overhead of Python object creation and management.\n"
|
|
|
);
|
|
|
|
|
|
static void BufferWithSegments_dealloc(ZstdBufferWithSegments* self) {
|
|
|
/* Backing memory is either canonically owned by a Py_buffer or by us. */
|
|
|
if (self->parent.buf) {
|
|
|
PyBuffer_Release(&self->parent);
|
|
|
}
|
|
|
else if (self->useFree) {
|
|
|
free(self->data);
|
|
|
}
|
|
|
else {
|
|
|
PyMem_Free(self->data);
|
|
|
}
|
|
|
|
|
|
self->data = NULL;
|
|
|
|
|
|
if (self->useFree) {
|
|
|
free(self->segments);
|
|
|
}
|
|
|
else {
|
|
|
PyMem_Free(self->segments);
|
|
|
}
|
|
|
|
|
|
self->segments = NULL;
|
|
|
|
|
|
PyObject_Del(self);
|
|
|
}
|
|
|
|
|
|
static int BufferWithSegments_init(ZstdBufferWithSegments* self, PyObject* args, PyObject* kwargs) {
|
|
|
static char* kwlist[] = {
|
|
|
"data",
|
|
|
"segments",
|
|
|
NULL
|
|
|
};
|
|
|
|
|
|
Py_buffer segments;
|
|
|
Py_ssize_t segmentCount;
|
|
|
Py_ssize_t i;
|
|
|
|
|
|
memset(&self->parent, 0, sizeof(self->parent));
|
|
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*y*:BufferWithSegments",
|
|
|
#else
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*s*:BufferWithSegments",
|
|
|
#endif
|
|
|
kwlist, &self->parent, &segments)) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
if (!PyBuffer_IsContiguous(&self->parent, 'C') || self->parent.ndim > 1) {
|
|
|
PyErr_SetString(PyExc_ValueError, "data buffer should be contiguous and have a single dimension");
|
|
|
goto except;
|
|
|
}
|
|
|
|
|
|
if (!PyBuffer_IsContiguous(&segments, 'C') || segments.ndim > 1) {
|
|
|
PyErr_SetString(PyExc_ValueError, "segments buffer should be contiguous and have a single dimension");
|
|
|
goto except;
|
|
|
}
|
|
|
|
|
|
if (segments.len % sizeof(BufferSegment)) {
|
|
|
PyErr_Format(PyExc_ValueError, "segments array size is not a multiple of %zu",
|
|
|
sizeof(BufferSegment));
|
|
|
goto except;
|
|
|
}
|
|
|
|
|
|
segmentCount = segments.len / sizeof(BufferSegment);
|
|
|
|
|
|
/* Validate segments data, as blindly trusting it could lead to arbitrary
|
|
|
memory access. */
|
|
|
for (i = 0; i < segmentCount; i++) {
|
|
|
BufferSegment* segment = &((BufferSegment*)(segments.buf))[i];
|
|
|
|
|
|
if (segment->offset + segment->length > (unsigned long long)self->parent.len) {
|
|
|
PyErr_SetString(PyExc_ValueError, "offset within segments array references memory outside buffer");
|
|
|
goto except;
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Make a copy of the segments data. It is cheap to do so and is a guard
|
|
|
against caller changing offsets, which has security implications. */
|
|
|
self->segments = PyMem_Malloc(segments.len);
|
|
|
if (!self->segments) {
|
|
|
PyErr_NoMemory();
|
|
|
goto except;
|
|
|
}
|
|
|
|
|
|
memcpy(self->segments, segments.buf, segments.len);
|
|
|
PyBuffer_Release(&segments);
|
|
|
|
|
|
self->data = self->parent.buf;
|
|
|
self->dataSize = self->parent.len;
|
|
|
self->segmentCount = segmentCount;
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
except:
|
|
|
PyBuffer_Release(&self->parent);
|
|
|
PyBuffer_Release(&segments);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Construct a BufferWithSegments from existing memory and offsets.
|
|
|
*
|
|
|
* Ownership of the backing memory and BufferSegments will be transferred to
|
|
|
* the created object and freed when the BufferWithSegments is destroyed.
|
|
|
*/
|
|
|
ZstdBufferWithSegments* BufferWithSegments_FromMemory(void* data, unsigned long long dataSize,
|
|
|
BufferSegment* segments, Py_ssize_t segmentsSize) {
|
|
|
ZstdBufferWithSegments* result = NULL;
|
|
|
Py_ssize_t i;
|
|
|
|
|
|
if (NULL == data) {
|
|
|
PyErr_SetString(PyExc_ValueError, "data is NULL");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
if (NULL == segments) {
|
|
|
PyErr_SetString(PyExc_ValueError, "segments is NULL");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < segmentsSize; i++) {
|
|
|
BufferSegment* segment = &segments[i];
|
|
|
|
|
|
if (segment->offset + segment->length > dataSize) {
|
|
|
PyErr_SetString(PyExc_ValueError, "offset in segments overflows buffer size");
|
|
|
return NULL;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
result = PyObject_New(ZstdBufferWithSegments, &ZstdBufferWithSegmentsType);
|
|
|
if (NULL == result) {
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
result->useFree = 0;
|
|
|
|
|
|
memset(&result->parent, 0, sizeof(result->parent));
|
|
|
result->data = data;
|
|
|
result->dataSize = dataSize;
|
|
|
result->segments = segments;
|
|
|
result->segmentCount = segmentsSize;
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
static Py_ssize_t BufferWithSegments_length(ZstdBufferWithSegments* self) {
|
|
|
return self->segmentCount;
|
|
|
}
|
|
|
|
|
|
static ZstdBufferSegment* BufferWithSegments_item(ZstdBufferWithSegments* self, Py_ssize_t i) {
|
|
|
ZstdBufferSegment* result = NULL;
|
|
|
|
|
|
if (i < 0) {
|
|
|
PyErr_SetString(PyExc_IndexError, "offset must be non-negative");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
if (i >= self->segmentCount) {
|
|
|
PyErr_Format(PyExc_IndexError, "offset must be less than %zd", self->segmentCount);
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
if (self->segments[i].length > PY_SSIZE_T_MAX) {
|
|
|
PyErr_Format(PyExc_ValueError,
|
|
|
"item at offset %zd is too large for this platform", i);
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
result = (ZstdBufferSegment*)PyObject_CallObject((PyObject*)&ZstdBufferSegmentType, NULL);
|
|
|
if (NULL == result) {
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
result->parent = (PyObject*)self;
|
|
|
Py_INCREF(self);
|
|
|
|
|
|
result->data = (char*)self->data + self->segments[i].offset;
|
|
|
result->dataSize = (Py_ssize_t)self->segments[i].length;
|
|
|
result->offset = self->segments[i].offset;
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
|
static int BufferWithSegments_getbuffer(ZstdBufferWithSegments* self, Py_buffer* view, int flags) {
|
|
|
if (self->dataSize > PY_SSIZE_T_MAX) {
|
|
|
view->obj = NULL;
|
|
|
PyErr_SetString(PyExc_BufferError, "buffer is too large for this platform");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
return PyBuffer_FillInfo(view, (PyObject*)self, self->data, (Py_ssize_t)self->dataSize, 1, flags);
|
|
|
}
|
|
|
#else
|
|
|
static Py_ssize_t BufferWithSegments_getreadbuffer(ZstdBufferWithSegments* self, Py_ssize_t segment, void **ptrptr) {
|
|
|
if (segment != 0) {
|
|
|
PyErr_SetString(PyExc_ValueError, "segment number must be 0");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
if (self->dataSize > PY_SSIZE_T_MAX) {
|
|
|
PyErr_SetString(PyExc_ValueError, "buffer is too large for this platform");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
*ptrptr = self->data;
|
|
|
return (Py_ssize_t)self->dataSize;
|
|
|
}
|
|
|
|
|
|
static Py_ssize_t BufferWithSegments_getsegcount(ZstdBufferWithSegments* self, Py_ssize_t* len) {
|
|
|
if (len) {
|
|
|
*len = 1;
|
|
|
}
|
|
|
|
|
|
return 1;
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
PyDoc_STRVAR(BufferWithSegments_tobytes__doc__,
|
|
|
"Obtain a bytes instance for this buffer.\n"
|
|
|
);
|
|
|
|
|
|
static PyObject* BufferWithSegments_tobytes(ZstdBufferWithSegments* self) {
|
|
|
if (self->dataSize > PY_SSIZE_T_MAX) {
|
|
|
PyErr_SetString(PyExc_ValueError, "buffer is too large for this platform");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
return PyBytes_FromStringAndSize(self->data, (Py_ssize_t)self->dataSize);
|
|
|
}
|
|
|
|
|
|
PyDoc_STRVAR(BufferWithSegments_segments__doc__,
|
|
|
"Obtain a BufferSegments describing segments in this sintance.\n"
|
|
|
);
|
|
|
|
|
|
static ZstdBufferSegments* BufferWithSegments_segments(ZstdBufferWithSegments* self) {
|
|
|
ZstdBufferSegments* result = (ZstdBufferSegments*)PyObject_CallObject((PyObject*)&ZstdBufferSegmentsType, NULL);
|
|
|
if (NULL == result) {
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
result->parent = (PyObject*)self;
|
|
|
Py_INCREF(self);
|
|
|
result->segments = self->segments;
|
|
|
result->segmentCount = self->segmentCount;
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
static PySequenceMethods BufferWithSegments_sq = {
|
|
|
(lenfunc)BufferWithSegments_length, /* sq_length */
|
|
|
0, /* sq_concat */
|
|
|
0, /* sq_repeat */
|
|
|
(ssizeargfunc)BufferWithSegments_item, /* sq_item */
|
|
|
0, /* sq_ass_item */
|
|
|
0, /* sq_contains */
|
|
|
0, /* sq_inplace_concat */
|
|
|
0 /* sq_inplace_repeat */
|
|
|
};
|
|
|
|
|
|
static PyBufferProcs BufferWithSegments_as_buffer = {
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
|
(getbufferproc)BufferWithSegments_getbuffer, /* bf_getbuffer */
|
|
|
0 /* bf_releasebuffer */
|
|
|
#else
|
|
|
(readbufferproc)BufferWithSegments_getreadbuffer, /* bf_getreadbuffer */
|
|
|
0, /* bf_getwritebuffer */
|
|
|
(segcountproc)BufferWithSegments_getsegcount, /* bf_getsegcount */
|
|
|
0 /* bf_getcharbuffer */
|
|
|
#endif
|
|
|
};
|
|
|
|
|
|
static PyMethodDef BufferWithSegments_methods[] = {
|
|
|
{ "segments", (PyCFunction)BufferWithSegments_segments,
|
|
|
METH_NOARGS, BufferWithSegments_segments__doc__ },
|
|
|
{ "tobytes", (PyCFunction)BufferWithSegments_tobytes,
|
|
|
METH_NOARGS, BufferWithSegments_tobytes__doc__ },
|
|
|
{ NULL, NULL }
|
|
|
};
|
|
|
|
|
|
static PyMemberDef BufferWithSegments_members[] = {
|
|
|
{ "size", T_ULONGLONG, offsetof(ZstdBufferWithSegments, dataSize),
|
|
|
READONLY, "total size of the buffer in bytes" },
|
|
|
{ NULL }
|
|
|
};
|
|
|
|
|
|
PyTypeObject ZstdBufferWithSegmentsType = {
|
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
|
"zstd.BufferWithSegments", /* tp_name */
|
|
|
sizeof(ZstdBufferWithSegments),/* tp_basicsize */
|
|
|
0, /* tp_itemsize */
|
|
|
(destructor)BufferWithSegments_dealloc, /* tp_dealloc */
|
|
|
0, /* tp_print */
|
|
|
0, /* tp_getattr */
|
|
|
0, /* tp_setattr */
|
|
|
0, /* tp_compare */
|
|
|
0, /* tp_repr */
|
|
|
0, /* tp_as_number */
|
|
|
&BufferWithSegments_sq, /* tp_as_sequence */
|
|
|
0, /* tp_as_mapping */
|
|
|
0, /* tp_hash */
|
|
|
0, /* tp_call */
|
|
|
0, /* tp_str */
|
|
|
0, /* tp_getattro */
|
|
|
0, /* tp_setattro */
|
|
|
&BufferWithSegments_as_buffer, /* tp_as_buffer */
|
|
|
Py_TPFLAGS_DEFAULT, /* tp_flags */
|
|
|
BufferWithSegments__doc__, /* tp_doc */
|
|
|
0, /* tp_traverse */
|
|
|
0, /* tp_clear */
|
|
|
0, /* tp_richcompare */
|
|
|
0, /* tp_weaklistoffset */
|
|
|
0, /* tp_iter */
|
|
|
0, /* tp_iternext */
|
|
|
BufferWithSegments_methods, /* tp_methods */
|
|
|
BufferWithSegments_members, /* tp_members */
|
|
|
0, /* tp_getset */
|
|
|
0, /* tp_base */
|
|
|
0, /* tp_dict */
|
|
|
0, /* tp_descr_get */
|
|
|
0, /* tp_descr_set */
|
|
|
0, /* tp_dictoffset */
|
|
|
(initproc)BufferWithSegments_init, /* tp_init */
|
|
|
0, /* tp_alloc */
|
|
|
PyType_GenericNew, /* tp_new */
|
|
|
};
|
|
|
|
|
|
PyDoc_STRVAR(BufferSegments__doc__,
|
|
|
"BufferSegments - Represents segments/offsets within a BufferWithSegments\n"
|
|
|
);
|
|
|
|
|
|
static void BufferSegments_dealloc(ZstdBufferSegments* self) {
|
|
|
Py_CLEAR(self->parent);
|
|
|
PyObject_Del(self);
|
|
|
}
|
|
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
|
static int BufferSegments_getbuffer(ZstdBufferSegments* self, Py_buffer* view, int flags) {
|
|
|
return PyBuffer_FillInfo(view, (PyObject*)self,
|
|
|
(void*)self->segments, self->segmentCount * sizeof(BufferSegment),
|
|
|
1, flags);
|
|
|
}
|
|
|
#else
|
|
|
static Py_ssize_t BufferSegments_getreadbuffer(ZstdBufferSegments* self, Py_ssize_t segment, void **ptrptr) {
|
|
|
if (segment != 0) {
|
|
|
PyErr_SetString(PyExc_ValueError, "segment number must be 0");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
*ptrptr = (void*)self->segments;
|
|
|
return self->segmentCount * sizeof(BufferSegment);
|
|
|
}
|
|
|
|
|
|
static Py_ssize_t BufferSegments_getsegcount(ZstdBufferSegments* self, Py_ssize_t* len) {
|
|
|
if (len) {
|
|
|
*len = 1;
|
|
|
}
|
|
|
|
|
|
return 1;
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
static PyBufferProcs BufferSegments_as_buffer = {
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
|
(getbufferproc)BufferSegments_getbuffer,
|
|
|
0
|
|
|
#else
|
|
|
(readbufferproc)BufferSegments_getreadbuffer,
|
|
|
0,
|
|
|
(segcountproc)BufferSegments_getsegcount,
|
|
|
0
|
|
|
#endif
|
|
|
};
|
|
|
|
|
|
PyTypeObject ZstdBufferSegmentsType = {
|
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
|
"zstd.BufferSegments", /* tp_name */
|
|
|
sizeof(ZstdBufferSegments),/* tp_basicsize */
|
|
|
0, /* tp_itemsize */
|
|
|
(destructor)BufferSegments_dealloc, /* tp_dealloc */
|
|
|
0, /* tp_print */
|
|
|
0, /* tp_getattr */
|
|
|
0, /* tp_setattr */
|
|
|
0, /* tp_compare */
|
|
|
0, /* tp_repr */
|
|
|
0, /* tp_as_number */
|
|
|
0, /* tp_as_sequence */
|
|
|
0, /* tp_as_mapping */
|
|
|
0, /* tp_hash */
|
|
|
0, /* tp_call */
|
|
|
0, /* tp_str */
|
|
|
0, /* tp_getattro */
|
|
|
0, /* tp_setattro */
|
|
|
&BufferSegments_as_buffer, /* tp_as_buffer */
|
|
|
Py_TPFLAGS_DEFAULT, /* tp_flags */
|
|
|
BufferSegments__doc__, /* tp_doc */
|
|
|
0, /* tp_traverse */
|
|
|
0, /* tp_clear */
|
|
|
0, /* tp_richcompare */
|
|
|
0, /* tp_weaklistoffset */
|
|
|
0, /* tp_iter */
|
|
|
0, /* tp_iternext */
|
|
|
0, /* tp_methods */
|
|
|
0, /* tp_members */
|
|
|
0, /* tp_getset */
|
|
|
0, /* tp_base */
|
|
|
0, /* tp_dict */
|
|
|
0, /* tp_descr_get */
|
|
|
0, /* tp_descr_set */
|
|
|
0, /* tp_dictoffset */
|
|
|
0, /* tp_init */
|
|
|
0, /* tp_alloc */
|
|
|
PyType_GenericNew, /* tp_new */
|
|
|
};
|
|
|
|
|
|
PyDoc_STRVAR(BufferSegment__doc__,
|
|
|
"BufferSegment - Represents a segment within a BufferWithSegments\n"
|
|
|
);
|
|
|
|
|
|
static void BufferSegment_dealloc(ZstdBufferSegment* self) {
|
|
|
Py_CLEAR(self->parent);
|
|
|
PyObject_Del(self);
|
|
|
}
|
|
|
|
|
|
static Py_ssize_t BufferSegment_length(ZstdBufferSegment* self) {
|
|
|
return self->dataSize;
|
|
|
}
|
|
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
|
static int BufferSegment_getbuffer(ZstdBufferSegment* self, Py_buffer* view, int flags) {
|
|
|
return PyBuffer_FillInfo(view, (PyObject*)self,
|
|
|
self->data, self->dataSize, 1, flags);
|
|
|
}
|
|
|
#else
|
|
|
static Py_ssize_t BufferSegment_getreadbuffer(ZstdBufferSegment* self, Py_ssize_t segment, void **ptrptr) {
|
|
|
if (segment != 0) {
|
|
|
PyErr_SetString(PyExc_ValueError, "segment number must be 0");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
*ptrptr = self->data;
|
|
|
return self->dataSize;
|
|
|
}
|
|
|
|
|
|
static Py_ssize_t BufferSegment_getsegcount(ZstdBufferSegment* self, Py_ssize_t* len) {
|
|
|
if (len) {
|
|
|
*len = 1;
|
|
|
}
|
|
|
|
|
|
return 1;
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
PyDoc_STRVAR(BufferSegment_tobytes__doc__,
|
|
|
"Obtain a bytes instance for this segment.\n"
|
|
|
);
|
|
|
|
|
|
static PyObject* BufferSegment_tobytes(ZstdBufferSegment* self) {
|
|
|
return PyBytes_FromStringAndSize(self->data, self->dataSize);
|
|
|
}
|
|
|
|
|
|
static PySequenceMethods BufferSegment_sq = {
|
|
|
(lenfunc)BufferSegment_length, /* sq_length */
|
|
|
0, /* sq_concat */
|
|
|
0, /* sq_repeat */
|
|
|
0, /* sq_item */
|
|
|
0, /* sq_ass_item */
|
|
|
0, /* sq_contains */
|
|
|
0, /* sq_inplace_concat */
|
|
|
0 /* sq_inplace_repeat */
|
|
|
};
|
|
|
|
|
|
static PyBufferProcs BufferSegment_as_buffer = {
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
|
(getbufferproc)BufferSegment_getbuffer,
|
|
|
0
|
|
|
#else
|
|
|
(readbufferproc)BufferSegment_getreadbuffer,
|
|
|
0,
|
|
|
(segcountproc)BufferSegment_getsegcount,
|
|
|
0
|
|
|
#endif
|
|
|
};
|
|
|
|
|
|
static PyMethodDef BufferSegment_methods[] = {
|
|
|
{ "tobytes", (PyCFunction)BufferSegment_tobytes,
|
|
|
METH_NOARGS, BufferSegment_tobytes__doc__ },
|
|
|
{ NULL, NULL }
|
|
|
};
|
|
|
|
|
|
static PyMemberDef BufferSegment_members[] = {
|
|
|
{ "offset", T_ULONGLONG, offsetof(ZstdBufferSegment, offset), READONLY,
|
|
|
"offset of segment within parent buffer" },
|
|
|
{ NULL }
|
|
|
};
|
|
|
|
|
|
PyTypeObject ZstdBufferSegmentType = {
|
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
|
"zstd.BufferSegment", /* tp_name */
|
|
|
sizeof(ZstdBufferSegment),/* tp_basicsize */
|
|
|
0, /* tp_itemsize */
|
|
|
(destructor)BufferSegment_dealloc, /* tp_dealloc */
|
|
|
0, /* tp_print */
|
|
|
0, /* tp_getattr */
|
|
|
0, /* tp_setattr */
|
|
|
0, /* tp_compare */
|
|
|
0, /* tp_repr */
|
|
|
0, /* tp_as_number */
|
|
|
&BufferSegment_sq, /* tp_as_sequence */
|
|
|
0, /* tp_as_mapping */
|
|
|
0, /* tp_hash */
|
|
|
0, /* tp_call */
|
|
|
0, /* tp_str */
|
|
|
0, /* tp_getattro */
|
|
|
0, /* tp_setattro */
|
|
|
&BufferSegment_as_buffer, /* tp_as_buffer */
|
|
|
Py_TPFLAGS_DEFAULT, /* tp_flags */
|
|
|
BufferSegment__doc__, /* tp_doc */
|
|
|
0, /* tp_traverse */
|
|
|
0, /* tp_clear */
|
|
|
0, /* tp_richcompare */
|
|
|
0, /* tp_weaklistoffset */
|
|
|
0, /* tp_iter */
|
|
|
0, /* tp_iternext */
|
|
|
BufferSegment_methods, /* tp_methods */
|
|
|
BufferSegment_members, /* tp_members */
|
|
|
0, /* tp_getset */
|
|
|
0, /* tp_base */
|
|
|
0, /* tp_dict */
|
|
|
0, /* tp_descr_get */
|
|
|
0, /* tp_descr_set */
|
|
|
0, /* tp_dictoffset */
|
|
|
0, /* tp_init */
|
|
|
0, /* tp_alloc */
|
|
|
PyType_GenericNew, /* tp_new */
|
|
|
};
|
|
|
|
|
|
PyDoc_STRVAR(BufferWithSegmentsCollection__doc__,
|
|
|
"Represents a collection of BufferWithSegments.\n"
|
|
|
);
|
|
|
|
|
|
static void BufferWithSegmentsCollection_dealloc(ZstdBufferWithSegmentsCollection* self) {
|
|
|
Py_ssize_t i;
|
|
|
|
|
|
if (self->firstElements) {
|
|
|
PyMem_Free(self->firstElements);
|
|
|
self->firstElements = NULL;
|
|
|
}
|
|
|
|
|
|
if (self->buffers) {
|
|
|
for (i = 0; i < self->bufferCount; i++) {
|
|
|
Py_CLEAR(self->buffers[i]);
|
|
|
}
|
|
|
|
|
|
PyMem_Free(self->buffers);
|
|
|
self->buffers = NULL;
|
|
|
}
|
|
|
|
|
|
PyObject_Del(self);
|
|
|
}
|
|
|
|
|
|
static int BufferWithSegmentsCollection_init(ZstdBufferWithSegmentsCollection* self, PyObject* args) {
|
|
|
Py_ssize_t size;
|
|
|
Py_ssize_t i;
|
|
|
Py_ssize_t offset = 0;
|
|
|
|
|
|
size = PyTuple_Size(args);
|
|
|
if (-1 == size) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
if (0 == size) {
|
|
|
PyErr_SetString(PyExc_ValueError, "must pass at least 1 argument");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
PyObject* item = PyTuple_GET_ITEM(args, i);
|
|
|
if (!PyObject_TypeCheck(item, &ZstdBufferWithSegmentsType)) {
|
|
|
PyErr_SetString(PyExc_TypeError, "arguments must be BufferWithSegments instances");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
if (0 == ((ZstdBufferWithSegments*)item)->segmentCount ||
|
|
|
0 == ((ZstdBufferWithSegments*)item)->dataSize) {
|
|
|
PyErr_SetString(PyExc_ValueError, "ZstdBufferWithSegments cannot be empty");
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
self->buffers = PyMem_Malloc(size * sizeof(ZstdBufferWithSegments*));
|
|
|
if (NULL == self->buffers) {
|
|
|
PyErr_NoMemory();
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
self->firstElements = PyMem_Malloc(size * sizeof(Py_ssize_t));
|
|
|
if (NULL == self->firstElements) {
|
|
|
PyMem_Free(self->buffers);
|
|
|
self->buffers = NULL;
|
|
|
PyErr_NoMemory();
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
self->bufferCount = size;
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
ZstdBufferWithSegments* item = (ZstdBufferWithSegments*)PyTuple_GET_ITEM(args, i);
|
|
|
|
|
|
self->buffers[i] = item;
|
|
|
Py_INCREF(item);
|
|
|
|
|
|
if (i > 0) {
|
|
|
self->firstElements[i - 1] = offset;
|
|
|
}
|
|
|
|
|
|
offset += item->segmentCount;
|
|
|
}
|
|
|
|
|
|
self->firstElements[size - 1] = offset;
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
static PyObject* BufferWithSegmentsCollection_size(ZstdBufferWithSegmentsCollection* self) {
|
|
|
Py_ssize_t i;
|
|
|
Py_ssize_t j;
|
|
|
unsigned long long size = 0;
|
|
|
|
|
|
for (i = 0; i < self->bufferCount; i++) {
|
|
|
for (j = 0; j < self->buffers[i]->segmentCount; j++) {
|
|
|
size += self->buffers[i]->segments[j].length;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return PyLong_FromUnsignedLongLong(size);
|
|
|
}
|
|
|
|
|
|
Py_ssize_t BufferWithSegmentsCollection_length(ZstdBufferWithSegmentsCollection* self) {
|
|
|
return self->firstElements[self->bufferCount - 1];
|
|
|
}
|
|
|
|
|
|
static ZstdBufferSegment* BufferWithSegmentsCollection_item(ZstdBufferWithSegmentsCollection* self, Py_ssize_t i) {
|
|
|
Py_ssize_t bufferOffset;
|
|
|
|
|
|
if (i < 0) {
|
|
|
PyErr_SetString(PyExc_IndexError, "offset must be non-negative");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
if (i >= BufferWithSegmentsCollection_length(self)) {
|
|
|
PyErr_Format(PyExc_IndexError, "offset must be less than %zd",
|
|
|
BufferWithSegmentsCollection_length(self));
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
for (bufferOffset = 0; bufferOffset < self->bufferCount; bufferOffset++) {
|
|
|
Py_ssize_t offset = 0;
|
|
|
|
|
|
if (i < self->firstElements[bufferOffset]) {
|
|
|
if (bufferOffset > 0) {
|
|
|
offset = self->firstElements[bufferOffset - 1];
|
|
|
}
|
|
|
|
|
|
return BufferWithSegments_item(self->buffers[bufferOffset], i - offset);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
PyErr_SetString(ZstdError, "error resolving segment; this should not happen");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
static PySequenceMethods BufferWithSegmentsCollection_sq = {
|
|
|
(lenfunc)BufferWithSegmentsCollection_length, /* sq_length */
|
|
|
0, /* sq_concat */
|
|
|
0, /* sq_repeat */
|
|
|
(ssizeargfunc)BufferWithSegmentsCollection_item, /* sq_item */
|
|
|
0, /* sq_ass_item */
|
|
|
0, /* sq_contains */
|
|
|
0, /* sq_inplace_concat */
|
|
|
0 /* sq_inplace_repeat */
|
|
|
};
|
|
|
|
|
|
static PyMethodDef BufferWithSegmentsCollection_methods[] = {
|
|
|
{ "size", (PyCFunction)BufferWithSegmentsCollection_size,
|
|
|
METH_NOARGS, PyDoc_STR("total size in bytes of all segments") },
|
|
|
{ NULL, NULL }
|
|
|
};
|
|
|
|
|
|
PyTypeObject ZstdBufferWithSegmentsCollectionType = {
|
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
|
"zstd.BufferWithSegmentsCollection", /* tp_name */
|
|
|
sizeof(ZstdBufferWithSegmentsCollection),/* tp_basicsize */
|
|
|
0, /* tp_itemsize */
|
|
|
(destructor)BufferWithSegmentsCollection_dealloc, /* tp_dealloc */
|
|
|
0, /* tp_print */
|
|
|
0, /* tp_getattr */
|
|
|
0, /* tp_setattr */
|
|
|
0, /* tp_compare */
|
|
|
0, /* tp_repr */
|
|
|
0, /* tp_as_number */
|
|
|
&BufferWithSegmentsCollection_sq, /* tp_as_sequence */
|
|
|
0, /* tp_as_mapping */
|
|
|
0, /* tp_hash */
|
|
|
0, /* tp_call */
|
|
|
0, /* tp_str */
|
|
|
0, /* tp_getattro */
|
|
|
0, /* tp_setattro */
|
|
|
0, /* tp_as_buffer */
|
|
|
Py_TPFLAGS_DEFAULT, /* tp_flags */
|
|
|
BufferWithSegmentsCollection__doc__, /* tp_doc */
|
|
|
0, /* tp_traverse */
|
|
|
0, /* tp_clear */
|
|
|
0, /* tp_richcompare */
|
|
|
0, /* tp_weaklistoffset */
|
|
|
/* TODO implement iterator for performance. */
|
|
|
0, /* tp_iter */
|
|
|
0, /* tp_iternext */
|
|
|
BufferWithSegmentsCollection_methods, /* tp_methods */
|
|
|
0, /* tp_members */
|
|
|
0, /* tp_getset */
|
|
|
0, /* tp_base */
|
|
|
0, /* tp_dict */
|
|
|
0, /* tp_descr_get */
|
|
|
0, /* tp_descr_set */
|
|
|
0, /* tp_dictoffset */
|
|
|
(initproc)BufferWithSegmentsCollection_init, /* tp_init */
|
|
|
0, /* tp_alloc */
|
|
|
PyType_GenericNew, /* tp_new */
|
|
|
};
|
|
|
|
|
|
void bufferutil_module_init(PyObject* mod) {
|
|
|
Py_TYPE(&ZstdBufferWithSegmentsType) = &PyType_Type;
|
|
|
if (PyType_Ready(&ZstdBufferWithSegmentsType) < 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
Py_INCREF(&ZstdBufferWithSegmentsType);
|
|
|
PyModule_AddObject(mod, "BufferWithSegments", (PyObject*)&ZstdBufferWithSegmentsType);
|
|
|
|
|
|
Py_TYPE(&ZstdBufferSegmentsType) = &PyType_Type;
|
|
|
if (PyType_Ready(&ZstdBufferSegmentsType) < 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
Py_INCREF(&ZstdBufferSegmentsType);
|
|
|
PyModule_AddObject(mod, "BufferSegments", (PyObject*)&ZstdBufferSegmentsType);
|
|
|
|
|
|
Py_TYPE(&ZstdBufferSegmentType) = &PyType_Type;
|
|
|
if (PyType_Ready(&ZstdBufferSegmentType) < 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
Py_INCREF(&ZstdBufferSegmentType);
|
|
|
PyModule_AddObject(mod, "BufferSegment", (PyObject*)&ZstdBufferSegmentType);
|
|
|
|
|
|
Py_TYPE(&ZstdBufferWithSegmentsCollectionType) = &PyType_Type;
|
|
|
if (PyType_Ready(&ZstdBufferWithSegmentsCollectionType) < 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
Py_INCREF(&ZstdBufferWithSegmentsCollectionType);
|
|
|
PyModule_AddObject(mod, "BufferWithSegmentsCollection", (PyObject*)&ZstdBufferWithSegmentsCollectionType);
|
|
|
}
|
|
|
|
