IMG/IMG_TileDevice.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 Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        IMG_TileDevice.h ( IMG Library, C++)
 *
 * COMMENTS:    Class to define tile based I/O for mantra.
 *              When writing an image which has fields, the data sent to
 *              writeTile will not be interlaced.  It's the responsibility of
 *              the device to put in the appropriate data to the other fields.
 */

#ifndef __IMG_TileDevice__
#define __IMG_TileDevice__

#include "IMG_API.h"
#include <UT/UT_Rect.h>
#include <UT/UT_String.h>
#include <UT/UT_StringArray.h>
#include "IMG_FileTypes.h"

class UT_WorkBuffer;
class IMG_Raster;
class IMG_Format;
class IMG_TileInterface;
class IMG_TileOptions;
class IMG_TileOptionList;

class IMG_API IMG_TileDevice {
public:
             IMG_TileDevice();
    virtual ~IMG_TileDevice();

    enum {
        IMG_TILE_BOTTOM_FIRST = 0,
        IMG_TILE_RANDOM_ORDER = 1,
        IMG_TILE_TOP_FIRST = 2
    };

    int         isRandomAccess() const  { return myRandomAccess; }

    // Static methods to allocate new devices of specific types
    static IMG_TileDevice       *newFileDevice();
    static IMG_TileDevice       *newNullDevice();
    static IMG_TileDevice       *newMPlayDevice(int from_middle=1);
    static IMG_TileDevice       *imdisplayFileDevice(const char *filename);
    static IMG_TileDevice       *newSharedMemDevice(
                                        const char *cmd = "mdriver %d %d %d %d",
                                        int from_middle = 1);
    static IMG_TileDevice       *newSocketDevice(const char *host);

    static void                 setFileDevCreator(IMG_TileDevice *(*creator)());
    static void                 setMPlayDevCreator(IMG_TileDevice *(*creator)(int ));

    // The visible region is inclusive (i.e. there are (r-l+1) pixels per scan)
    // Setting the visible region should be done before the image is opened.
    void                        setVisibleRegion(int l, int r, int b, int t);

    // The region is always bigger or equal to the visible region.  It
    // represents the region which needs to be "rendered".  The renderable
    // region is broken up into tiles of the tile size specified.
    void                        setRenderSize(int rwidth, int rheight);

    // Open the device
    virtual int                 open(const IMG_TileOptions &info,
                                     int xres, int yres,
                                     int tile_width, int tile_height,
                                     fpreal aspect) = 0;

    virtual int                 openMulti(
                                        IMG_TileOptionList &flist,
                                        int xres, int yres,
                                        int tile_width, int tile_height,
                                        fpreal aspect);

    virtual void                setWhitePoint(fpreal white);

    /// Allow the device to perform any "checkpointing" needed.
    virtual void                checkpoint();

    // where the render originated from, to provide a half-decent name to ip.
            void                setRenderSourceName( const char *name )
                                { myRenderSourceName.harden(name); }
    const char                  *getRenderSourceName() const
                                { return myRenderSourceName; }
    
    // After the open() is called, then it's possible to query the data type
    // that the device expects.
    int                         getFileCount() const    { return myFileCount; }
    IMG_DataType                getDataType(int idx=0) const;

    // Default is to return IMG_RGBA
    IMG_ColorModel              getColorModel(int idx=0) const;

    IMG_DataType                *getDataTypes()         { return myDataType; }
    IMG_ColorModel              *getColorModels()       { return myColorModel; }

    // Writes a custom tag to the device. The tag must have a name, and some
    // number of string values (zero is acceptable).
    virtual void                writeCustomTag(const char *tagname, int size,
                                               const char **values);


    // The data written is in the format specified by the IMG_ColorModel and
    // IMG_DataType parameters in the open.  The size of the tile is smaller or
    // equal to the sizes specified in the open.
    // The limits specified do not include the maximum value (i.e. x1 is not
    // included in the tile).  The data sent down is contiguous (i.e. there is
    // no stride or gaps between pixel data - scanlines follow each other).
    virtual int                 writeTile(const void *data,
                                          unsigned x0, unsigned x1,
                                          unsigned y0, unsigned y1) = 0;

    virtual void                flush();

    virtual int                 close() = 0;

    // If the flush method is unsafe for multi-processing (or very costly), the
    // device should return 1 here.
    virtual int                 unsafeFlush();

    // The renderer will ask us for the next tile location to be rendered.
    // We give it the location (in renderable region coordinates).  The
    // function returns 1 if this is a valid tile, otherwise 0.
    // The tile mode maps to the enum of bottom/top first or random order
    virtual int         getNextTile(int &xl, int &xr, int &yb, int &yt);

    // Returns true if a tile has been clicked; otherwise, false.  If a tile
    // has been clicked then tx and ty will be set to that tile's coordinates;
    // otherwise, the values of tx and ty are undefined.
    virtual bool        getClickedTile(int &tx, int &ty) const;

    virtual void        resetTileRequestor();
    virtual int         getTileMode() const;

    virtual void        terminateOnConnectionLost(bool ) {}

    // Whether this object wants the Houdini HScript port to be written
    // to it via writeCustomTag("houdiniportnum", ...)
    virtual bool        wantsHoudiniPort() const { return false; }

protected:
    // Subclasses can override this method if they respond to mouse clicks.
    // x and y should be set to the mouse position (in pixels) if the mouse
    // has been clicked.  The method returns true if the mouse has been
    // clicked; otherwise, false.  If the method returns false then the
    // values of x and y are undefined.
    virtual bool        getMouseClickPosition(int &x, int &y) const
                            { return false; }

    // The sub-class must call this function to initialize the base class
    // correctly.
    void        setResolution(int xres, int yres,
                              int tilewidth, int tileheight,
                              int tile_order = IMG_TILE_BOTTOM_FIRST);

    void        setModel(const IMG_TileOptions &finfo);
    void        setModel(IMG_TileOptionList &flist);
    void        setModel(const IMG_DataType *dt, const IMG_ColorModel *cm);

    // Some random access devices may want to tell the renderer which tile to
    // render next.  This function will get the coordinates of the tile (i.e.
    // if there are N tiles in X and M tiles in Y, tx is (0,N) and ty is (0,M)
    void        mapImageToTile(int ix, int iy, int &tx, int &ty);
    void        getTileBounds(int tx, int ty,
                              int &xl, int &xr, int &yb, int &yt);

    bool        hasDataWindow(int full_xres, int full_yres) const;
    int         getDataX() const            { return myVL; }
    int         getDataY() const            { return myVB; }
    int         getDataWidth() const        { return myVR - myVL + 1; }
    int         getDataHeight() const       { return myVT - myVB + 1; }

    UT_InclusiveRect getDataWindow() const;

    int         myFileCount;
    int         myXres, myYres;
    fpreal      myAspectRatio;
    int         myTileWidth, myTileHeight;
    int         myVL, myVR, myVB, myVT; // Visible region
    int         myRWidth, myRHeight;    // Renderable mapping
    unsigned    myRandomAccess;         // If device supports random access

private:
    int                  myClickedTileXY[2];
    int                  myFilterX, myFilterY;
    int                  myTileCountX, myTileCountY;
    int                  myRandomCheck;
    IMG_DataType        *myDataType;
    IMG_ColorModel      *myColorModel;
    IMG_TileInterface   *myTiles;
    UT_String            myRenderSourceName;
};

#endif

---