ImageBase.h

Go to the documentation of this file.

/* $Id: ImageBase.h 35082 2011-02-22 19:30:37Z jesterking $
-----------------------------------------------------------------------------
This source file is part of blendTex 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.
-----------------------------------------------------------------------------
*/

#if !defined IMAGEBASE_H
#define IMAGEBASE_H

#include "Common.h"

#include <vector>
#include <PyObjectPlus.h>

#include "PyTypeList.h"

#include "FilterBase.h"


// forward declarations
struct PyImage;
class ImageSource;


typedef std::vector<ImageSource*> ImageSourceList;


class ImageBase
{
public:
        ImageBase (bool staticSrc = false);
        virtual ~ImageBase (void);
        virtual bool release (void);

        bool isImageAvailable(void)
        { return m_avail; }
        unsigned int * getImage (unsigned int texId = 0, double timestamp=-1.0);
        short * getSize (void) { return m_size; }
        unsigned long getBuffSize (void)
        { return m_size[0] * m_size[1] * sizeof(unsigned int); }
        virtual void refresh (void);

        bool getScale (void) { return m_scale; }
        void setScale (bool scale) { m_scale = scale; m_scaleChange = true; }
        bool getFlip (void) { return m_flip; }
        void setFlip (bool flip) { m_flip = flip; }

        PyImage * getSource (const char * id);
        bool setSource (const char * id, PyImage * source);

        PyFilter * getFilter (void) { return m_pyfilter; }
        void setFilter (PyFilter * filt);

        static short calcSize (short size);

        int m_exports;

protected:
        unsigned int * m_image;
        unsigned int m_imgSize;
        short m_size[2];
        bool m_avail;

        bool m_scale;
        bool m_scaleChange;
        bool m_flip;

        ImageSourceList m_sources;
        bool m_staticSources;

        PyFilter * m_pyfilter;

        void init (short width, short height);

        ImageSourceList::iterator findSource (const char * id);

        virtual ImageSource * newSource (const char * id) { return NULL; }

        bool checkSourceSizes (void);

        virtual void calcImage (unsigned int texId, double ts) {}

        bool loopDetect (ImageBase * img);

        template<class FLT, class SRC> void convImage (FLT & filter, SRC srcBuff,
                short * srcSize)
        {
                // destination buffer
                unsigned int * dstBuff = m_image;
                // pixel size from filter
                unsigned int pixSize = filter.firstPixelSize();
                // if no scaling is needed
                if (srcSize[0] == m_size[0] && srcSize[1] == m_size[1])
                        // if flipping isn't required
                        if (!m_flip)
                                // copy bitmap
                                for (short y = 0; y < m_size[1]; ++y)
                                        for (short x = 0; x < m_size[0]; ++x, ++dstBuff, srcBuff += pixSize)
                                                // copy pixel
                                                *dstBuff = filter.convert(srcBuff, x, y, srcSize, pixSize);
                // otherwise flip image top to bottom
                        else
                        {
                                // go to last row of image
                                srcBuff += srcSize[0] * (srcSize[1] - 1) * pixSize;
                                // copy bitmap
                                for (short y = m_size[1] - 1; y >= 0; --y, srcBuff -= 2 * srcSize[0] * pixSize)
                                        for (short x = 0; x < m_size[0]; ++x, ++dstBuff, srcBuff += pixSize)
                                                // copy pixel
                                                *dstBuff = filter.convert(srcBuff, x, y, srcSize, pixSize);
                        }
                        // else scale picture (nearest neighbour)
                else
                {
                        // interpolation accumulator
                        int accHeight = srcSize[1] >> 1;
                        // if flipping is required
                        if (m_flip)
                                // go to last row of image
                                srcBuff += srcSize[0] * (srcSize[1] - 1) * pixSize;
                        // process image rows
                        for (int y = 0; y < srcSize[1]; ++y)
                        {
                                // increase height accum
                                accHeight += m_size[1];
                                // if pixel row has to be drawn
                                if (accHeight >= srcSize[1])
                                {
                                        // decrease accum
                                        accHeight -= srcSize[1];
                                        // width accum
                                        int accWidth = srcSize[0] >> 1;
                                        // process row
                                        for (int x = 0; x < srcSize[0]; ++x)
                                        {
                                                // increase width accum
                                                accWidth += m_size[0];
                                                // if pixel has to be drawn
                                                if (accWidth >= srcSize[0])
                                                {
                                                        // decrease accum
                                                        accWidth -= srcSize[0];
                                                        // convert pixel
                                                        *dstBuff = filter.convert(srcBuff, x, m_flip ? srcSize[1] - y - 1 : y,
                                                                srcSize, pixSize);
                                                        // next pixel
                                                        ++dstBuff;
                                                }
                                                // shift source pointer
                                                srcBuff += pixSize;
                                        }
                                }
                                // if pixel row will not be drawn
                                else
                                        // move source pointer to next row
                                        srcBuff += pixSize * srcSize[0];
                                // if y flipping is required
                                if (m_flip)
                                        // go to previous row of image
                                        srcBuff -= 2 * pixSize * srcSize[0];
                        }
                }
        }

