CHOP/CHOP_VexContext.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 Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        COP_VexContext.h ( COP Library, C++)
 *
 * COMMENTS:    Contains a context for evaluating channels
 */

#ifndef __CHOP_VexContext__
#define __CHOP_VexContext__

#include "CHOP_API.h"
#include <UT/UT_Dependency.h>
#include <VEX/VEX_ContextManager.h>
#include <VEX/VEX_Context.h>

class CL_Clip;

DECLARE_DEPENDENCY(CHOP)

typedef enum {
    VCHOP_VALUE,        // Sample Value
    VCHOP_INDEX,        // Sample Index
    
    VCHOP_START,        // Channel Start
    VCHOP_END,          // Channel End
    VCHOP_RATE,         // Channel Rate
    VCHOP_LENGTH,       // Channel Length

    VCHOP_CHAN,         // current channel index
    VCHOP_NUMCHAN,      // Total # of channels

    VCHOP_MAX_VARIABLES
} VCHOP_Global;


class CHOP_API CHOP_VexVariableMap
{
public:
     CHOP_VexVariableMap();
    ~CHOP_VexVariableMap();

    // Before evaluating functions, you should set the context.  You might want
    // to keep the old context and re-set it after the fact.
    static CHOP_VexVariableMap  *getCurrent();
    static void                  setCurrent(CHOP_VexVariableMap *map);

    // Initialize has to be called once to find out what variables are required
    // by the function.
    void        initData(VEX_Instance *func);

    // Binding should be done each time you evaluate the function
    void        bind(VEX_Instance *func);

    // Before calling the function to evaluate, you should call this function
    // to load the variables with the data required.  The prepData functions
    // will set all the variables appropriatly.
    void        prepData(int start, int end, int numchan, float rate,
                         int units, int ninputs, const CL_Clip **inputs);

    // If the data overruns a scanline, then the y value will be incremented
    // appropriately.
    void        prepData(float *samples, int offset, int length,
                         int channum);

    void        extractData();
    
    int          isRead(VCHOP_Global id) const  { return myMap[id] >= 0; }
    int          getMap(VCHOP_Global id) const  { return myMap[id]; }
    void        *getData(VCHOP_Global id)
                 {
                     return myMap[id] >= 0 ? myData[id] : 0;
                 }

    int         isConnected(int input);
    float       getInputSample(int input, int track, float sample);
    int         getStart(int input);
    int         getEnd(int input);
    float       getRate(int input);
    int         getNumTracks(int input);
    int         getUnits() const { return myUnits; }

    float       getStartTime(int input);
    float       getEndTime(int input);
    float       getGlobalRate();
    
    
private:
    int                  myMap [VCHOP_MAX_VARIABLES];
    void                *myData[VCHOP_MAX_VARIABLES];
    int                  myStart, myEnd, myLength, myNumChannels;
    int                  myCurrentChannel;
    float                mySampleRate;
    float                myGlobalRate;
    int                  myReadFlag;
    int                  myNumInputs;
    int                  myUnits;
    const CL_Clip       **myInput;
};


class CHOP_API CHOP_VexContext : public VEX_Context
{
public:
    virtual int          getGlobalVariableEntries() const;
    virtual const char  *getGlobalVariableName(int id) const;
    virtual const char  *getGlobalVariableDescription(int id) const;
    virtual VEX_Type     getGlobalVariableType(int id) const;
    virtual VEX_Storage  getGlobalVariableStorage(int id) const;
    virtual int          getGlobalVariableReadWrite(int id) const;

private:
             CHOP_VexContext();
    virtual ~CHOP_VexContext();
    virtual void        addGlobalVariables(VEX_Assemble &as) const;

    static VEX_Context  *getChopContext();
    static void          clearContext();

    friend class CHOP_DummyFriend; // to avoid private d-tor warnings

    VEX_DECLARE_CONTEXT(VEX_CHOP_CONTEXT)
};

#endif

---