37b9c9fe4d
- Use BGL buffer instead of string for image data.
- Add buffer interface to image source.
- Allow customization of pixel format.
- Add valid property to check if the image data is available.
The image property of all Image source objects will now
return a BGL 'buffer' object. Previously it was returning
a string, which was not working at all with Python 3.1.
The BGL buffer type allows sequence access to bytes and
is directly usable in BGL OpenGL wrapper functions.
The buffer is formated as a 1 dimensional array of bytes
with 4 bytes per pixel in RGBA order.
BGL buffers will also be accepted in the ImageBuff load()
and plot() functions.
It is possible to customize the pixel format by using
the VideoTexture.imageToArray(image, mode) function:
the first argument is a Image source object, the second
optional argument is a format string using the R, G, B,
A, 0 and 1 characters. For example "BGR" means that each
pixel will be 3 bytes, corresponding to the Blue, Green
and Red channel in that order. Use 0 for a fixed hex 00
value, 1 for hex FF. The default mode is "RGBA".
All Image source objects now support the buffer interface
which allows to create memoryview objects for direct access
to the image internal buffer without memory copy. The buffer
format is one dimensional array of bytes with 4 bytes per
pixel in RGBA order. The buffer is writable, which allows
custom modifications of the image data.
v = memoryview(source)
A bug in the Python 3.1 buffer API will cause a crash if
the memoryview object cannot be created. Therefore, you
must always check first that an image data is available
before creating a memoryview object. Use the new valid
attribute for that:
if source.valid:
v = memoryview(source)
...
Note: the BGL buffer object itself does not yet support
the buffer interface.
Note: the valid attribute makes sense only if you use
image source in conjunction with texture object like this:
# refresh texture but keep image data in memory
texture.refresh(False)
if texture.source.valid:
v = memoryview(texture.source)
# process image
...
# invalidate image for next texture refresh
texture.source.refresh()
Limitation: While memoryview objects exist, the image cannot be
resized. Resizing occurs with ImageViewport objects when the
viewport size is changed or with ImageFFmpeg when a new image
is reloaded for example. Any attempt to resize will cause a
runtime error. Delete the memoryview objects is you want to
resize an image source object.
356 lines
10 KiB
C++
356 lines
10 KiB
C++
/* $Id$
|
|
-----------------------------------------------------------------------------
|
|
This source file is part of VideoTexture library
|
|
|
|
Copyright (c) 2007 The Zdeno Ash Miklas
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU Lesser General Public License as published by the Free Software
|
|
Foundation; either version 2 of the License, or (at your option) any later
|
|
version.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
|
|
http://www.gnu.org/copyleft/lesser.txt.
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
// implementation
|
|
|
|
#include <PyObjectPlus.h>
|
|
#include <structmember.h>
|
|
|
|
#include "ImageBuff.h"
|
|
#include "Exception.h"
|
|
#include "ImageBase.h"
|
|
#include "FilterSource.h"
|
|
|
|
// use ImBuf API for image manipulation
|
|
extern "C" {
|
|
#include "IMB_imbuf_types.h"
|
|
#include "IMB_imbuf.h"
|
|
#include "BGL.h"
|
|
};
|
|
|
|
// default filter
|
|
FilterRGB24 defFilter;
|
|
|
|
// forward declaration;
|
|
extern PyTypeObject ImageBuffType;
|
|
|
|
ImageBuff::~ImageBuff (void)
|
|
{
|
|
if (m_imbuf)
|
|
IMB_freeImBuf(m_imbuf);
|
|
}
|
|
|
|
|
|
// load image from buffer
|
|
void ImageBuff::load (unsigned char * img, short width, short height)
|
|
{
|
|
// loading a new buffer implies to reset the imbuf if any, because the size may change
|
|
if (m_imbuf)
|
|
{
|
|
IMB_freeImBuf(m_imbuf);
|
|
m_imbuf = NULL;
|
|
}
|
|
// initialize image buffer
|
|
init(width, height);
|
|
// original size
|
|
short orgSize[2] = {width, height};
|
|
// is filter available
|
|
if (m_pyfilter != NULL)
|
|
// use it to process image
|
|
convImage(*(m_pyfilter->m_filter), img, orgSize);
|
|
else
|
|
// otherwise use default filter
|
|
convImage(defFilter, img, orgSize);
|
|
// image is available
|
|
m_avail = true;
|
|
}
|
|
|
|
// img must point to a array of RGBA data of size width*height
|
|
void ImageBuff::plot (unsigned char * img, short width, short height, short x, short y, short mode)
|
|
{
|
|
struct ImBuf* tmpbuf;
|
|
|
|
if (m_size[0] == 0 || m_size[1] == 0 || width <= 0 || height <= 0)
|
|
return;
|
|
|
|
if (!m_imbuf) {
|
|
// allocate most basic imbuf, we will assign the rect buffer on the fly
|
|
m_imbuf = IMB_allocImBuf(m_size[0], m_size[1], 0, 0, 0);
|
|
}
|
|
|
|
tmpbuf = IMB_allocImBuf(width, height, 0, 0, 0);
|
|
|
|
// assign temporarily our buffer to the ImBuf buffer, we use the same format
|
|
tmpbuf->rect = (unsigned int*)img;
|
|
m_imbuf->rect = m_image;
|
|
IMB_rectblend(m_imbuf, tmpbuf, x, y, 0, 0, width, height, (IMB_BlendMode)mode);
|
|
// remove so that MB_freeImBuf will free our buffer
|
|
m_imbuf->rect = NULL;
|
|
tmpbuf->rect = NULL;
|
|
IMB_freeImBuf(tmpbuf);
|
|
}
|
|
|
|
void ImageBuff::plot (ImageBuff* img, short x, short y, short mode)
|
|
{
|
|
if (m_size[0] == 0 || m_size[1] == 0 || img->m_size[0] == 0 || img->m_size[1] == 0)
|
|
return;
|
|
|
|
if (!m_imbuf) {
|
|
// allocate most basic imbuf, we will assign the rect buffer on the fly
|
|
m_imbuf = IMB_allocImBuf(m_size[0], m_size[1], 0, 0, 0);
|
|
}
|
|
if (!img->m_imbuf) {
|
|
// allocate most basic imbuf, we will assign the rect buffer on the fly
|
|
img->m_imbuf = IMB_allocImBuf(img->m_size[0], img->m_size[1], 0, 0, 0);
|
|
}
|
|
// assign temporarily our buffer to the ImBuf buffer, we use the same format
|
|
img->m_imbuf->rect = img->m_image;
|
|
m_imbuf->rect = m_image;
|
|
IMB_rectblend(m_imbuf, img->m_imbuf, x, y, 0, 0, img->m_imbuf->x, img->m_imbuf->y, (IMB_BlendMode)mode);
|
|
// remove so that MB_freeImBuf will free our buffer
|
|
m_imbuf->rect = NULL;
|
|
img->m_imbuf->rect = NULL;
|
|
}
|
|
|
|
|
|
// cast Image pointer to ImageBuff
|
|
inline ImageBuff * getImageBuff (PyImage * self)
|
|
{ return static_cast<ImageBuff*>(self->m_image); }
|
|
|
|
|
|
// python methods
|
|
|
|
static bool testPyBuffer(Py_buffer* buffer, int width, int height, unsigned int pixsize)
|
|
{
|
|
if (buffer->itemsize != 1)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "Buffer must be an array of bytes");
|
|
return false;
|
|
}
|
|
if (buffer->len != width*height*pixsize)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "Buffer hasn't the correct size");
|
|
return false;
|
|
}
|
|
// multi dimension are ok as long as there is no hole in the memory
|
|
Py_ssize_t size = buffer->itemsize;
|
|
for (int i=buffer->ndim-1; i>=0 ; i--)
|
|
{
|
|
if (buffer->suboffsets != NULL && buffer->suboffsets[i] >= 0)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "Buffer must be of one block");
|
|
return false;
|
|
}
|
|
if (buffer->strides != NULL && buffer->strides[i] != size)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "Buffer must be of one block");
|
|
return false;
|
|
}
|
|
if (i > 0)
|
|
size *= buffer->shape[i];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool testBGLBuffer(Buffer* buffer, int width, int height, unsigned int pixsize)
|
|
{
|
|
unsigned int size = BGL_typeSize(buffer->type);
|
|
for (int i=0; i<buffer->ndimensions; i++)
|
|
{
|
|
size *= buffer->dimensions[i];
|
|
}
|
|
if (size != width*height*pixsize)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "Buffer hasn't the correct size");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
// load image
|
|
static PyObject * load (PyImage * self, PyObject * args)
|
|
{
|
|
// parameters: string image buffer, its size, width, height
|
|
Py_buffer buffer;
|
|
Buffer *bglBuffer;
|
|
short width;
|
|
short height;
|
|
unsigned int pixSize;
|
|
|
|
// calc proper buffer size
|
|
// use pixel size from filter
|
|
if (self->m_image->getFilter() != NULL)
|
|
pixSize = self->m_image->getFilter()->m_filter->firstPixelSize();
|
|
else
|
|
pixSize = defFilter.firstPixelSize();
|
|
|
|
// parse parameters
|
|
if (!PyArg_ParseTuple(args, "s*hh:load", &buffer, &width, &height))
|
|
{
|
|
PyErr_Clear();
|
|
// check if it is BGL buffer
|
|
if (!PyArg_ParseTuple(args, "O!hh:load", &BGL_bufferType, &bglBuffer, &width, &height))
|
|
{
|
|
// report error
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
if (testBGLBuffer(bglBuffer, width, height, pixSize))
|
|
{
|
|
try
|
|
{
|
|
// if correct, load image
|
|
getImageBuff(self)->load((unsigned char*)bglBuffer->buf.asvoid, width, height);
|
|
}
|
|
catch (Exception & exp)
|
|
{
|
|
exp.report();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// check if buffer size is correct
|
|
if (testPyBuffer(&buffer, width, height, pixSize))
|
|
{
|
|
try
|
|
{
|
|
// if correct, load image
|
|
getImageBuff(self)->load((unsigned char*)buffer.buf, width, height);
|
|
}
|
|
catch (Exception & exp)
|
|
{
|
|
exp.report();
|
|
}
|
|
}
|
|
PyBuffer_Release(&buffer);
|
|
}
|
|
if (PyErr_Occurred())
|
|
return NULL;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject * plot (PyImage * self, PyObject * args)
|
|
{
|
|
PyImage * other;
|
|
Buffer* bglBuffer;
|
|
Py_buffer buffer;
|
|
//unsigned char * buff;
|
|
//unsigned int buffSize;
|
|
short width;
|
|
short height;
|
|
short x, y;
|
|
short mode = IMB_BLEND_COPY;
|
|
|
|
if (PyArg_ParseTuple(args, "s*hhhh|h:plot", &buffer, &width, &height, &x, &y, &mode))
|
|
{
|
|
// correct decoding, verify that buffer size is correct
|
|
// we need a continous memory buffer
|
|
if (testPyBuffer(&buffer, width, height, 4))
|
|
{
|
|
getImageBuff(self)->plot((unsigned char*)buffer.buf, width, height, x, y, mode);
|
|
}
|
|
PyBuffer_Release(&buffer);
|
|
if (PyErr_Occurred())
|
|
return NULL;
|
|
Py_RETURN_NONE;
|
|
}
|
|
PyErr_Clear();
|
|
// try the other format
|
|
if (PyArg_ParseTuple(args, "O!hh|h:plot", &ImageBuffType, &other, &x, &y, &mode))
|
|
{
|
|
getImageBuff(self)->plot(getImageBuff(other), x, y, mode);
|
|
Py_RETURN_NONE;
|
|
}
|
|
PyErr_Clear();
|
|
// try the last format (BGL buffer)
|
|
if (!PyArg_ParseTuple(args, "O!hhhh|h:plot", &BGL_bufferType, &bglBuffer, &width, &height, &x, &y, &mode))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "Expecting ImageBuff or Py buffer or BGL buffer as first argument; width, height next; postion x, y and mode as last arguments");
|
|
return NULL;
|
|
}
|
|
if (testBGLBuffer(bglBuffer, width, height, 4))
|
|
{
|
|
getImageBuff(self)->plot((unsigned char*)bglBuffer->buf.asvoid, width, height, x, y, mode);
|
|
}
|
|
if (PyErr_Occurred)
|
|
return NULL;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
// methods structure
|
|
static PyMethodDef imageBuffMethods[] =
|
|
{
|
|
{"load", (PyCFunction)load, METH_VARARGS, "Load image from buffer"},
|
|
{"plot", (PyCFunction)plot, METH_VARARGS, "update image buffer"},
|
|
{NULL}
|
|
};
|
|
// attributes structure
|
|
static PyGetSetDef imageBuffGetSets[] =
|
|
{ // attributes from ImageBase class
|
|
{(char*)"valid", (getter)Image_valid, NULL, (char*)"bool to tell if an image is available", NULL},
|
|
{(char*)"image", (getter)Image_getImage, NULL, (char*)"image data", NULL},
|
|
{(char*)"size", (getter)Image_getSize, NULL, (char*)"image size", NULL},
|
|
{(char*)"scale", (getter)Image_getScale, (setter)Image_setScale, (char*)"fast scale of image (near neighbour)", NULL},
|
|
{(char*)"flip", (getter)Image_getFlip, (setter)Image_setFlip, (char*)"flip image vertically", NULL},
|
|
{(char*)"filter", (getter)Image_getFilter, (setter)Image_setFilter, (char*)"pixel filter", NULL},
|
|
{NULL}
|
|
};
|
|
|
|
|
|
// define python type
|
|
PyTypeObject ImageBuffType =
|
|
{
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"VideoTexture.ImageBuff", /*tp_name*/
|
|
sizeof(PyImage), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
(destructor)Image_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*/
|
|
&imageBufferProcs, /*tp_as_buffer*/
|
|
Py_TPFLAGS_DEFAULT, /*tp_flags*/
|
|
"Image source from image buffer", /* tp_doc */
|
|
0, /* tp_traverse */
|
|
0, /* tp_clear */
|
|
0, /* tp_richcompare */
|
|
0, /* tp_weaklistoffset */
|
|
0, /* tp_iter */
|
|
0, /* tp_iternext */
|
|
imageBuffMethods, /* tp_methods */
|
|
0, /* tp_members */
|
|
imageBuffGetSets, /* tp_getset */
|
|
0, /* tp_base */
|
|
0, /* tp_dict */
|
|
0, /* tp_descr_get */
|
|
0, /* tp_descr_set */
|
|
0, /* tp_dictoffset */
|
|
(initproc)Image_init<ImageBuff>, /* tp_init */
|
|
0, /* tp_alloc */
|
|
Image_allocNew, /* tp_new */
|
|
};
|
|
|