CHOP/CHOP_Node.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:
 *      Rob Bairos
 *      Side Effects Software Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        CHOP Library (C++)
 *
 * COMMENTS:    The base class for all Channel Operators
 *
 */

#ifndef __CHOP_Node_h__
#define __CHOP_Node_h__

#include "CHOP_API.h"
#include <UT/UT_ExpandArray.h>
#include <UT/UT_NTStreamUtil.h>

#include <CL/CL_Clip.h>
#include <CL/CL_Defines.h>

#include <PRM/PRM_Parm.h>
#include <OP/OP_InputChangeHelper.h>
#include <OP/OP_Node.h>
#include <OP/OP_Network.h>

#include "CHOP_Error.h"
#include "CHOP_Notes.h"

#define CHOP_AUDIO_FLAG         'a'
#define CHOP_EXPORT_FLAG        'o'

class OP_OperatorTable;
class OP_TemplatePair;
class OP_VariablePair;
class OP_OutputCodeParms;
class CHOP_Handle;
class CHOP_HandleData;
class UT_Vector4;
class CHOP_Fitter;
class CL_FitParms;
class OR_Mapping;
class orPath;
class orUnit;
class CHOP_OutputClipManager;
class CHOP_VariableList;
class UT_IncludeFileManager;

typedef void (*CHOP_ReplaceCallback)(void *data, int replace);

typedef void (*CHOP_ConflictCallback)(void *data,
                void *ldata, CHOP_ReplaceCallback func,
                const char *source, const char *dest);

typedef UT_PtrArray<orUnit *>           orUnitList;
typedef UT_PtrArray<CHOP_Handle *>      CHOP_HandleList;

extern "C" {
    DLLEXPORT extern void       newChopOperator(OP_OperatorTable *table);
};

#define CHOP_PARM_COUNT         (8)
#define CHOP_TAB        "Common"
#define NONE_TOKEN      "none"

#define CHOP_OUT_CFUNC "_updateCParam"
#define CHOP_OUT_IFUNC "_updateIParam"

#define CHOP_OUT_CPARAM "params.cUpdate"
#define CHOP_OUT_IPARAM "params.iUpdate"


#define CHOP_SWITCHER(cnt, nm) \
    static PRM_Default switcher[2] = \
    { \
        PRM_Default(cnt, nm), \
        PRM_Default(CHOP_PARM_COUNT, CHOP_TAB), \
    }

#define CHOP_SWITCHER2(cnt1,nm1,cnt2, nm2) \
    static PRM_Default switcher[3] = \
    { \
        PRM_Default(cnt1, nm1), \
        PRM_Default(cnt2, nm2), \
        PRM_Default(CHOP_PARM_COUNT, CHOP_TAB), \
    }

#define CHOP_SWITCHER3(cnt1,nm1,cnt2, nm2,cnt3,nm3) \
    static PRM_Default switcher[4] = \
    { \
        PRM_Default(cnt1, nm1), \
        PRM_Default(cnt2, nm2), \
        PRM_Default(cnt3, nm3), \
        PRM_Default(CHOP_PARM_COUNT, CHOP_TAB), \
    }

#define CHOP_SWITCHER4(cnt1,nm1,cnt2, nm2,cnt3,nm3,cnt4,nm4) \
    static PRM_Default switcher[5] = \
    { \
        PRM_Default(cnt1, nm1), \
        PRM_Default(cnt2, nm2), \
        PRM_Default(cnt3, nm3), \
        PRM_Default(cnt4, nm4), \
        PRM_Default(CHOP_PARM_COUNT, CHOP_TAB), \
    }

#define CHOP_SWITCHER5(cnt1,nm1,cnt2, nm2,cnt3,nm3,cnt4,nm4,cnt5,nm5) \
    static PRM_Default switcher[6] = \
    { \
        PRM_Default(cnt1, nm1), \
        PRM_Default(cnt2, nm2), \
        PRM_Default(cnt3, nm3), \
        PRM_Default(cnt4, nm4), \
        PRM_Default(cnt5, nm5), \
        PRM_Default(CHOP_PARM_COUNT, CHOP_TAB), \
    }

#define CHOP_SWITCHER6(cnt1,nm1,cnt2, nm2,cnt3,nm3,cnt4,nm4,cnt5,nm5,cnt6,nm6) \
    static PRM_Default switcher[7] = \
    { \
        PRM_Default(cnt1, nm1), \
        PRM_Default(cnt2, nm2), \
        PRM_Default(cnt3, nm3), \
        PRM_Default(cnt4, nm4), \
        PRM_Default(cnt5, nm5), \
        PRM_Default(cnt6, nm6), \
        PRM_Default(CHOP_PARM_COUNT, CHOP_TAB), \
    }

