IMG/IMG_TileMemBuf.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        RAY library shared memory interface (C++)
 *
 * COMMENTS:    This provides a shared memory interface for read/write
 *              of tiles generated by Mantra.  Mantra will write to
 *              the buffer and flag it as readable.  Until the buffer
 *              has been read, the buffer is flagged as "non-writable".
 *
 *      The data is structured as follows
 *              Index           Meaning
 *                0             Reference count on the memory
 *                1             Tile Width
 *                2             Tile Height
 *                3             Quit Flag
 *                4             Mouse X
 *                5             Mouse Y
 *                6             # Tiles written
 *                7             # Tiles read
 *                8             # Rasters queue size
 *                9
 *                10
 *                11
 *                12
 *                13
 *                14
 *                15
 *                raster data
 *
 *    Each raster data consists of:
 *      int     xl, xr, yb, yt;         // Coordinates of sub-raster
 *      void    *pixeldata;             // Contents of the raster
 *
 *   There will be multiple rasters stored in the raster data area.  The number
 *   of rasters is dependent on the amount of memory we want to take up.  If
 *   the tile size is bigger than the amount of memory, then we will only have
 *   one raster in the queue.  The fact that there are multiple rasters should
 *   cut down on inter-process latency (i.e. one process spinning while
 *   waiting).
 */

#ifndef __IMG_TileMemBuf_h__
#define __IMG_TileMemBuf_h__

#include "IMG_API.h"
#include <UT/UT_SysClone.h>
#include "IMG_TileBuffer.h"

class IMG_Raster;

// Memory used for raster queues
#define IMG_MAXRAM      16384

class IMG_API IMG_TileMemBuf : public IMG_TileBuffer {
public:
      IMG_TileMemBuf(); // Creator uses this
      IMG_TileMemBuf(int key_num, int size);    // Reader uses this constructor

     ~IMG_TileMemBuf();                 // Uses reference counting to
                                        // destroy actual shared memory

    virtual int          getTileWidth() const   { return getInt(1); }
    virtual int          getTileHeight() const  { return getInt(2); }

    virtual void         setQuitFlag(int val=1) { setInt(3, val); }
    virtual int          getQuitFlag() const    { return getInt(3); }

    virtual void         setMouseXY(int x, int y)       // Set render position
                         {
                            setInt(4, x);
                            setInt(5, y);
                         }
    virtual void         getMouseXY(int &x, int &y) const
                         {
                            x = getInt(4);
                            y = getInt(5);
                         }

    virtual int          canWriteTile() const
                         {
                            return getInt(6) <= getInt(7)+myQueueSize;
                         }
    virtual int          canReadTile() const
                         {
                             return getInt(6) > getInt(7);
                         }

    void                 resetMem();
    int                  createMem(int tileWidth, int tileHeight,
                                    unsigned maxmemory = IMG_MAXRAM);

    virtual void         writeTile(int xl, int xr, int yb, int yt,
                                   const void *data);
    virtual void         readTile(IMG_Raster &rp, int *coords=0);
    virtual void         getKeyString( char *str );

    int                  getKey() const { return myKeyId; }
    int                  getSize() const { return mySize; }

    virtual int          getInt(int offset) const;

protected:
    virtual void         bump(int offset)
                         {
                             setInt( offset, getInt( offset ) + 1 );
                         }
    virtual void         setTileSize(int w, int h)
                         {
                            setInt(1, w);
                            setInt(2, h);
                         }
    virtual void         setInt(int offset, int value);

private:
    void                *getMemory(int key_num, int size=0);
    void                 freeMemory();
    void                 buildOffsets(int tilex, int tiley);

    key_t                myKeyNum;
    int                  myKeyId;
    int                  mySize;
    int                  myQueueSize;   // Number of rasters - 1
    int                 *myOffsets;     // Offsets for each raster
    void                *myData;
};

#endif

---