        // template for specific filter preprocessing
        template <class F, class SRC> void filterImage (F & filt, SRC srcBuff, short * srcSize)
        {
                // find first filter in chain
                FilterBase * firstFilter = NULL;
                if (m_pyfilter != NULL) firstFilter = m_pyfilter->m_filter->findFirst();
                // if first filter is available
                if (firstFilter != NULL)
                {
                        // python wrapper for filter
                        PyFilter pyFilt;
                        pyFilt.m_filter = &filt;
                        // set specified filter as first in chain
                        firstFilter->setPrevious(&pyFilt, false);
                        // convert video image
                        convImage(*(m_pyfilter->m_filter), srcBuff, srcSize);
                        // delete added filter
                        firstFilter->setPrevious(NULL, false);
                }
                // otherwise use given filter for conversion
                else convImage(filt, srcBuff, srcSize);
                // source was processed
                m_avail = true;
        }
};


// python structure for image filter
struct PyImage
{
        PyObject_HEAD
        // source object
        ImageBase * m_image;
};


// size of id
const int SourceIdSize = 32;


class ImageSource
{
public:
        ImageSource (const char * id);
        virtual ~ImageSource (void);

        const char * getId (void) { return m_id; }
        bool is (const char * id);

        PyImage * getSource (void) { return m_source; }
        void setSource (PyImage * source);

        unsigned int * getImage (double ts=-1.0);
        unsigned int * getImageBuf (void) { return m_image; }
        void refresh (void);

        short * getSize (void)
        { 
                static short defSize [] = {0, 0};
                return m_source != NULL ? m_source->m_image->getSize() : defSize;
        }

protected:
        char m_id [SourceIdSize];
        PyImage * m_source;
        unsigned int * m_image;

private:
        ImageSource (void) {}
};

// list of python image types
extern PyTypeList pyImageTypes;


// functions for python interface

// object initialization
template <class T> static int Image_init (PyObject * pySelf, PyObject * args, PyObject * kwds)
{
        PyImage * self = reinterpret_cast<PyImage*>(pySelf);
        // create source object
        if (self->m_image != NULL) delete self->m_image;
        self->m_image = new T();
        // initialization succeded
        return 0;
}

// object allocation
PyObject * Image_allocNew (PyTypeObject * type, PyObject * args, PyObject * kwds);
// object deallocation
void Image_dealloc (PyImage * self);

// get image data
PyObject * Image_getImage (PyImage * self, char * mode);
// get image size
PyObject * Image_getSize (PyImage * self, void * closure);
// refresh image - invalidate current content
PyObject * Image_refresh (PyImage * self);

// get scale
PyObject * Image_getScale (PyImage * self, void * closure);
// set scale
int Image_setScale (PyImage * self, PyObject * value, void * closure);
// get flip
PyObject * Image_getFlip (PyImage * self, void * closure);
// set flip
int Image_setFlip (PyImage * self, PyObject * value, void * closure);

// get filter source object
PyObject * Image_getSource (PyImage * self, PyObject * args);
// set filter source object
PyObject * Image_setSource (PyImage * self, PyObject * args);

// get pixel filter object
PyObject * Image_getFilter (PyImage * self, void * closure);
// set pixel filter object
int Image_setFilter (PyImage * self, PyObject * value, void * closure);
// check if a buffer can be extracted
PyObject * Image_valid(PyImage * self, void * closure);
// for buffer access to PyImage objects
extern PyBufferProcs imageBufferProcs;

#endif