enum CHOP_SampleMatch   { FIRST_RATE    = 0,
                          SAMPLE_MAX_RATE,
                          SAMPLE_MIN_RATE,
                          ERROR_IF_DIFF };

#define ARG_CHOP_SCOPE          (myParmCommonBase + 0)
#define ARG_CHOP_MATCH          (myParmCommonBase + 1)
#define ARG_CHOP_UNITS          (myParmCommonBase + 2)
#define ARG_CHOP_REALTIME       (myParmCommonBase + 3)
#define ARG_CHOP_UNLOAD         (myParmCommonBase + 4)
#define ARG_CHOP_EXPORT_PATH    (myParmCommonBase + 5)
#define ARG_CHOP_DCOLOR         (myParmCommonBase + 6)
#define ARG_CHOP_COLSTEP        (myParmCommonBase + 7)

//___________________________________________________________________________

class CHOP_API CHOP_Node : public OP_Network
{
public:

    virtual const char          *getChildType() const;
    virtual const char          *getOpType() const;

    virtual OP_OpTypeId  getChildTypeID() const;
    virtual OP_OpTypeId  getOpTypeID() const;

    virtual OP_DATA_TYPE         getCookedDataType() const;
    static void                  buildOperatorTable(OP_OperatorTable &table);
    static void                  buildGameOperatorTable(OP_OperatorTable &table);

    static OP_TemplatePair       myTemplatePair;
    static OP_VariablePair       myVariablePair;
    static PRM_Template          myTemplateList[];
    static CH_LocalVariable      myVariableList[];

    virtual int                  getAudio() const;
    virtual int                  getExport() const;
    virtual int                  setAudio(int on_off);
    virtual int                  setExport(int on_off);

    //
    // cooking methods
    //

    virtual OP_ERROR             cookMyChop(OP_Context &context) = 0;
    virtual void                 cookMyHandles(OP_Context &context);
    CHOP_HandleList             *getHandles(OP_Context &context);

    // Virtual function for getting our child with the audio flag on.
    // Only the subnet CHOP returns a non-zero value.
    virtual CHOP_Node           *getAudioNodePtr()
                                 { return 0; }

    // cooked data access
    virtual const CL_Clip       *getClip(OP_Context *context = 0);

    int64                        getMemoryUsage(void) const;
    const CL_Clip               *inputClip(int idx, OP_Context &context);
    CL_Track                    *getTrack(const char *name); // doesn't cook
    float                        getSampleRate();
    
    UT_Color                     getColor(unsigned int index = 0) const;

    virtual CH_Channel          *getTrackChannel(const char *name);

    // Do global expansion on a pattern, and get a track list, and
    // corresponding node list of track owners.
    // If dependent given, addExtraInputs.                    
    void                 globTracks(const char                  *pattern,    
                                    CL_TrackListC               *tlist,  
                                    UT_PtrArray<OP_Node *>      *olist = 0,  
                                    OP_GlobContext              *context = 0,
                                    int                          do_cook = 0,
                                    float                        t = 0,
                                    OP_Node                     *dependent = 0);

    //
    // return the application frame rate
    //

    static float                 getGlobalRate(void);

    static float                 getGlobalStart();
    static float                 getGlobalEnd();

    static float                 getGlobalSampleStep();


    //
    // This method is called whenever a guide handle has been dragged
    virtual float                handleChanged(CHOP_Handle *handle, 
                                               CHOP_HandleData *data);

    // This method is used to traverse to create the necessary 
    // cached clips for outputting code.
    int                          buildCacheInfo(OP_Context &context, 
                                                CHOP_OutputClipManager *mgr);

    //
    // Notes interface
    int                          putNote(float t, const char *);
    int                          putNote(float t, int index);
    int                          putNote(int index, const char *);

    const char                  *getNote(float t0) const;
    const char                  *getNote(int index) const;
    int                          getNotes(float t0, float t1,
                                          CHOP_NoteList &clist,
                                          CHOP_TimeList &tlist) const;

    //
    // Edit interface

    OP_Channels                 *getFitData();
    void                         resampleFromFit();
    void                         setFitParms(const CL_FitParms &parms);
    void                         getFitParms(CL_FitParms &parms) const;

    //
    // This function will copy the fit channels to the
    // destination node channels

    int                          copyFitChannels();


    //
    // Error & Warning reporting
    //

