TIL/TIL_TileMPlay.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 Alexander
 *      Side Effects Software Inc.
 *      477 Richmond St W
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-504-9876
 *
 * NAME:        TIL_TileMPlay (C++)
 *
 * COMMENTS:    This class writes to deep raster tiles to a Net socket.
 *              
 */

#ifndef __TIL_TileMPlay_H__
#define __TIL_TileMPlay_H__

#include "TIL_API.h"
class TIL_Sequence;
class TIL_Tile;
class UT_NetPacket;
class UT_NetSocket;

#include <UT/UT_IntArray.h>
#include <UT/UT_Lock.h>
#include <UT/UT_SysClone.h>
#include <UT/UT_StopWatch.h>
#include <IMG/IMG_TileDevice.h>

class TIL_API TIL_TileMPlay : public IMG_TileDevice
{
public:
             TIL_TileMPlay(int middle, bool isflipbook);
    virtual ~TIL_TileMPlay();

    virtual int          open(const IMG_TileOptions &finfo,
                              int xres, int yres, int twidth, int theight,
                              fpreal aspect);

    virtual int          openMulti(IMG_TileOptionList &flist,
                                   int xres, int yres,
                                   int twidth, int theight, fpreal aspect);

    virtual void         setWhitePoint(fpreal w);

    virtual void         writeCustomTag(const char *tagname, int size,
                                               const char **values);

    virtual int          writeTile(const void *data, unsigned x0, unsigned x1,
                                                     unsigned y0, unsigned y1);
    virtual void         flush();
    virtual int          close();

    // more convienient functions for COPs.
    int                  openDeep(const char *filename,
                                  const TIL_Sequence &info,
                                  int tilex, int tiley,
                                  bool startnew=false,
                                  const IMG_TileOptions *finfo=0);

    int                  writeDeepTile(int plane_index, const void *data,
                                       int x0, int x1, int y0, int y1);
    void                 setStatusMsg(const char *msg);

    bool                 isOpen() const { return mySocket && myPacket; }
    bool                 checkInterrupt() { drainSocket(); return isOpen(); }

    virtual bool         getMouseClickPosition(int &x, int &y) const;
    
    void                 setMouseClickPosition(int x, int y)
                         { myMouse[0] =x; myMouse[1] =y; }

    void                 streakEdges(int x1, int y1, int x2, int y2,
                                     int plane = -1);

    bool                 wasRemoteQuitRequested() { return myQuitFlag; }

    // returns the name of the lock file.
    static void          getLockFile(UT_WorkBuffer &buf, bool isflipbook);

    virtual void         terminateOnConnectionLost(bool);

    virtual bool         wantsHoudiniPort() const { return true; }

    static void          enableColorCorrection(bool enable);
    static void          setColorCorrectionLUT(bool enable, const char *lut);
    static void          setColorCorrectionGamma(bool enable, fpreal gamma);
private:
    int                  openSocket(int port);
    void                 drainSocket();
    void                 clean();

private:
    void                 sendTileOptions(const IMG_TileOptions &options);

    TIL_Sequence        *mySequence;
    UT_Lock              myWriteLock;
    bool                 myIsFlipbook;
    UT_IntArray          myPlaneIndex;
    UT_IntArray          myPlaneSize;

    UT_NetSocket        *mySocket;
    UT_NetPacket        *myPacket;
    int                  myBPP, myMiddle;
    int                  myMouse[2];
    bool                 myQuitFlag;
    UT_StopWatch         myFlushTimer;
    int                  myQueuedSize;
};

#endif

---