ImageBuff.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
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;

static int ImageBuff_init (PyObject * pySelf, PyObject * args, PyObject * kwds)
{
    short width = -1;
    short height = -1;
    unsigned char color = 0;
    PyObject *py_scale = Py_False;
    ImageBuff *image;

    PyImage * self = reinterpret_cast<PyImage*>(pySelf);
    // create source object
    if (self->m_image != NULL) 
        delete self->m_image;
    image = new ImageBuff();
    self->m_image = image;

    if (PyArg_ParseTuple(args, "hh|bO!:ImageBuff", &width, &height, &color, &PyBool_Type, &py_scale)) 
    {
        // initialize image buffer
        image->setScale(py_scale == Py_True);
        image->clear(width, height, color);
    }
    else
    {
        // check if at least one argument was passed
        if (width != -1 || height != -1)
            // yes and they didn't match => it's an error
            return -1;
        // empty argument list is okay
        PyErr_Clear();
    }
    // initialization succeded
    return 0;

}

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;
}

void ImageBuff::clear (short width, short height, unsigned char color)
{
    unsigned char *p;
    int size;

    // 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);
    // the width/height may be different due to scaling
    size = (m_size[0] * m_size[1]);
    // initialize memory with color for all channels
    memset(m_image, color, size*4);
    // and change the alpha channel
    p = &((unsigned char*)m_image)[3];
    for (; size>0; size--)
    {
        *p = 0xFF;
        p += 4;
    }
    // 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);
    }

    tmpbuf = IMB_allocImBuf(width, height, 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);
    }
    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);
    }
    // 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)ImageBuff_init,     /* tp_init */
    0,                         /* tp_alloc */
    Image_allocNew,           /* tp_new */
};