    static void          addError(int code, const char *msg = 0)
                            { UTaddError("CHOP", code, msg);}

    static void          addWarning(int code, const char *msg=0)
                            { UTaddWarning("CHOP", code, msg);}

    //
    // An external hook to notify the user of export conflicts

    static void         setConflictCallback(CHOP_ConflictCallback func,
                                            void *data)
                        {
                            theConflictCallback = func;
                            theConflictData = data;
                        }

    //
    // Extra flags
    //

    virtual void         setExtraFlag(char flag, int onoff);

    //
    // method to direct-manip the start of an ancestor from
    // a descendants handle
    //

    virtual float        shiftStart(float new_offset, float t);

    //
    // must maintain overriding whether or not its being displayed
    // or referenced 
    virtual void         opChanged(OP_EventType reason, void *data=0);
    virtual int          propagateModification(OP_Node *by_whom,
                                               OP_EventType reason,
                                               int parm_index,
                                               OP_PropagateData &data);

    // Overriden by the Realtime CHOPs.
    virtual      int usesRealtime()     { return 0; }
    virtual      int isRealtimeCook()   { return 0; }
    virtual OP_ERROR doCookRealtime(OP_Context &context);

    virtual     void realtimeInit(float t);
    virtual     void realtimeCleanup();
    
    // returns true if a range has been modified, plus that range.
    virtual int         getModifiedRange(int &first,int &last,int clear=1);

    static void         installCommands();
    
    // For realtime: only called by the maxslice command.
    static void         setMaxSliceSize(float size) { myMaxRealtimeSlice = size; }
    static float        getMaxSliceSize() { return myMaxRealtimeSlice; }
    static void         setTimeSliceDefault(int state) { myTimeSliceDefault = state; }
    static int          getTimeSliceDefault() { return myTimeSliceDefault; }

    static void         setSmartCook(int f) { mySmartCookFlag = f; }
    static int          getSmartCook() { return mySmartCookFlag; }
    
    //
    // Menu building routines
    // 

    static void                  buildEditorMenu(void *, PRM_Name *, int,
                                         const PRM_SpareData *, PRM_Parm *);
    static void                  buildNetMenu(void *, PRM_Name *, int,
                                         const PRM_SpareData *, PRM_Parm *);
    static void                  buildNodeMenu(void *, PRM_Name *, int,
                                         const PRM_SpareData *, PRM_Parm *);

    //
    // Limit the number of lines generated in our info methods.
    //

    int                          limitInfo() const
                                 { return myLimitInfo; }

    void                         limitInfo(int yesno)
                                 { myLimitInfo = yesno; }

    // export mapping techniques
    //
    virtual void         setMapping(int idx, int type, const char *label = 0);
    virtual int          getMapping(int idx, const char *&label) const;

    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                                 int verbose,
                                                 UT_WorkBuffer &text);
    void                 saveMapping( ostream &os, bool binary ) const;
    bool                 loadMapping( UT_IStream &is );

    ///Get absolute width
    virtual fpreal       getW() const;
    ///Get absolute height
    virtual fpreal       getH() const;

    // Force matching of our exports to nodes and do any necessary
    // exports.  This method is called whenever a new node is added
    // or a node is renamed and there might be a new export.
    virtual void                 updateExports();

    // Generic implementation to return a parameter representing a track.
    // It simply calls the first input to do it.
    virtual bool         findParmFromTrack(float t, const char *trackname,
                                           OP_Node *&node, PRM_Parm *&parm,
                                           int &vecidx);

