PyObject *memory_as_pybuffer(void *ptr, Py_ssize_t buf_len, int readonly) {
Py_buffer pybuf;
Py_ssize_t shape[] = {buf_len};
int ret;
if (readonly)
ret = PyBuffer_FillInfo(&pybuf, NULL, ptr, buf_len, 0, PyBUF_SIMPLE);
else
ret = PyBuffer_FillInfo(&pybuf, NULL, ptr, buf_len, 0, PyBUF_WRITABLE);
if (ret!=0)
return NULL;
pybuf.format = "B";
pybuf.shape = shape;
return PyMemoryView_FromBuffer(&pybuf);
}
static int
Blob_getbuffer(Blob *self, Py_buffer *view, int flags)
{
return PyBuffer_FillInfo(view, (PyObject *) self,
(void *) git_blob_rawcontent(self->blob),
git_blob_rawsize(self->blob), 1, flags);
}
static int
asciistr_getbuffer(PyObject *exporter, Py_buffer *view, int flags)
{
return (PyBuffer_FillInfo(view, exporter, PyUnicode_DATA(exporter),
PyUnicode_GET_LENGTH(exporter), 1, flags));
}
static int Image_getbuffer(PyImage *self, Py_buffer *view, int flags)
{
unsigned int * image;
int ret;
try {
// can throw in case of resize
image = self->m_image->getImage();
}
catch (Exception & exp) {
exp.report();
return -1;
}
if (!image) {
PyErr_SetString(PyExc_BufferError, "Image buffer is not available");
return -1;
}
if (view == NULL)
{
self->m_image->m_exports++;
return 0;
}
ret = PyBuffer_FillInfo(view, (PyObject *)self, image, self->m_image->getBuffSize(), 0, flags);
if (ret >= 0)
self->m_image->m_exports++;
return ret;
}
static int PyPointlessVector_getbuffer(PyPointlessVector* self, Py_buffer* view, int flags)
{
if (view == 0)
return 0;
void* ptr = pointless_prim_vector_base_ptr(self);
return PyBuffer_FillInfo(view, (PyObject*)self, ptr, pointless_vector_n_bytes(self), 0, flags);
}
static int Image_getbuffer(PyImage *self, Py_buffer *view, int flags)
{
unsigned int * image;
int ret;
try
{
// can throw in case of resize
image = self->m_image->getImage();
}
catch (Exception & exp)
{
// cannot return -1, this creates a crash in Python, for now we will just return an empty buffer
exp.report();
//return -1;
goto error;
}
if (!image)
{
// same remark, see above
//PyErr_SetString(PyExc_BufferError, "Image buffer is not available");
//return -1;
goto error;
}
if (view == NULL)
{
self->m_image->m_exports++;
return 0;
}
ret = PyBuffer_FillInfo(view, (PyObject *)self, image, self->m_image->getBuffSize(), 0, flags);
if (ret >= 0)
self->m_image->m_exports++;
return ret;
error:
// Return a empty buffer to avoid a crash in Python 3.1
// The bug is fixed in Python SVN 77916, as soon as the python revision used by Blender is
// updated, you can simply return -1 and set the error
static char* buf = (char *)"";
ret = PyBuffer_FillInfo(view, (PyObject *)self, buf, 0, 0, flags);
if (ret >= 0)
self->m_image->m_exports++;
return ret;
}
static int buffer_getbuffer(PyBufferObject *self, Py_buffer *buf, int flags)
{
void *ptr;
Py_ssize_t size;
if (!get_buf(self, &ptr, &size, ANY_BUFFER))
return -1;
return PyBuffer_FillInfo(buf, (PyObject*)self, ptr, size,
self->b_readonly, flags);
}
static int
stolenbuf_getbuffer(stolenbufobject *self, Py_buffer *view, int flags)
{
return PyBuffer_FillInfo(view,
(PyObject*) self,
(void*) PyString_AS_STRING(self->invalid_bytes),
PyString_GET_SIZE(self->invalid_bytes),
0, /* not readonly */
flags);
}
static int
mmap_buffer_getbuf(mmap_object *self, Py_buffer *view, int flags)
{
CHECK_VALID(-1);
if (PyBuffer_FillInfo(view, (PyObject*)self, self->data, self->size,
(self->access == ACCESS_READ), flags) < 0)
return -1;
self->exports++;
return 0;
}
/* 3.0 buffer interface */
int chunk_getbuffer(PyObject *_self, Py_buffer *view, int flags)
{
int rv;
chunkObject *self = (chunkObject*)_self;
rv = PyBuffer_FillInfo(view, _self, self->base, self->len, 1, flags);
if (rv == 0) {
view->format = "c";
}
return rv;
}
/*
* The buffer implementation for Python v2.6 and later.
*/
static int sipVoidPtr_getbuffer(PyObject *self, Py_buffer *buf, int flags)
{
sipVoidPtrObject *v;
if (check_size(self) < 0)
return -1;
v = (sipVoidPtrObject *)self;
return PyBuffer_FillInfo(buf, self, v->voidptr, v->size, !v->rw, flags);
}
PyObject *
PyBuffer_FromMemory(void *data, Py_ssize_t len)
{
Py_buffer buffer;
PyObject *mv;
PyBuffer_FillInfo(&buffer, NULL, data, len, 1, PyBUF_CONTIG_RO);
mv = PyMemoryView_FromBuffer(&buffer);
PyBuffer_Release(&buffer);
return mv;
}
int MemInfo_getbuffer(PyObject *exporter, Py_buffer *view, int flags) {
Py_ssize_t len;
void *buf;
int readonly = 0;
MemInfoObject *miobj = (MemInfoObject*)exporter;
MemInfo *mi = miobj->meminfo;
buf = NRT_MemInfo_data(mi);
len = NRT_MemInfo_size(mi);
return PyBuffer_FillInfo(view, exporter, buf, len, readonly, flags);
}
static int
MemAllocObject_getbufferproc(PyObject *self, Py_buffer *view, int flags)
{
Py_ssize_t size = 0;
void *ptr = 0;
int readonly;
if(-1 == get_bufinfo(self, &size, &ptr))
return -1;
readonly = (PyBUF_WRITABLE & flags) != PyBUF_WRITABLE;
/* fill buffer */
if (-1 == PyBuffer_FillInfo(view, self, (void*)ptr, size, readonly, flags))
return -1;
return 0;
}
PyObject* make_mview(const TCPStream::payload_type& payload) {
// make a python memoryview corresponding to the vector<uint8_t> payload
const uint8_t* buf = &(payload[0]);
size_t buf_size = payload.size();
Py_buffer* viewinfo = (Py_buffer*) PyMem_Malloc(sizeof(Py_buffer));
if (viewinfo == 0) {
throw std::bad_alloc(); // malloc error
}
if (PyBuffer_FillInfo(viewinfo, 0, (void*) buf, (Py_ssize_t) buf_size, 1, PyBUF_FULL_RO) != 0) {
PyMem_Free((void*) viewinfo);
throw std::runtime_error("PyBuffer_FillInfo failed in TCPStreamPyFunctor::make_mview");
}
PyObject* mview = PyMemoryView_FromBuffer(viewinfo); // new reference
if (mview == 0) {
PyMem_Free((void*) viewinfo);
throw std::runtime_error("PyMemoryView_FromBuffer failed in TCPStreamPyFunctor::make_mview");
}
return mview;
}
static int BPy_IDArray_getbuffer(BPy_IDArray *self, Py_buffer *view, int flags)
{
IDProperty *prop = self->prop;
int itemsize = itemsize_by_idarray_type(prop->subtype);
int length = itemsize * prop->len;
if (PyBuffer_FillInfo(view, (PyObject *)self, IDP_Array(prop), length, false, flags) == -1) {
return -1;
}
view->itemsize = itemsize;
view->format = (char *)idp_format_from_array_type(prop->subtype);
Py_ssize_t *shape = MEM_mallocN(sizeof(Py_ssize_t), __func__);
shape[0] = prop->len;
view->shape = shape;
return 0;
}
static int get_buffer(PyObject* obj, Py_buffer *buf, int force)
{
Py_buffer read_buf;
int flags = PyBUF_ND|PyBUF_STRIDES|PyBUF_FORMAT;
int ret;
/* Attempt to get a writable buffer */
if (!PyObject_GetBuffer(obj, buf, flags|PyBUF_WRITABLE))
return 0;
if (!force)
return -1;
/* Make a writable buffer from a read-only buffer */
PyErr_Clear();
if(-1 == PyObject_GetBuffer(obj, &read_buf, flags))
return -1;
ret = PyBuffer_FillInfo(buf, NULL, read_buf.buf, read_buf.len, 0,
flags|PyBUF_WRITABLE);
PyBuffer_Release(&read_buf);
return ret;
}
