HDK: COP2/COP2_VexContext.h Source File

00001 /*
00002  * PROPRIETARY INFORMATION.  This software is proprietary to
00003  * Side Effects Software Inc., and is not to be reproduced,
00004  * transmitted, or disclosed in any way without written permission.
00005  *
00006  * Produced by:
00007  *      Mark Alexander
00008  *      Side Effects Software Inc
00009  *      477 Richmond Street West
00010  *      Toronto, Ontario
00011  *      Canada   M5V 3E7
00012  *      416-504-9876
00013  *
00014  * NAME:        COP2_VexContext.h ( COPv2 Library, C++)
00015  *
00016  * COMMENTS:    Contains a context for evaluating images
00017  */
00018 #ifndef __COP2_VEX_CONTEXT_H__
00019 #define __COP2_VEX_CONTEXT_H__
00020 
00021 #include "COP2_API.h"
00022 #include <UT/UT_Dependency.h>
00023 #include <UT/UT_IntArray.h>
00024 #include <UT/UT_PtrArray.h>
00025 #include <UT/UT_Matrix3.h>
00026 #include <RU/RU_FilterArea.h>
00027 #include <VEX/VEX_ContextManager.h>
00028 #include <VEX/VEX_Context.h>
00029 
00030 class UT_Vector3;
00031 class UT_Vector4;
00032 class UT_Matrix4;
00033 class TIL_Plane;
00034 class TIL_Sequence;
00035 class TIL_Tile;
00036 class TIL_TileList;
00037 class RU_FilterArea;
00038 class COP2_Node;
00039 class COP2_VexAtlas;
00040 
00041 #define COP2_VEX_TILE_CACHE_SIZE        8
00042 
00043 DECLARE_DEPENDENCY(COP2)
00044 
00045 typedef enum {
00046     VCOP2_XRES,         // X-resolution *
00047     VCOP2_YRES,         // Y-resolution *
00048     VCOP2_ASPECT,       // Aspect ratio
00049     
00050     VCOP2_R,            // Red          RW
00051     VCOP2_G,            // Green        RW
00052     VCOP2_B,            // Blue         RW
00053     VCOP2_A,            // Alpha        RW
00054 
00055     VCOP2_C1,           // Component 1  RW
00056     VCOP2_C2,           // .. 2         RW
00057     VCOP2_C3,           // .. 3         RW
00058     VCOP2_C4,           // .. 4         RW
00059 
00060     VCOP2_PNAME,        // Plane name
00061     VCOP2_PI,           // Plane index @
00062     VCOP2_NP,           // Number of planes *
00063     VCOP2_PS,           // Plane size (# of channels)
00064     
00065     VCOP2_AI,           // Array index @
00066     VCOP2_AS,           // Array size @
00067     
00068     VCOP2_I,            // Image index *
00069     VCOP2_NI,           // Number of images in sequence *
00070     
00071     VCOP2_H,            // Hue
00072     VCOP2_S,            // Sat
00073     VCOP2_V,            // Value
00074 
00075     VCOP2_X,            // X (0-1)
00076     VCOP2_Y,            // Y (0-1)
00077     VCOP2_IX,           // X Pixel value
00078     VCOP2_IY,           // Y Pixel value
00079 
00080     VCOP2_SF,           // Start Frame *
00081     VCOP2_EF,           // End Frame *
00082     VCOP2_F,            // Current Frame *
00083     VCOP2_FR,           // Frame rate *
00084     VCOP2_T,            // Current Time *
00085     VCOP2_TINC,         // Current Time Increment *
00086 
00087     VCOP2_PXSC,         // Proxy scale
00088 
00089     VCOP2_MAX_VARIABLES
00090 } VCOP2_Global;
00091 
00092 // * does not change during the cook.
00093 // @ does not change during the tile processing.
00094 
00095 class COP2_VexContext;
00096 class VEX_FilterOptions;
00097 
00098 class COP2_API cop2_TileCacheItem
00099 {
00100 public:
00101     cop2_TileCacheItem();
00102     
00103     bool matches(int input, int plane, int array, float t, int u, int v);
00104     cop2_TileCacheItem & operator=(const cop2_TileCacheItem &);
00105     void set(int input, int plane, int array, float t);
00106     
00107     TIL_TileList *myTileList;
00108     int           myInput;
00109     int           myPlane;
00110     int           myArray;
00111     float         myTime;
00112 };
00113     
00114 
00115 class COP2_API COP2_VexVariableMap
00116 {
00117 public:
00118      COP2_VexVariableMap();
00119     ~COP2_VexVariableMap();
00120 
00121    // Initialize has to be called once to find out what variables are required
00122     // by the function.
00123     void        initData(VEX_Instance *func);
00124 
00125     void        initExports(VEX_Instance *func, TIL_Sequence *seq);
00126 
00127     void        getExportList(UT_IntArray *export_id,
00128                               UT_IntArray *plane_index) const;
00129     
00130     // Binding should be done each time you evaluate the function
00131     void        bind(VEX_Instance *func);
00132     void        bindAtlas(const COP2_VexAtlas *atlas,
00133                           VEX_Instance *func,
00134                           VEX_ProcArray *proc);
00135     
00136     void        fillPlane(char *data, int index, int array_num, int vector_num,
00137                           int size, int num_procs);
00138     
00139     // Before calling the function to evaluate, you should call this function
00140     // to load the variables with the data required.  The prepData functions
00141     // will set all the variables appropriatly.
00142     void        prepData(UT_PtrArray<const TIL_Sequence *> inputs,
00143                          int num_planes, int xres, int yres, float aspect,
00144                          int startf, int endf, float cookscale,
00145                          COP2_Node *node, int thread_index, float t);
00146 
00147     void        prepData(const char *plane_name,
00148                          int plane_index, int plane_size,
00149                          int array_index, int array_size,
00150                          float *r,  float *g,  float *b,  float *a,
00151                          float *c1, float *c2, float *c3, float *c4,
00152                          int x1, int y1, int x2, int y2);
00153 
00154     // keep it in floating point format so we can let the templated TIL_Fill
00155     // class do any conversions.
00156     void         extractData();
00157     void         extractExport(VEX_Instance *func, int num_pnts, int idx,
00158                                int size, TIL_Tile **tiles, int x, int y,
00159                                int w, int stride);
00160                          
00161     int          isRead(VCOP2_Global id) const  { return myAccessedFlags[id]; }
00162     int          getMap(VCOP2_Global id) const  { return myMap[id]; }
00163     int          isConnected(int idx) const
00164                  { return (idx<0 || idx>=myInputs.entries()) ? 0 :
00165                      (myInputs(idx)!=0); }
00166     
00167     void        *getData(VCOP2_Global id)
00168                  { return myMap[id] >= 0 ? myData[id] : 0; }
00169     
00170     void        *getDataAlways(VCOP2_Global id) { return myData[id];  }
00171 
00172     void         releaseLockedTiles();
00173 
00174     // For VEX functions
00175 
00176     // current node.
00177     int          getPlaneIndex(const char *plane_name) const;
00178     const char  *getPlaneName(int index) const;
00179     const char  *getComponentName(int index, int compindex) const;
00180     int          hasPlane(const char *plane_name) const;
00181     int          getPlaneSize(int index) const;
00182 
00183     // inputs...
00184     void         getInputRes(int input, int &x, int &y) const;
00185     float        getInputAspect(int input) const;
00186     float        getFrameRate(int input) const;
00187     int          getStart(int input) const;
00188     int          getEnd(int input) const;
00189     
00190     const char  *getInputPlaneName(int input, int plane_index) const;
00191     const char  *getInputComponentName(int input, int plane_index,
00192                                        int comp_index) const;
00193     int          getInputPlaneIndex(int input, const char *plane_name) const;
00194     int          getInputNumPlanes(int input);
00195     int          hasInputPlane(int input, const char *plane_name) const;
00196     int          getInputPlaneSize(int input, int index) const;
00197 
00198     // input pixel functions (non-filtered). 
00199     float        getPixelComponent(int input, int plane_num, int plane_comp,
00200                                    int array_index,int u, int v,int frame);
00201     float        getPixelComponent(int input, int plane_num, int plane_comp,
00202                                    int array_index,float u, float v,int frame);
00203 
00204     void         getPixelComponents(float *comps, int num_comps,
00205                                     int input, int plane_num, int plane_comp,
00206                                     int array_index,
00207                                     int *u, int *v, int *frames,
00208                                     int singleframe=1, char *mask = 0);
00209     void         getPixelComponents(float *comps, int num_comps, int input,
00210                                     int plane_num, int plane_comp,
00211                                     int array_index,
00212                                     float *u,float *v, int *frames,
00213                                     int singleframe=1, char *mask = 0);
00214    
00215     UT_Vector3   getVector(int input, int plane_num, 
00216                            int array_index,int u, int v, int frame);
00217     UT_Vector3   getVector(int input, int plane_num, 
00218                            int array_index,float u, float v, int frame);
00219     
00220     void         getVectors(UT_Vector3 *vects, int num_vects,
00221                             int input, int plane_num,int array_index,
00222                             int *u, int *v, int *frames, int singleframe=1,
00223                             char *mask = 0);
00224     void         getVectors(UT_Vector3 *vects, int num_vects,
00225                             int input, int plane_num,int array_index,
00226                             float *u, float *v,int *frame, int singleframe=1,
00227                             char *mask = 0 );
00228     
00229     UT_Vector4   getPoint(int input, int plane_num, 
00230                           int array_index, int u, int v, int frame);
00231     UT_Vector4   getPoint(int input, int plane_num, 
00232                           int array_index, float u, float v, int frame);
00233     
00234     void         getPoints(UT_Vector4 *vects, int num_vects,
00235                            int input, int plane_num, int array_index,
00236                            int *u, int *v,int *frames, int singleframe =1,
00237                            char *mask = 0);
00238     void         getPoints(UT_Vector4 *vects, int num_vects,
00239                            int input, int plane_num, int array_index,
00240                            float *u, float *v,int *frame, int singleframe =1,
00241                            char *mask = 0);
00242 
00243     // Bilinear filtered pixel functions.
00244     float        getBilinearPixelComponent(int input, int plane_num,
00245                                            int plane_comp, int array_index,
00246                                            int u, int v, int frame);
00247     float        getBilinearPixelComponent(int input, int plane_num,
00248                                            int plane_comp, int array_index,
00249                                            float u, float v, int frame);
00250     void         getBilinearPixelComponents(float *comps, int num,
00251                                             int input, int plane_num,
00252                                             int plane_comp,int array_index,
00253                                             int *u, int *v, int *frames,
00254                                             int singleframe = 1, char *mask=0);
00255     void         getBilinearPixelComponents(float *comps, int num,
00256                                             int input, int plane_num,
00257                                             int plane_comp,int array_index,
00258                                             float *u, float *v, int *frames,
00259                                             int singleframe = 1, char *mask=0);
00260     
00261 
00262     UT_Vector3   getBilinearVector(int input, int plane_num, int array_index,
00263                                    int u, int v, int frame);
00264     UT_Vector3   getBilinearVector(int input, int plane_num, int array_index,
00265                                    float u, float v, int frame);
00266     void         getBilinearVectors(UT_Vector3 *vects, int,
00267                                     int input, int plane_num, int array_index,
00268                                     int *u, int *v, int *frame,
00269                                    int singleframe = 1, char *mask=0);
00270     void         getBilinearVectors(UT_Vector3 *vects, int,
00271                                     int input, int plane_num, int array_index,
00272                                     float *u, float *v, int *frame,
00273                                     int singleframe = 1,char *mask=0);
00274     
00275     UT_Vector4   getBilinearPoint(int input, int plane_num, int array_index,
00276                                   int u, int v, int frame);
00277     UT_Vector4   getBilinearPoint(int input, int plane_num, int array_index,
00278                                   float u, float v, int frame);
00279     void         getBilinearPoints(UT_Vector4 *vects, int,
00280                                    int input, int plane_num, int array_index,
00281                                    int *u, int *v, int *frame,
00282                                    int singleframe = 1, char *mask=0);
00283     void         getBilinearPoints(UT_Vector4 *vects, int,
00284                                    int input, int plane_num, int array_index,
00285                                    float *u, float *v, int *frame,
00286                                    int singleframe = 1, char *mask = 0);
00287     // Filtered pixel functions.
00288     float        getFilteredPixelComponent(int input, int plane_num,
00289                                            int plane_comp, int array_index,
00290                                            int u, int v, int frame);
00291     float        getFilteredPixelComponent(int input, int plane_num,
00292                                            int plane_comp, int array_index,
00293                                            float u, float v, int frame);
00294     void         getFilteredPixelComponents(float *comps, int num,
00295                                             int input, int plane_num,
00296                                             int plane_comp,int array_index,
00297                                             int *u, int *v, int *frames,
00298                                             int singleframe = 1, char *mask=0);
00299     void         getFilteredPixelComponents(float *comps, int num,
00300                                             int input, int plane_num,
00301                                             int plane_comp,int array_index,
00302                                             float *u, float *v, int *frames,
00303                                             int singleframe = 1, char *mask=0);
00304     
00305     UT_Vector3   getFilteredVector(int input, int plane_num, int array_index,
00306                                    int u, int v, int frame);
00307     UT_Vector3   getFilteredVector(int input, int plane_num, int array_index,
00308                                    float u, float v, int frame);
00309     void         getFilteredVectors(UT_Vector3 *vects, int,
00310                                     int input, int plane_num, int array_index,
00311                                     int *u, int *v, int *frame,
00312                                    int singleframe = 1, char *mask=0);
00313     void         getFilteredVectors(UT_Vector3 *vects, int,
00314                                     int input, int plane_num, int array_index,
00315                                     float *u, float *v, int *frame,
00316                                     int singleframe = 1,char *mask=0);
00317     
00318     UT_Vector4   getFilteredPoint(int input, int plane_num, int array_index,
00319                                   int u, int v, int frame);
00320     UT_Vector4   getFilteredPoint(int input, int plane_num, int array_index,
00321                                   float u, float v, int frame);
00322     void         getFilteredPoints(UT_Vector4 *vects, int,
00323                                    int input, int plane_num, int array_index,
00324                                    int *u, int *v, int *frame,
00325                                    int singleframe = 1, char *mask=0);
00326     void         getFilteredPoints(UT_Vector4 *vects, int,
00327                                    int input, int plane_num, int array_index,
00328                                    float *u, float *v, int *frame,
00329                                    int singleframe = 1, char *mask = 0);
00330 
00331     UT_Matrix3   getNeighbourPixel(int input, int plane_num, int plane_comp,
00332                                    int array_index,int u, int v,int frame);
00333     UT_Matrix3   getNeighbourPixel(int input, int plane_num, int plane_comp,
00334                                    int array_index,float u, float v,int frame);
00335     void         getNeighbourPixels(UT_Matrix3 *pix,  int num,
00336                                     int input, int plane_num,
00337                                     int plane_comp,int array_index,
00338                                     int *u, int *v, int *frames,
00339                                     int singleframe = 1, char *mask=0);
00340     void         getNeighbourPixels(UT_Matrix3 *pix, int num,
00341                                     int input, int plane_num,
00342                                     int plane_comp,int array_index,
00343                                     float *u, float *v, int *frames,
00344                                     int singleframe = 1, char *mask=0); 
00345     
00346     void         storeFilterOptions(const VEX_Instance &state);
00347     bool         hasScanned() const     { return myHasFilterOptions; }
00348 
00349     int          getPlaneIndex() const  { return myCurrentPlaneIndex; }
00350     int          getArrayIndex() const  { return myCurrentArrayIndex; }
00351     float        getTime() const        { return myTime; }
00352     int          getFrame() const       { return myFrame; }
00353     float        getCookScale() const   { return myCookScale; }
00354     int          getRows() const        { return myY2-myY1+1; }
00355     int          getCols() const        { return myX2-myX1+1; }
00356     
00357     // allocation stuff.
00358     void        allocUVMaps   (void *&u, void *&v, int size);
00359     void        allocCompMap  (float *&comp,   int size);
00360     void        allocVectorMap(UT_Vector3 *&v, int size);
00361     void        allocPointMap (UT_Vector4 *&p, int size);
00362 
00363     void        resetAtlas();
00364 
00365     int         *getThreadPtr() { return &myThreadIndex; }
00366 
00367     void         setInitPass(bool pass) { myInitPassOnly = pass;
00368                                           myNeededFrames.resize(0); }
00369     bool         isInitPass() const { return myInitPassOnly; }
00370 
00371     int          setNeededFrame(int frame);
00372     const UT_IntArray &getNeededFrames() const { return myNeededFrames; }
00373 private:
00374     void        createIntUVs(int input,int num,
00375                              const float *u, const float *v,
00376                              int *iu, int *iv);
00377 
00378     bool        correctUV(int dx, int dy, int xsize, int ysize,
00379                           int xres, int yres, int &u,int &v);
00380     void        scaleUVs(int input, int num, float *u, float *v);
00381     void        createFloatUVs(int input,int num,
00382                                const int *u, const int *v,
00383                                float *fu, float *fv);
00384     void        zeroValues(void *values, int num_floats);
00385     float       getTime(int frame);
00386 
00387     void        getInputOffsetSize(int input,
00388                                    const TIL_Plane *plane, int aindex, float t,
00389                                    int &dx, int &dy, int &xsize, int &ysize);
00390     
00391     TIL_TileList *fetchTile(int input, const TIL_Plane *plane, int pindex,
00392                             int aindex,float t,int u,int v, int frame);
00393     
00394     int                  myMap [VCOP2_MAX_VARIABLES];
00395     void                *myData[VCOP2_MAX_VARIABLES];
00396     int                  myReadFlag;
00397     int                  myAccessedFlags[VCOP2_MAX_VARIABLES];
00398     int                  myHSVFlag;
00399     UT_IntArray          myExports;
00400     UT_IntArray          myExportPlanes;
00401 
00402     // data that doesn't change during the cook.
00403     UT_PtrArray<const TIL_Sequence *>   myInputs;
00404     COP2_Node                           *myParentNode;
00405     int                                 myDataAllocMask;
00406     int                                 myThreadIndex;
00407 
00408     // data that changes with each prepData/extractData call.
00409     int          myX1, myY1;
00410     int          myX2, myY2;
00411     int          myXres, myYres;
00412     float        myAspectRatio;
00413     int          myCurrentPlaneIndex;
00414     int          myCurrentPlaneSize;
00415     int          myCurrentArrayIndex;
00416     int          myCurrentArraySize;
00417     const char  *myCurrentPlaneName;
00418 
00419     // data static to the cook.
00420     int          myNumPlanes;
00421     int          myImageIndex;
00422     int          myNumImages;
00423     float        myTime;
00424     float        myTimeInc;
00425     int          myFrame;
00426     int          myFrameRate;
00427     float        myCookScale;
00428     int          myStartFrame;
00429     int          myEndFrame;
00430 
00431     // filtering.
00432     RU_FILTER_WRAP      myXFilterWrap, myYFilterWrap;
00433     float               myXFilterSize, myYFilterSize;
00434     UT_FilterType       myXFilterType, myYFilterType;
00435     float               myBorderColor[4];
00436     bool                myHasFilterOptions;
00437 
00438     // buffered data arrays.
00439     void        *myUMap, *myVMap;
00440     float       *myCompMap;
00441     UT_Vector3  *myVectorMap;
00442     UT_Vector4  *myPointMap;
00443     int         myUVMapSize;
00444     int         myCompMapSize;
00445     int         myVectorMapSize;
00446     int         myPointMapSize;
00447 
00448     // buffered input tiles.
00449     cop2_TileCacheItem myInputTile[COP2_VEX_TILE_CACHE_SIZE];
00450 
00451     // filter
00452     RU_FilterArea *myFilter;
00453 
00454 public:
00455     // late binding caches -- please don't touch.
00456     UT_PtrArray<float *>        myCacheFloat;
00457     UT_PtrArray<UT_Vector3 *>   myCacheVector;
00458     UT_PtrArray<UT_Vector4 *>   myCachePoint;
00459     UT_PtrArray<UT_Matrix3 *>   myCacheMat3;
00460     UT_PtrArray<UT_Matrix4 *>   myCacheMat4;
00461 
00462     int myCachePtrFloat;
00463     int myCachePtrVector;
00464     int myCachePtrPoint;
00465     int myCachePtrMat3;
00466     int myCachePtrMat4;
00467 
00468     UT_IntArray         myNeededFrames;
00469     bool                myInitPassOnly;
00470 };
00471 
00472 
00473 class COP2_API COP2_VexContext : public VEX_Context
00474 {
00475 public:
00476     virtual int          getGlobalVariableEntries() const;
00477     virtual const char  *getGlobalVariableName(int id) const;
00478     virtual const char  *getGlobalVariableDescription(int id) const;
00479     virtual VEX_Type     getGlobalVariableType(int id) const;
00480     virtual VEX_Storage  getGlobalVariableStorage(int id) const;
00481     virtual int          getGlobalVariableReadWrite(int id) const;
00482 
00483 private:
00484                          COP2_VexContext();
00485     virtual             ~COP2_VexContext();
00486     
00487     static VEX_Context  *getCopContext();
00488     static void          clearContext();
00489 
00490     virtual void        addGlobalVariables(VEX_Assemble &as) const;
00491 
00492     friend class COP2_DummyFriend; // to avoid private d-tor warnings
00493     
00494     VEX_DECLARE_CONTEXT(VEX_COP2_CONTEXT)
00495 };
00496 
00497 #endif