protected:
    CHOP_Node(OP_Network *parent, const char *name, OP_Operator *entry);
    virtual ~CHOP_Node();

    virtual void         inputConnectChanged(int which_input);

    // notifier when this node is unlocked
    virtual void         nodeUnlocked();

    // All external references must be removed by the time this function
    // returns!
    virtual void         clearAndDestroy(void);

    virtual OP_ERROR     preCook(OP_Context &context);
    virtual void         postCook();
    
    virtual OP_ERROR     cookMe(OP_Context &context);
    virtual OP_ERROR     bypassMe (OP_Context &context, int &);
    virtual unsigned     disableParms();

    void                 initCommonBaseParm();

    virtual void         buildOpDependencies();

        // this method is called to alert this op that its dependency has
        // changed. if it's a name interest, then the old full path is given
    virtual void         handleOpDependency( int referenced_op_id,
                                             const OP_Dependency &op_dep,
                                             OP_InterestType interest_type,
                                             bool &need_cook,
                                             const char *old_fullpath,
                                             const char *old_cwd,
                                             const char *old_chan_name);

    // This method is called when a channel that we reference has changed 
    // the way it is referenced.
    virtual void         handleChanNameDependency(const UT_String &chan_token,
                                                  const UT_String &chan_alias,
                                                  const char *old_chan_name,
                                                  bool &need_cook);

    // This method takes an expand array with a pattern of channels and 
    // generates a new pattern based on the renaming of a channel that was
    // guaranteed to be in the pattern (old_chan_name should be matched by
    // chan_array).  chan_token and chan_alias are the two new ways of
    // of accessing the old channel name.  If either of the new names can
    // be matched by the existing pattern in chan_array, then new_pattern
    // will not contain a valid string (that is !new_pattern.isstring()).
    static void          renameChanReference(UT_ExpandArray &chan_array, 
                                             const UT_String &chan_token,
                                             const UT_String &chan_alias,
                                             const char *old_chan_name,
                                             bool &need_cook,
                                             UT_String &new_pattern);

    // Adds dependencies to the parms/channels found in the supplied lists.
    void                         addParmReferences(
                                        const UT_RefArray<opParmData> *plist,
                                        const CH_ChannelList *clist);

    //
    // Override these methods to enable/disable the common parameters
    //

    virtual int          usesScope() const;
    virtual int          usesSampleMatch() const;
    virtual int          usesUnits();

    //
    // Input scoping methods
    //

    void                 getScopedTracks(const CL_Clip *, CL_TrackListC &);
    int                  isScoped(const UT_String &name);


    //
    // reset methods

    void                 destroyClip(void);
    void                 destroyHandles(void);

    //
    // reset the data and set the correct sample rate

    const CL_Clip       *copyInputAttributes(OP_Context &context, 
                                             int destroy = 1);

    //
    // copy us exactly from the input, tracks and all
    // options to copy data samples and slerp info as well
    //

    const CL_Clip       *copyInput(OP_Context &context, int idx,
                                   int data, int slerps);


    //
    // Conversion methods
    //
    
    float                toSampleLength(float len,
                                    CL_Unit unit = UNIT_NONE,
                                    int end_width = 0);
    float                toSample(float val,
                                  CL_Unit unit = UNIT_NONE,
                                  int end_width = 0);
    float                toUnitLength(float len,
                                CL_Unit unit = UNIT_NONE,
                                int end_width = 0);
    float                toUnit(float index,
                                CL_Unit unit = UNIT_NONE,
                                int end_width = 0);


    //
    // toStandard take (s,e) and converts it to absolute indices
    // fromStandard does the opposite

    float                toStandardStart(float is, OP_Context context,
                                         int relative, int ref_input = 1);

    float                toStandardEnd(float is, OP_Context context,
                                       int relative, int ref_input = 1);

    float                fromStandardStart(float os, OP_Context context,
                                           int relative, int ref_input,
                                           CL_Unit unit = UNIT_NONE);

    float                fromStandardEnd(float oe, OP_Context context,
                                         int relative, int ref_input,
                                         CL_Unit unit = UNIT_NONE);


    //
    //  I/O methods
    //

    virtual int          saveCookedData(const char *, OP_Context &);
    virtual int          saveCookedData(ostream &os, OP_Context &, int binary);
    virtual bool         loadCookedData(UT_IStream &is, const char*);
    virtual const char  *getFileExtension(int binary) const;
    virtual void         deleteCookedData();

    virtual OP_ERROR     save(ostream &os, const OP_SaveFlags &flags,
                              const char *pathPrefix);
    virtual bool         load(UT_IStream &is, const char *extension,
                              const char *path=0);

    /// @brief Mark all inputs as dirty so that useInputSource() will return
    /// true upon its next call. This is the default.
    void                 resetChangedSourceFlags();

    /// @brief Mark the given input as used for cooking by this node.
    ///
    /// This updates source flags to mark the input as now clean, returning
    /// whether the input has changed since the last time this function was
    /// called. If @c force is true, then we treat the input as always dirty.
    /// Returns @c false if the input has errors.
    bool                 useInputSource(unsigned idx, bool &changed, bool force)
                         {
                             return myInputChangeHelper.useInput(
                                                *this, idx, changed, force);
                         }

    //
    // Common page parameter access
    //

    void                 SCOPE_STRING(UT_String &str)
                         { evalString(str,ARG_CHOP_SCOPE, 0, 0); }

    CHOP_SampleMatch     SAMPLE_MATCH()
                         { return (CHOP_SampleMatch)
                             evalInt(ARG_CHOP_MATCH, 0, 0); }

    CL_Unit              UNITS()
                         { return (CL_Unit)
                             evalInt(ARG_CHOP_UNITS, 0, 0); }

    int                  REALTIME()
                         { return evalInt(ARG_CHOP_REALTIME,0,0); }

    int                  UNLOAD()
                         { return evalInt(ARG_CHOP_UNLOAD,0,0); }

    void                 EXPORT_PATH(UT_String &str)
                         { evalString(str, ARG_CHOP_EXPORT_PATH, 0, 0); }

    short                myParmBase;            // parameter offsets
    short                myParmCommonBase;

    CL_Clip             *myClip;                // chop data..
    CHOP_HandleList      myHandles;
    float                myHandleCookTime;

    //
    // method to retrieve a valid index interval, or the
    // current unprocessed index interval

    static void          getStaticInterval(float t, int &istart, int &iend,
                                           int &last_iend, float start, 
                                           float end, int current, 
                                           const CL_Clip *clip);

    virtual int          getNetOverviewColor( UT_Color &color );

    static void          buildScopeMenu(void *data,
                                        PRM_Name *menuEntries, int thelistsize,
                                        const PRM_SpareData *spare, PRM_Parm *);

    //
    // Override this method if this chop exports in a specific manner
    //

    virtual const orUnitList    *getOverrideUnits() const
                                 { return 0; }
    // stealOverrideUnits() will steal the allocated data from units
    virtual void                 stealOverrideUnits(orUnitList & /*units*/)
                                 { }

    //
    // Menu handling routines
    // 

    void                         getMenuPath(UT_String &base,
                                             const UT_String &edit,
                                             const UT_String &net,
                                             const UT_String &node,
                                             int add_inputs = 1);

    virtual void                 EDITOR_PATH(UT_String &str);
    virtual void                 NET_PATH(UT_String &str);

    // This is set by a parent chop during cooking, to unload itself

    void                         setUnloadParent()
                                 { myUnloadParent = 1; }

