#ifndef cmDspClass_h #define cmDspClass_h #ifdef __cplusplus extern "C" { #endif typedef unsigned cmDspRC_t; enum { kOkDspRC = cmOkRC, // 0 kMemAllocFailDspRC, // 1 kLHeapFailDspRC, // 2 kJsonFailDspRC, // 3 kFileSysFailDspRC, // 4 kSymTblFailDspRC, // 5 kThreadFailDspRC, // 6 kNetFailDspRC, // 7 kCsvFailDspRC, // 8 kProcFailDspRC, kAllocInstFailDspRC, kClassFinalFailDspRC, kInstFinalFailDspRC, kInstResetFailDspRC, kInstExecFailDspRC, kInstStoreFailDspRC, kInstRecallFailDspRC, kInstMsgRcvFailDspRC, kNetSendAllocFailDspRC, kClassNotFoundDspRC, kInstNotFoundDspRC, kDuplInstSymIdDspRC, kVarNotFoundDspRC, kSrcVarNotFoundDspRC, kRsrcNotFoundDspRC, kSymNotFoundDspRC, kNetNodeNotFoundDspRC, kDuplPresetInstDspRC, kDuplPresetVarDspRC, kPresetGrpNotFoundDspRC, kPresetPreNotFoundDspRC, kPresetInstNotFoundDspRC, kPresetVarNotFoundDspRC, kVarDuplicateDspRC, kVarTypeErrDspRC, kVarNotValidDspRC, kVarArgParseFailDspRC, kInstCbInstallFailDspRC, kConnectFailDspRC, kInstSetFlagsFailDspRC, kSerializeUiMsgFailDspRC, kSendToHostFailDspRC, kUiEleCreateFailDspRC, kInvalidArgDspRC, kInvalidStateDspRC, kSubSysFailDspRC, kFileWriteFailDspRC, kFileReadFailDspRC, kFileOpenFailDspRC, kFileCloseFailDspRC, kInvalidPgmIdxDspRC, kPgmCfgFailDspRC }; struct cmDspClass_str; struct cmDspInst_str; enum { kUiDspFl = 0x01, // set in cmDspSysHandleUiMsg() to indicate that a msg originated from a UI control. kUiEchoDspFl = 0x02, // set in cmDspSysHandleUiMsg() to indicate that the value set from a UI control should sent back to it by the DSP engine. kDfltEvtDspFlags = 0 }; // DSP event record typedef struct { unsigned flags; // See kXXDspFl struct cmDspInst_str* srcInstPtr; // source instance of the event or NULL if the system generated the event unsigned srcVarId; // source selector id used to identify this event (See Note 1 below.) unsigned dstVarId; // dest. selector id used to identify the target of the event void* dstDataPtr; // dest. supplied custom callback data pointer const cmDspValue_t* valuePtr; // event message data } cmDspEvt_t; #define cmDspEvtCopy( e0, e1 ) (*(e0)) = (*(e1)) // Note 1: When the event was generated from a UI msg then: // a. The kUiDspFl is set and the kUiEchoDspFl if the UI requested duplex operation. // b. srcVarId is set with the cmDspUiHdr_t selId value of the UI msg. typedef struct cmDspClass_str* (*cmDspClassConsFunc_t)(cmDspCtx_t* ctx); typedef cmDspRC_t (*cmDspClassFunc_t)( cmDspCtx_t* ctx, struct cmDspClass_str* classPtr ); typedef struct cmDspInst_str* (*cmDspConsFunc_t)( cmDspCtx_t* ctx, struct cmDspClass_str* classPtr, unsigned storeSymId, unsigned instSymId, unsigned id, unsigned va_cnt, va_list vl ); typedef cmDspRC_t (*cmDspFunc_t)( cmDspCtx_t* ctx, struct cmDspInst_str* thisPtr, const cmDspEvt_t* evtPtr ); typedef cmDspRC_t (*cmDspStoreFunc_t)( cmDspCtx_t* ctx, struct cmDspInst_str* thisPtr, bool Fl ); typedef cmDspRC_t (*cmDspAttrSymFunc_t)(cmDspCtx_t* ctx, struct cmDspInst_str* thisPtr, unsigned attrSymId, const cmDspValue_t* value ); // DSP class record typedef struct cmDspClass_str { cmErr_t err; const cmChar_t* labelStr; const cmChar_t* doc; cmDspClassFunc_t finalClassFunc; // finalize the class cmDspConsFunc_t allocFunc; // allocate an instance cmDspFunc_t freeFunc; // free an instance cmDspFunc_t resetFunc; // cmDspFunc_t execFunc; // cmDspFunc_t recvFunc; // cmDspStoreFunc_t storeFunc; // store the state of this instance cmDspAttrSymFunc_t sysRecvFunc; // attr/value recv function (see cmDspSysBroadcastValue() } cmDspClass_t; // record used to maintain an event target callback chain typedef struct cmDspInstCb_str { unsigned srcVarSymId; // src var symbol id struct cmDspInst_str* dstInstPtr; // target instance unsigned dstVarId; // target instance sel id void* dstDataPtr; // target instance custom data struct cmDspInstCb_str* linkPtr; // chain link } cmDspCb_t; // record used to maintain instance variables typedef struct { unsigned flags; // see xxxDsvFl in cmDspValue.h for possible flag values unsigned constId; // constant id provided by the instance unsigned symId; // symbol id assoc'd with this var's label cmDspValue_t value; // current value of this variable cmDspValue_t dflt; // default value for this variable cmDspCb_t* cbList; // event targets registered with this instance const cmChar_t* doc; // document string } cmDspVar_t; typedef struct { const char* label; unsigned constId; unsigned rn; unsigned cn; unsigned flags; const cmChar_t* doc; } cmDspVarArg_t; typedef struct cmDspInstSymId_str { unsigned symId; // set to cmInvalidId if the recd is not active struct cmDspInstSymId_str* link; } cmDspInstSymId_t; enum { kDisableExecInstFl = 0x01 }; typedef struct cmDspInst_str { struct cmDspClass_str* classPtr; // ptr to class for this instance unsigned symId; // optional instance label symbol id unsigned id; // id is unique among all insts unsigned flags; // See kXXXInstFl above cmDspVar_t* varArray; // unsigned varCnt; // cmDspFunc_t freeFunc; // free an instance cmDspFunc_t resetFunc; // reset a instance to its default values cmDspFunc_t execFunc; // DSP clock tick cmDspFunc_t recvFunc; // recv an event cmDspStoreFunc_t storeFunc; // cmDspAttrSymFunc_t sysRecvFunc; unsigned presetGroupSymId;// cmDspInstSymId_t* symIdList; // } cmDspInst_t; cmDspRC_t cmDspClassSetup( cmDspClass_t* classPtr, // class to setup cmDspCtx_t* ctx, // const cmChar_t* classLabel, // cmDspClassFunc_t finalClassFunc, // finalize the class cmDspConsFunc_t allocFunc, // allocate an instance cmDspFunc_t freeFunc, // free an instance cmDspFunc_t resetFunc, cmDspFunc_t execFunc, cmDspFunc_t recvFunc, cmDspStoreFunc_t storeFunc, cmDspAttrSymFunc_t sysRecvFunc, const cmChar_t* doc ); void* cmDspInstAllocate(cmDspCtx_t* ctx, cmDspClass_t* classPtr, const cmDspVarArg_t* argV, unsigned instByteCnt, unsigned instSymId, unsigned instId, unsigned storeSymId, unsigned vargCnt, va_list vl ); #define cmDspInstAlloc(T,ctx,classPtr,args,symId,id,storeSymId,vargCnt,vl) (T*)cmDspInstAllocate(ctx,classPtr,args,sizeof(T),symId,id,storeSymId,vargCnt,vl) void* cmDspInstAllocateV(cmDspCtx_t* ctx, cmDspClass_t* classPtr, unsigned instByteCnt, unsigned instSymId, unsigned instId, unsigned storeSymId, unsigned vargCnt, va_list vl0, ... ); #define cmDspInstAllocV(T,ctx,classPtr,symId,id,storeSymId,va_cnt,vl, ... ) (T*)cmDspInstAllocateV(ctx,classPtr,sizeof(T),symId,id,storeSymId,va_cnt,vl, __VA_ARGS__ ) bool cmDspInstHasAttrSym( cmDspInst_t* inst, unsigned attrSymId ); cmDspRC_t cmDspInstRegisterAttrSym( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned attrSymId ); cmDspRC_t cmDspInstRemoveAttrSym( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned attrSymId ); cmDspRC_t cmDspClassErr( cmDspCtx_t* ctx, cmDspClass_t* classPtr, cmDspRC_t rc, const cmChar_t* fmt, ... ); cmDspRC_t cmDspInstErr( cmDspCtx_t* ctx, cmDspInst_t* inst, cmDspRC_t rc, const cmChar_t* fmt, ... ); // Helper functions for setting up enumerated cmDspVarArg_t records. void cmDspArgSetup( cmDspCtx_t* ctx, cmDspVarArg_t* arg, const cmChar_t* labelPrefix, unsigned labelId, unsigned constId, unsigned rn, unsigned cn, unsigned flags, const cmChar_t* docStr ); unsigned cmDspArgCopy( cmDspVarArg_t* argArray, unsigned argN, unsigned dstIdx, const cmDspVarArg_t* s, unsigned sn ); unsigned cmDspArgSetupN( cmDspCtx_t* ctx, cmDspVarArg_t* arg, unsigned argN, unsigned dstIdx, unsigned cnt, const cmChar_t* labelPrefix, unsigned baseConstId, unsigned rn, unsigned cn, unsigned flags, const cmChar_t* staticDocStr ); void cmDspArgSetupNull( cmDspVarArg_t* arg ); const cmChar_t* cmDspInstLabel( cmDspCtx_t* ctx, cmDspInst_t* inst ); // Given and instance and a variable symbol id return a pointer to the variable. cmDspVar_t* cmDspVarSymbolToPtr( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varSymId, unsigned flags ); // Given an instance and a var id return a pointer to the variable. const cmDspVar_t* cmDspVarIdToCPtr( const cmDspInst_t* inst, unsigned varId ); cmDspVar_t* cmDspVarIdToPtr( cmDspInst_t* inst, unsigned varId ); const cmChar_t* cmDspVarLabel( cmDspCtx_t* ctx, const cmDspInst_t* inst, unsigned varId ); // Make callbacks for the specified instance var. cmDspRC_t cmDspOutputEvent( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId ); cmDspRC_t cmDspVarPresetWrite( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId ); cmDspRC_t cmDspVarPresetRead( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId ); cmDspRC_t cmDspVarPresetRdWr( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, bool storeFl ); double cmDspSampleRate( cmDspCtx_t* ctx ); unsigned cmDspSamplesPerCycle( cmDspCtx_t* ctx ); // Query the type of a variable unsigned cmDspTypeFlags(const cmDspInst_t* inst, unsigned varId ); bool cmDspIsBool( const cmDspInst_t* inst, unsigned varId ); bool cmDspIsInt( const cmDspInst_t* inst, unsigned varId ); bool cmDspIsUInt( const cmDspInst_t* inst, unsigned varId ); bool cmDspIsDouble( const cmDspInst_t* inst, unsigned varId ); bool cmDspIsStrz( const cmDspInst_t* inst, unsigned varId ); bool cmDspIsSymbol( const cmDspInst_t* inst, unsigned varId ); bool cmDspIsJson( const cmDspInst_t* inst, unsigned varId ); // Get the value of an instance variable. bool cmDspBool( cmDspInst_t* inst, unsigned varId ); int cmDspInt( cmDspInst_t* inst, unsigned varId ); unsigned cmDspUInt( cmDspInst_t* inst, unsigned varId ); double cmDspDouble( cmDspInst_t* inst, unsigned varId ); const cmChar_t* cmDspStrcz( cmDspInst_t* inst, unsigned varId ); unsigned cmDspSymbol( cmDspInst_t* inst, unsigned varId ); cmJsonNode_t* cmDspJson( cmDspInst_t* inst, unsigned varId ); // Get the default value of an instance variable. bool cmDspDefaultBool( cmDspInst_t* inst, unsigned varId ); int cmDspDefaultInt( cmDspInst_t* inst, unsigned varId ); unsigned cmDspDefaultUInt( cmDspInst_t* inst, unsigned varId ); double cmDspDefaultDouble( cmDspInst_t* inst, unsigned varId ); const cmChar_t* cmDspDefaultStrcz( cmDspInst_t* inst, unsigned varId ); unsigned cmDspDefaultSymbol( cmDspInst_t* inst, unsigned varId ); cmJsonNode_t* cmDspDefaultJson( cmDspInst_t* inst, unsigned varId ); // Possible values for cmDspSetXXX() enum { kUpdateUiDspFl = 0x00, kNoUpdateUiDspFl = 0x01, // don't callback the UI kNoAllocDspFl = 0x02, // the caller is handling memory mgmt for the incoming value don't allocate space for it internally kSetDefaultDspFl = 0x04, // set the var default value rather than the current value kNoSendDspFl = 0x08 // do not transmit the value to connected objects }; // Instance variable setter functions: // // All forms of the setter assign a value to of the specified instance variable and // then make the callbacks attached to the variable. Note that callbacks to the UI // can be prevented by setting the kNoUpdateUiDspFl in the call to cmDspSetX(). // // // All setters are implemented in terms of the cmDspValueSet() // // Convert the source value (svp) to the type of the target var (inst->varArray[varId]) // and assign it to the var value. All the cmDspSetXXX() functions work in terms of this function. // See the kXXXDspFl flags above for possible 'flag' values. cmDspRC_t cmDspValueSet( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmDspValue_t* vp, unsigned flags ); // Assign the default value to the current value (if the the specified variable has a valid default value). cmDspRC_t cmDspApplyDefault( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId ); // Apply the default value to the current value for all variables which has a valid default value. // This is cmDspRC_t cmDspApplyAllDefaults( cmDspCtx_t* ctx, cmDspInst_t* inst ); // Set the default value of a variable. cmDspRC_t cmDspSetDefault( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmDspValue_t* valPtr ); // Set the default variable of a variable to 'val'. // The call is ignored (and the default value is not set) if the default // value was previously set to a vaue which is not equal to 'nonInitVal'. cmDspRC_t cmDspSetDefaultBool( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, bool nonInitVal, bool val ); cmDspRC_t cmDspSetDefaultInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, int nonInitVal, int val ); cmDspRC_t cmDspSetDefaultUInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned nonInitVal, unsigned val ); cmDspRC_t cmDspSetDefaultDouble( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, double nonInitVal, double val ); cmDspRC_t cmDspSetDefaultStrcz( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmChar_t* nonInitVal, const cmChar_t* val ); cmDspRC_t cmDspSetDefaultSymbol( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, /*unsigned cmInvalidId*/ unsigned val ); cmDspRC_t cmDspSetDefaultJson( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmJsonNode_t* nonInitVal, cmJsonNode_t* val ); // Set the value of a variable and make any attached callbacks. // If the kUiDsvFl is set on the variable then the UI is also informed of the new value. // If the source ('val') type does not match the variable type then if possible the // source is converted to the dest (variable) type. // This function is implemented in terms of cmDspValueSet(). cmDspRC_t cmDspSetBool( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, bool val ); cmDspRC_t cmDspSetInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, int val ); cmDspRC_t cmDspSetUInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned val ); cmDspRC_t cmDspSetDouble( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, double val ); cmDspRC_t cmDspSetStrcz( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmChar_t* val ); cmDspRC_t cmDspSetSymbol( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned val ); cmDspRC_t cmDspSetJson( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmJsonNode_t* val ); // Set the value of a variable to the *evt->valuePtr and make any attached callbacks. // If the kUiDsvFl is set and kNoUiEchoDspFl is not set in evt->flags then UI is informed of the new value. // If the source (*evt->valuePtr) type does not match the variable type then if possible the // source is converted to the dest (variable) type. // This function is implemented in terms of cmDspValueSet(). cmDspRC_t cmDspSetEvent( cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt ); // Same as cmDspSetEvent() but the event is automatically echoed to the UI. cmDspRC_t cmDspSetEventUi( cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt ); // Same as cmDspSetEventUi() but change the event target variable to 'varId'. cmDspRC_t cmDspSetEventUiId( cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt, unsigned varId ); // Get the row and col count of a matrix valued instance variable. unsigned cmDspVarRows( cmDspInst_t* inst, unsigned varId ); unsigned cmDspVarCols( cmDspInst_t* inst, unsigned varId ); // Audio buffer helper functions bool cmDspIsAudioInputConnected( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId ); cmDspRC_t cmDspZeroAudioBuf( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId ); cmSample_t* cmDspAudioBuf( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned chIdx ); unsigned cmDspAudioBufSmpCount( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned chIdx ); // Register dspInstPtr to receive a callback when srcInstPtr generates an event identified by srcVarId. cmDspRC_t cmDspInstInstallCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, unsigned srcVarId, cmDspInst_t* dstInstPtr, unsigned dstVarSymId, void* dstCbDataPtr); cmDspRC_t cmDspInstallCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, const cmChar_t* srcVarLabel, cmDspInst_t* dstInstPtr, const cmChar_t* dstVarLabel, void* dstCbDataPtr); // Uninstall a previous registred instance variable callback function. cmDspRC_t cmDspInstRemoveCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, unsigned srcVarId, cmDspInst_t* dstInstPtr, unsigned dstVarId ); cmDspRC_t cmDspRemoveCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, const cmChar_t* srcVarLabel, cmDspInst_t* dstInstPtr, unsigned dstVarId ); // cmDspRC_t cmDspInstVarSetFlags( cmDspCtx_t* ctx, cmDspInst_t* instPtr, unsigned varId, unsigned flags ); // Used to transmit messages to the audio system. cmDspRC_t cmDspSendValueToAudioSys( cmDspCtx_t* ctx, unsigned msgTypeId, unsigned selId, unsigned valId, const cmDspValue_t* valPtr ); // The following functions are used to send message to the UI and are // implemented in cmDspUi.c. They are declared here because they are // visible to the cmDspInst functions which use them but are not available // to the host UI. The other values defined and declared in cmDspUi.h are // common to both the host UI and the DSP instances. cmDspRC_t cmDspUiConsolePrint( cmDspCtx_t* ctx, cmChar_t* text ); cmDspRC_t cmDspUiSendValue( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmDspValue_t* valPtr ); cmDspRC_t cmDspUiSendVar( cmDspCtx_t* ctx, cmDspInst_t* inst, cmDspVar_t* var ); cmDspRC_t cmDspUiScalarCreate( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned typeDuiId, unsigned minVarId, unsigned maxVarId, unsigned stpVarId, unsigned valVarId, unsigned lblVarId ); cmDspRC_t cmDspUiTextCreate( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned valVarId, unsigned lblVarId ); cmDspRC_t cmDspUiMeterCreate( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned minVarId, unsigned maxVarId, unsigned valVarId, unsigned lblVarId ); cmDspRC_t cmDspUiButtonCreate( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned typeDuiId, unsigned outVarId, unsigned lblVarId ); cmDspRC_t cmDspUiLabelCreate( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned lblVarId, unsigned alignVarId ); cmDspRC_t cmDspUiNewColumn( cmDspCtx_t* ctx, unsigned colW ); cmDspRC_t cmDspUiInsertHorzBorder( cmDspCtx_t* ctx ); cmDspRC_t cmDspUiNewPage( cmDspCtx_t* ctx, const cmChar_t* title ); enum { kFnameFnDspFl=0x00, kFnameDirDspFl=0x01 }; cmDspRC_t cmDspUiFnameCreate( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned valVarId, unsigned patVarId, unsigned dirVarId ); cmDspRC_t cmDspUiMsgListCreate(cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned height, unsigned listVarId, unsigned selVarId ); #ifdef __cplusplus } #endif #endif