private:    // methods

    // This method is called whenever a cook is called causing a
    // cookMyChop or the context.myCookOverride is set to 1
    // on a getClip() which may also call cook.

    void                 updateOverrides();
    static void          updateConflicts(void *data, int replace);

    void                 saveOverrideUnits(ostream &os, bool binary);
    bool                 loadOverrideUnits(UT_IStream &is);

    void                 destroyScopePatterns();

    float                getInputRate(int input_idx);
    static void          initializeExpressions();
    void                 notifyOverrides(const OP_NodeList &list,
                                         const UT_IntArray &indices);
    void                 getFitInterval(int &istart, int &iend);

    OP_ERROR             doCook(OP_Context &context, int bypass);

    void                 buildChannelMenu(PRM_Name *menuEntries,
                                          int themenusize);

    bool                 loadFitData(UT_IStream &is, const char *path);
    void                 destroyAllFitData();
    void                 createFitCollection();
    void                 destroyFitCollection();

    bool                 haveSeenModification( long counter );


private:    // data

    char                         myUnloadParent;

    // These parameters reduce the number of times a scope
    // string must be parsed to traverse arrays

    UT_ExpandArray               myScopePatterns;
    char                         myScopeAll;

    static PRM_ChoiceList        scopeMenu;
    CHOP_Notes                   myNotes;

    OP_Channels                 *myFitCollection;
    CL_Clip                     *myFitClip;
    CL_FitParms                 *myFitParms;
    float                        myFitError2;
    int                          myFitDirty;
    CHOP_Fitter                 *myFitter;
    orPath                      *myOrPathParms;
    int                          myRealtimeCookState;

    static float                 myMaxRealtimeSlice;
    static int                   myTimeSliceDefault;
    static int                   mySmartCookFlag;

    static int                   myLimitInfo;

    OP_VERSION                   myHandleVersionParms;

    static CHOP_ConflictCallback         theConflictCallback;
    static void                         *theConflictData;

    char                         myConflictPending;

    OR_Mapping                  *myMapping;
    
    long                         myLastModification;

    OP_InputChangeHelper         myInputChangeHelper;

    // Undo classes should have access to everything so that they can undo
    friend class CHOP_UndoFitDestroy;
};

// Function to get a list of template arrays containing parm names that must
// be reserved when compiling VEX CHOPs.
CHOP_API extern void
CHOPgetVexReservedTemplateLists(UT_PtrArray<PRM_Template *> &tplatelists);

#undef FLT_PARM
#undef INT_PARM
#undef STR_PARM
#undef FLT_SET

#endif

---