libcm is a C development framework with an emphasis on audio signal processing applications.
您最多选择25个主题 主题必须以字母或数字开头,可以包含连字符 (-),并且长度不得超过35个字符

cmDspClass.c 43KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444
  1. #include "cmPrefix.h"
  2. #include "cmGlobal.h"
  3. #include "cmFloatTypes.h"
  4. #include "cmRpt.h"
  5. #include "cmErr.h"
  6. #include "cmCtx.h"
  7. #include "cmMem.h"
  8. #include "cmMallocDebug.h"
  9. #include "cmLinkedHeap.h"
  10. #include "cmSymTbl.h"
  11. #include "cmPrefs.h"
  12. #include "cmJson.h"
  13. #include "cmDspValue.h"
  14. #include "cmMsgProtocol.h"
  15. #include "cmThread.h"
  16. #include "cmUdpPort.h"
  17. #include "cmUdpNet.h"
  18. #include "cmAudioSys.h"
  19. #include "cmProcObj.h"
  20. #include "cmDspCtx.h"
  21. #include "cmDspClass.h"
  22. #include "cmDspSys.h"
  23. cmDspRC_t cmDspClassSetup(
  24. cmDspClass_t* classPtr,
  25. cmDspCtx_t* ctx,
  26. const cmChar_t* classLabel,
  27. cmDspClassFunc_t finalClassFunc,
  28. cmDspConsFunc_t allocFunc,
  29. cmDspFunc_t freeFunc,
  30. cmDspFunc_t resetFunc,
  31. cmDspFunc_t execFunc,
  32. cmDspFunc_t recvFunc,
  33. cmDspStoreFunc_t storeFunc,
  34. cmDspAttrSymFunc_t sysRecvFunc,
  35. const cmChar_t* doc )
  36. {
  37. classPtr->labelStr = classLabel;
  38. classPtr->doc = doc;
  39. classPtr->finalClassFunc = finalClassFunc;
  40. classPtr->allocFunc = allocFunc;
  41. classPtr->freeFunc = freeFunc;
  42. classPtr->resetFunc = resetFunc;
  43. classPtr->execFunc = execFunc;
  44. classPtr->recvFunc = recvFunc;
  45. classPtr->storeFunc = storeFunc;
  46. classPtr->sysRecvFunc = sysRecvFunc;
  47. cmErrSetup( &classPtr->err, ctx->rpt, classLabel);
  48. return kOkDspRC;
  49. }
  50. // default DSP instance system recv function
  51. cmDspRC_t _cmDspInstSysRecvFunc( cmDspCtx_t* ctx, struct cmDspInst_str* inst, unsigned attrSymId, const cmDspValue_t* value )
  52. {
  53. if( cmDsvIsSymbol(value) )
  54. {
  55. unsigned msgSymId = cmDsvSymbol(value);
  56. if( msgSymId == ctx->_disableSymId )
  57. {
  58. inst->flags = cmSetFlag(inst->flags,kDisableExecInstFl );
  59. //printf("%s disabled\n",cmStringNullGuard(cmDspInstLabel(ctx,inst)));
  60. }
  61. else
  62. {
  63. if( msgSymId == ctx->_enableSymId )
  64. {
  65. inst->flags = cmClrFlag(inst->flags,kDisableExecInstFl );
  66. //printf("%s enabled\n",cmStringNullGuard(cmDspInstLabel(ctx,inst)));
  67. }
  68. }
  69. }
  70. if( inst->classPtr->sysRecvFunc != NULL )
  71. return inst->classPtr->sysRecvFunc(ctx,inst,attrSymId,value);
  72. return kOkDspRC;
  73. }
  74. void* cmDspInstAllocate(
  75. cmDspCtx_t* ctx,
  76. cmDspClass_t* classPtr,
  77. const cmDspVarArg_t* argV,
  78. unsigned instByteCnt,
  79. unsigned instSymId,
  80. unsigned instId,
  81. unsigned storeSymId,
  82. unsigned va_cnt,
  83. va_list vl )
  84. {
  85. unsigned i;
  86. unsigned varCnt = 0;
  87. unsigned varDataByteCnt = 0;
  88. unsigned va_idx = 0;
  89. unsigned reqArgCnt = 0;
  90. // check for duplicate variable names
  91. for(i=0; argV[i].label != NULL; ++i)
  92. if( argV[i].label != NULL )
  93. {
  94. unsigned j = 0;
  95. for(j=0; argV[j].label != NULL; ++j)
  96. if( i != j && argV[j].label != NULL && strcmp(argV[i].label,argV[j].label) == 0 )
  97. {
  98. // two variables have the same name
  99. unsigned mask = kInDsvFl | kOutDsvFl;
  100. // we allow two variables to have the same name as long as they are not both inputs or outputs
  101. if( (argV[j].flags & mask) == (argV[i].flags & mask))
  102. cmDspClassErr(ctx,classPtr,kVarDuplicateDspRC,"The variable label '%s' is used by multiple variables.",argV[i].label);
  103. }
  104. }
  105. // determine the count and size of the instance variables
  106. for(i=0; argV[i].label != NULL; ++i,++varCnt)
  107. {
  108. unsigned rn = argV[i].rn;
  109. unsigned flags = argV[i].flags;
  110. // audio buffer sample count is determined automatically
  111. if( cmAllFlags( argV[i].flags, kAudioBufDsvFl | kOutDsvFl ) )
  112. {
  113. rn = ctx->ctx->ss->args.dspFramesPerCycle;
  114. flags = kSampleDsvFl | kMtxDsvFl;
  115. }
  116. // determine the space needed for matrices of known size
  117. if( cmIsFlag(flags,kMtxDsvFl) && (rn*argV[i].cn) )
  118. {
  119. unsigned n = cmDsvByteCount( flags, rn, argV[i].cn );
  120. varDataByteCnt += n;
  121. }
  122. // determine the number of required arguments
  123. reqArgCnt += cmIsFlag(flags,kReqArgDsvFl) ? 1 : 0;
  124. }
  125. unsigned varRecdByteCnt = varCnt * sizeof(cmDspVar_t);
  126. unsigned ttlByteCnt = instByteCnt + varRecdByteCnt + varDataByteCnt;
  127. char* p = cmLHeapAllocZ(ctx->lhH, ttlByteCnt); // allocate the instance memory
  128. char* ep = p + ttlByteCnt; // record the end of the alloc'd memory
  129. cmDspInst_t* ip = (cmDspInst_t*)p; // set the instance ptr
  130. cmDspVar_t* varArray = (cmDspVar_t*)(p + instByteCnt); // set the instance variable recd array
  131. char* varDataPtr = (char*)(varArray + varCnt); // set the base of variable data buffer
  132. // setup the instance record
  133. ip->classPtr = classPtr;
  134. ip->symId = instSymId;
  135. ip->id = instId;
  136. ip->flags = kDisableExecInstFl;
  137. ip->presetGroupSymId = storeSymId;
  138. ip->varArray = varArray;
  139. ip->varCnt = varCnt;
  140. ip->freeFunc = classPtr->freeFunc;
  141. ip->resetFunc = classPtr->resetFunc;
  142. ip->execFunc = classPtr->execFunc;
  143. ip->recvFunc = classPtr->recvFunc;
  144. ip->storeFunc = classPtr->storeFunc;
  145. ip->sysRecvFunc = _cmDspInstSysRecvFunc;
  146. if( reqArgCnt > va_cnt )
  147. cmDspInstErr(ctx,ip,kVarArgParseFailDspRC,"The class requires %i arguments but only %i were given.",reqArgCnt,va_cnt);
  148. // setup the variable records
  149. for(i=0; i<varCnt; ++i)
  150. {
  151. unsigned flags = argV[i].flags;
  152. unsigned rn = argV[i].rn;
  153. // handle requests for audio output buffers
  154. if( cmAllFlags(argV[i].flags, kAudioBufDsvFl | kOutDsvFl ) )
  155. {
  156. // remove the audio buffer flag and reconstitute as a generic cmDspValue sample mtx type.
  157. //flags = cmClrFlag( argV[i].flags, kAudioBufDsvFl | kTypeDsvMask );
  158. flags = kSampleDsvFl | kMtxDsvFl;
  159. rn = ctx->ctx->ss->args.dspFramesPerCycle;
  160. }
  161. // the constId must be the same as the var index
  162. assert( i == argV[i].constId );
  163. bool reqArgFl = cmIsFlag(argV[i].flags,kReqArgDsvFl);
  164. bool optArgFl = cmIsFlag(argV[i].flags,kOptArgDsvFl);
  165. // verify that the required arg. exists
  166. if( reqArgFl && i>va_cnt )
  167. cmDspInstErr(ctx,ip,kVarArgParseFailDspRC,"The required argument '%s' is missing",argV[i].label);
  168. ip->varArray[i].flags = argV[i].flags; // store the original flag set as the var flags
  169. ip->varArray[i].constId = argV[i].constId;
  170. ip->varArray[i].symId = cmSymTblRegisterSymbol(ctx->stH,argV[i].label);
  171. ip->varArray[i].doc = argV[i].doc;
  172. ip->varArray[i].value.flags = argV[i].flags & kTypeDsvMask;
  173. // if this is a required or optional constructor arg. then assign it as the
  174. // default value for this variable
  175. if( va_idx < va_cnt && (reqArgFl || optArgFl) )
  176. {
  177. cmDspValue_t* vp = &ip->varArray[i].value;
  178. switch(ip->varArray[i].value.flags)
  179. {
  180. case kBoolDsvFl: cmDsvSetBool( vp, va_arg(vl,int )); break;
  181. case kCharDsvFl: cmDsvSetChar( vp, va_arg(vl,int )); break;
  182. case kUCharDsvFl: cmDsvSetUChar( vp, va_arg(vl,int )); break;
  183. case kShortDsvFl: cmDsvSetShort( vp, va_arg(vl,int )); break;
  184. case kUShortDsvFl: cmDsvSetUShort( vp, va_arg(vl,int )); break;
  185. case kLongDsvFl: cmDsvSetLong( vp, va_arg(vl,long )); break;
  186. case kULongDsvFl: cmDsvSetULong( vp, va_arg(vl,unsigned long )); break;
  187. case kIntDsvFl: cmDsvSetInt( vp, va_arg(vl,int )); break;
  188. case kUIntDsvFl: cmDsvSetUInt( vp, va_arg(vl,unsigned )); break;
  189. case kFloatDsvFl: cmDsvSetFloat( vp, va_arg(vl,double )); break;
  190. case kDoubleDsvFl: cmDsvSetDouble( vp, va_arg(vl,double )); break;
  191. case kSampleDsvFl: cmDsvSetSample( vp, va_arg(vl,double )); break;
  192. case kRealDsvFl: cmDsvSetReal( vp, va_arg(vl,double )); break;
  193. case kStrzDsvFl: cmDsvSetStrz( vp, va_arg(vl,cmChar_t* )); break;
  194. case kSymDsvFl: cmDsvSetSymbol( vp, va_arg(vl,unsigned )); break;
  195. default:
  196. cmDspInstErr(ctx,ip,kVarArgParseFailDspRC,"A var-args parse error occurred while parsing the variable '%s'.",argV[i].label);
  197. }
  198. // set the default value from the initial value
  199. cmDspValueSet(ctx, ip, i, vp, kSetDefaultDspFl );
  200. // store the fact that the default value was explicitely set.
  201. ip->varArray[i].flags = cmSetFlag(ip->varArray[i].flags,kDfltSetDsvFl);
  202. // track the number of va_list arg's read
  203. ++va_idx;
  204. }
  205. // assign memory to the matrix types of known size
  206. if( cmIsFlag(flags,kMtxDsvFl) && (rn*argV[i].cn) )
  207. {
  208. cmDsvSetMtx( &ip->varArray[i].value, flags, varDataPtr, rn, argV[i].cn );
  209. unsigned n = cmDsvByteCount( flags, rn, argV[i].cn );
  210. varDataPtr += n;
  211. }
  212. }
  213. assert( varDataPtr == ep );
  214. return p;
  215. }
  216. void _cmDspParseArgV( cmDspVarArg_t* a, va_list vl )
  217. {
  218. a->label = va_arg(vl,const char*);
  219. a->constId = va_arg(vl,unsigned);
  220. a->rn = va_arg(vl,unsigned);
  221. a->cn = va_arg(vl,unsigned);
  222. a->flags = va_arg(vl,unsigned);
  223. a->doc = va_arg(vl,const char*);
  224. }
  225. void* cmDspInstAllocateV(cmDspCtx_t* ctx, cmDspClass_t* classPtr, unsigned instByteCnt, unsigned instSymId, unsigned instId, unsigned storeSymId, unsigned va_cnt, va_list vl0, ... )
  226. {
  227. va_list vl1,vl2;
  228. va_start(vl1,vl0);
  229. va_copy(vl2,vl1);
  230. unsigned argCnt = 0;
  231. int repeatCnt;
  232. while( (repeatCnt = va_arg(vl1,int)) != 0 )
  233. {
  234. cmDspVarArg_t a;
  235. // do some value checking to possibly catch problems with the var_args format
  236. assert( repeatCnt > 0 && repeatCnt < 255 );
  237. argCnt += repeatCnt;
  238. _cmDspParseArgV(&a,vl1);
  239. }
  240. va_end(vl1);
  241. cmDspVarArg_t aa[ argCnt+1 ];
  242. unsigned j=0;
  243. while( (repeatCnt = va_arg(vl2,int)) != 0 )
  244. {
  245. cmDspVarArg_t a;
  246. _cmDspParseArgV(&a,vl2);
  247. cmDspArgSetupN(ctx,aa,argCnt,j,repeatCnt,a.label,a.constId,a.rn, a.cn, a.flags, a.doc );
  248. j += repeatCnt;
  249. }
  250. cmDspArgSetupNull(aa + argCnt);
  251. va_end(vl2);
  252. return cmDspInstAllocate(ctx,classPtr,aa,instByteCnt,instSymId,instId,storeSymId,va_cnt,vl0);
  253. }
  254. cmDspInstSymId_t* _cmDspInstFindAttrSymId( cmDspInst_t* inst, unsigned symId )
  255. {
  256. cmDspInstSymId_t* ip = inst->symIdList;
  257. for(; ip != NULL; ip=ip->link)
  258. if( ip->symId == symId )
  259. return ip;
  260. return NULL;
  261. }
  262. bool cmDspInstHasAttrSym( cmDspInst_t* inst, unsigned attrSymId )
  263. { return _cmDspInstFindAttrSymId(inst,attrSymId) != NULL; }
  264. cmDspRC_t cmDspInstRegisterAttrSym( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned symId )
  265. {
  266. cmDspInstSymId_t* ip;
  267. // if this symbol is already registered
  268. if((ip = _cmDspInstFindAttrSymId(inst,symId)) != NULL )
  269. return cmDspInstErr(ctx,inst,kOkDspRC,"The symbol '%s' is already registered with the instance.",cmStringNullGuard(cmSymTblLabel(ctx->stH,symId)));
  270. // try to find an unused symbol
  271. ip = inst->symIdList;
  272. for(; ip != NULL; ip=ip->link)
  273. if( ip->symId == cmInvalidId )
  274. break;
  275. // if no unused symbols were found then allocate a new one
  276. if( ip == NULL )
  277. {
  278. ip = cmLhAllocZ(ctx->lhH, cmDspInstSymId_t, 1 );
  279. ip->link = inst->symIdList;
  280. inst->symIdList = ip;
  281. }
  282. ip->symId = symId;
  283. return kOkDspRC;
  284. }
  285. cmDspRC_t cmDspInstRemoveAttrSym( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned symId )
  286. {
  287. cmDspInstSymId_t* ip;
  288. // if this symbol is already registered
  289. if((ip = _cmDspInstFindAttrSymId(inst,symId)) == NULL )
  290. return cmDspInstErr(ctx,inst,kOkDspRC,"The symbol '%s' is could not be found to be removed from the instance.",cmStringNullGuard(cmSymTblLabel(ctx->stH,symId)));
  291. // mark a symbol recd as inactive by setting the symbol id to cmInalidId
  292. ip->symId = cmInvalidId;
  293. return kOkDspRC;
  294. }
  295. cmDspRC_t _cmDspClassErrV( cmDspCtx_t* ctx, cmDspClass_t* classPtr, unsigned instId, cmDspRC_t rc, const cmChar_t* fmt, va_list vl )
  296. {
  297. va_list vl2;
  298. va_copy(vl2,vl);
  299. unsigned n = vsnprintf(NULL,0,fmt,vl2)+1;
  300. cmChar_t buf[n+1];
  301. vsnprintf(buf,n,fmt,vl);
  302. if( instId == cmInvalidId )
  303. cmErrMsg( &classPtr->err, rc, "%s DSP Class:%s",buf, classPtr->labelStr);
  304. else
  305. cmErrMsg( &classPtr->err, rc, "%s DSP Class:%s Inst:%i",buf, classPtr->labelStr,instId);
  306. va_end(vl2);
  307. return rc;
  308. }
  309. cmDspRC_t cmDspClassErr( cmDspCtx_t* ctx, cmDspClass_t* classPtr, cmDspRC_t rc, const cmChar_t* fmt, ... )
  310. {
  311. va_list vl;
  312. va_start(vl,fmt);
  313. rc = _cmDspClassErrV(ctx,classPtr,cmInvalidId,rc,fmt,vl);
  314. va_end(vl);
  315. return rc;
  316. }
  317. cmDspRC_t cmDspInstErr( cmDspCtx_t* ctx, cmDspInst_t* inst, cmDspRC_t rc, const cmChar_t* fmt, ... )
  318. {
  319. va_list vl;
  320. va_start(vl,fmt);
  321. rc = _cmDspClassErrV(ctx,inst->classPtr,inst->id,rc,fmt,vl);
  322. va_end(vl);
  323. return rc;
  324. }
  325. void cmDspArgSetup(
  326. cmDspCtx_t* ctx,
  327. cmDspVarArg_t* arg,
  328. const cmChar_t* labelPrefix,
  329. unsigned labelId,
  330. unsigned constId,
  331. unsigned rn,
  332. unsigned cn,
  333. unsigned flags,
  334. const cmChar_t* docStr )
  335. {
  336. unsigned labelIdCharCnt = (unsigned)floor( labelId==0 ? 1.0 : log10(abs(labelId)) + 1.0 );
  337. int labelCharCnt = strlen(labelPrefix) + 1 + labelIdCharCnt + 1;
  338. cmChar_t label[ labelCharCnt + 1 ];
  339. const cmChar_t* lp;
  340. if( labelId == cmInvalidId )
  341. lp = labelPrefix;
  342. else
  343. {
  344. lp = label;
  345. label[labelCharCnt] = 0;
  346. snprintf(label,labelCharCnt,"%s-%i",labelPrefix,labelId);
  347. }
  348. // use the symbol table to hold the label string
  349. arg->label = cmSymTblLabel(ctx->stH,cmSymTblRegisterSymbol(ctx->stH,lp));
  350. arg->constId = constId;
  351. arg->rn = rn;
  352. arg->cn = cn;
  353. arg->flags = flags;
  354. arg->doc = cmLhAllocStr(ctx->lhH,docStr);;
  355. }
  356. unsigned cmDspArgCopy( cmDspVarArg_t* argArray, unsigned argN, unsigned dstIdx, const cmDspVarArg_t* s, unsigned sn )
  357. {
  358. assert( dstIdx + sn <= argN );
  359. unsigned i;
  360. for(i=0; i<sn; ++i)
  361. argArray[dstIdx+i] = s[i];
  362. return dstIdx + i;
  363. }
  364. unsigned cmDspArgSetupN(
  365. cmDspCtx_t* ctx,
  366. cmDspVarArg_t* arg,
  367. unsigned argN,
  368. unsigned dstIdx,
  369. unsigned cnt,
  370. const cmChar_t* labelPrefix,
  371. unsigned baseConstId,
  372. unsigned rn,
  373. unsigned cn,
  374. unsigned flags,
  375. const cmChar_t* staticDocStr )
  376. {
  377. assert( dstIdx + cnt <= argN );
  378. unsigned i;
  379. for(i=0; i<cnt; ++i)
  380. cmDspArgSetup(ctx,arg + dstIdx + i,labelPrefix, cnt==1 ? cmInvalidId : i, baseConstId + i, rn, cn, flags, staticDocStr );
  381. return dstIdx + i;
  382. }
  383. void cmDspArgSetupNull( cmDspVarArg_t* arg )
  384. { memset(arg,0,sizeof(*arg)); }
  385. const cmChar_t* cmDspInstLabel( cmDspCtx_t* ctx, cmDspInst_t* inst )
  386. {
  387. const char* noInstLbl = "<no_inst_lbl>";
  388. const char* lbl = noInstLbl;
  389. if( inst->symId == cmInvalidId )
  390. return lbl;
  391. if((lbl = cmSymTblLabel(ctx->stH,inst->symId)) == NULL )
  392. lbl = noInstLbl;
  393. return lbl;
  394. }
  395. cmDspRC_t _cmDspVarPtr( const cmDspInst_t* inst, unsigned varId, cmDspVar_t** retVarPtrPtr )
  396. {
  397. if( varId >= inst->varCnt )
  398. {
  399. *retVarPtrPtr = NULL;
  400. return cmErrMsg(&inst->classPtr->err,kVarNotFoundDspRC,"The variable id %i is invalid for DSP instance '%s' (id:%i) .", varId, inst->classPtr->labelStr, inst->id );
  401. }
  402. assert( inst->varArray[varId].constId == varId );
  403. *retVarPtrPtr = inst->varArray + varId;
  404. return kOkDspRC;
  405. }
  406. cmDspRC_t _cmDspVarAndValuePtr( cmDspInst_t* inst, unsigned varId, cmDspVar_t** varPtrPtr, cmDspValue_t** valPtrPtr )
  407. {
  408. cmDspRC_t rc;
  409. if((rc = _cmDspVarPtr(inst,varId,varPtrPtr)) != kOkDspRC )
  410. *valPtrPtr = NULL;
  411. else
  412. *valPtrPtr = cmDsvValuePtr(&(*varPtrPtr)->value);
  413. return rc;
  414. }
  415. cmDspRC_t _cmDspVarValuePtr( cmDspInst_t* inst, unsigned varId, cmDspValue_t** retValPtrPtr )
  416. {
  417. cmDspVar_t* varPtr = NULL;
  418. cmDspRC_t rc;
  419. if((rc = _cmDspVarPtr(inst,varId,&varPtr)) != kOkDspRC )
  420. *retValPtrPtr = NULL;
  421. else
  422. *retValPtrPtr = cmDsvValuePtr(&varPtr->value);
  423. return rc;
  424. }
  425. cmDspRC_t _cmDspVarDefaultPtr( cmDspInst_t* inst, unsigned varId, cmDspValue_t** retValPtrPtr )
  426. {
  427. cmDspVar_t* varPtr = NULL;
  428. cmDspRC_t rc;
  429. if((rc = _cmDspVarPtr(inst,varId,&varPtr)) != kOkDspRC )
  430. *retValPtrPtr = NULL;
  431. else
  432. *retValPtrPtr = &varPtr->dflt;
  433. return rc;
  434. }
  435. void _cmDspSendEvt( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, unsigned srcVarId, const cmDspVar_t* varPtr )
  436. {
  437. cmDspEvt_t e;
  438. cmDspCb_t* cbp = varPtr->cbList;
  439. if( cbp == NULL )
  440. return;
  441. e.flags = kDfltEvtDspFlags;
  442. e.srcInstPtr = srcInstPtr;
  443. e.srcVarId = srcVarId;
  444. e.valuePtr = &varPtr->value;
  445. for(; cbp!=NULL; cbp=cbp->linkPtr)
  446. {
  447. e.dstVarId = cbp->dstVarId;
  448. e.dstDataPtr = cbp->dstDataPtr;
  449. if( cbp->dstInstPtr->recvFunc!=NULL)
  450. cbp->dstInstPtr->recvFunc(ctx,cbp->dstInstPtr,&e);
  451. }
  452. }
  453. cmDspVar_t* cmDspVarSymbolToPtr( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varSymId, unsigned flags )
  454. {
  455. unsigned i;
  456. for(i=0; i<inst->varCnt; ++i)
  457. if( inst->varArray[i].symId == varSymId )
  458. {
  459. if( flags==0 || cmAllFlags(inst->varArray[i].flags,flags) )
  460. return inst->varArray + i;
  461. }
  462. cmDspInstErr(ctx,inst,kVarNotFoundDspRC,"The variable '%s' could not be found in the instance '%s' (id:%i).",
  463. cmSymTblLabel( ctx->stH, varSymId), inst->classPtr->labelStr, inst->id );
  464. return NULL;
  465. }
  466. const cmDspVar_t* cmDspVarIdToCPtr( const cmDspInst_t* inst, unsigned varId )
  467. {
  468. cmDspVar_t* varPtr;
  469. if( _cmDspVarPtr(inst, varId, &varPtr) != kOkDspRC )
  470. return NULL;
  471. return varPtr;
  472. }
  473. cmDspVar_t* cmDspVarIdToPtr( cmDspInst_t* inst, unsigned varId )
  474. {
  475. cmDspVar_t* varPtr;
  476. if( _cmDspVarPtr(inst, varId, &varPtr) != kOkDspRC )
  477. return NULL;
  478. return varPtr;
  479. }
  480. const cmChar_t* cmDspVarLabel( cmDspCtx_t* ctx, const cmDspInst_t* inst, unsigned varId )
  481. {
  482. const cmDspVar_t* varPtr;
  483. if(( varPtr = cmDspVarIdToCPtr(inst,varId) ) == NULL )
  484. return NULL;
  485. return cmSymTblLabel( ctx->stH, varPtr->symId);
  486. }
  487. cmDspRC_t cmDspOutputEvent( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId )
  488. {
  489. cmDspRC_t rc;
  490. cmDspVar_t* varPtr;
  491. if((rc = _cmDspVarPtr(inst, varId, &varPtr )) != kOkDspRC )
  492. return rc;
  493. _cmDspSendEvt(ctx, inst, varId, varPtr );
  494. return rc;
  495. }
  496. cmDspRC_t cmDspVarPresetWrite( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId )
  497. {
  498. cmDspRC_t rc;
  499. const cmDspVar_t* varPtr;
  500. if((varPtr = cmDspVarIdToCPtr(inst,varId)) == NULL )
  501. return cmDspInstErr(ctx,inst,kVarNotFoundDspRC,"Var with id %i not found during preset store.");
  502. if((rc = cmDspSysPresetWriteValue(ctx->dspH, varPtr->symId, &varPtr->value )) != kOkDspRC )
  503. return cmDspInstErr(ctx,inst,kSubSysFailDspRC,"Var preset storage failed on var:'%s'.",cmStringNullGuard(cmSymTblLabel(ctx->stH,varPtr->symId)));
  504. return rc;
  505. }
  506. cmDspRC_t cmDspVarPresetRead( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId )
  507. {
  508. cmDspRC_t rc;
  509. cmDspVar_t* varPtr;
  510. cmDspValue_t value;
  511. if((varPtr = cmDspVarIdToPtr(inst,varId)) == NULL )
  512. return cmDspInstErr(ctx,inst,kVarNotFoundDspRC,"Var with id %i not found during preset recall.");
  513. if((rc = cmDspSysPresetReadValue(ctx->dspH, varPtr->symId, &value )) != kOkDspRC )
  514. return cmDspInstErr(ctx,inst,kSubSysFailDspRC,"Var preset recall failed on var:'%s'.",cmStringNullGuard(cmSymTblLabel(ctx->stH,varPtr->symId)));
  515. return cmDspValueSet(ctx,inst,varId,&value,0);
  516. }
  517. cmDspRC_t cmDspVarPresetRdWr( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, bool storeFl )
  518. {
  519. cmDspRC_t rc;
  520. if( storeFl )
  521. rc = cmDspVarPresetWrite(ctx,inst,varId);
  522. else
  523. rc = cmDspVarPresetRead(ctx,inst,varId);
  524. return rc;
  525. }
  526. double cmDspSampleRate( cmDspCtx_t* ctx )
  527. { return ctx->ctx->ss->args.srate; }
  528. unsigned cmDspSamplesPerCycle( cmDspCtx_t * ctx )
  529. { return ctx->ctx->ss->args.dspFramesPerCycle; }
  530. unsigned cmDspTypeFlags(const cmDspInst_t* inst, unsigned varId )
  531. {
  532. cmDspVar_t* varPtr;
  533. unsigned flags;
  534. if( _cmDspVarPtr(inst,varId,&varPtr) != kOkDspRC )
  535. return 0;
  536. cmDspValue_t* valPtr = cmDsvValuePtr(&varPtr->value);
  537. if( valPtr->flags != 0 )
  538. flags = valPtr->flags;
  539. else
  540. flags = varPtr->flags;
  541. return flags & kTypeDsvMask;
  542. }
  543. bool cmDspIsBool( const cmDspInst_t* inst, unsigned varId )
  544. { return cmIsFlag(cmDspTypeFlags(inst,varId),kBoolDsvFl); }
  545. bool cmDspIsInt( const cmDspInst_t* inst, unsigned varId )
  546. { return cmIsFlag(cmDspTypeFlags(inst,varId),kIntDsvFl); }
  547. bool cmDspIsUInt( const cmDspInst_t* inst, unsigned varId )
  548. { return cmIsFlag(cmDspTypeFlags(inst,varId),kUIntDsvFl); }
  549. bool cmDspIsDouble( const cmDspInst_t* inst, unsigned varId )
  550. { return cmIsFlag(cmDspTypeFlags(inst,varId),kDoubleDsvFl); }
  551. bool cmDspIsStrz( const cmDspInst_t* inst, unsigned varId )
  552. { return cmIsFlag(cmDspTypeFlags(inst,varId),kStrzDsvFl); }
  553. bool cmDspIsSymbol( const cmDspInst_t* inst, unsigned varId )
  554. { return cmIsFlag(cmDspTypeFlags(inst,varId),kSymDsvFl); }
  555. bool cmDspIsJson( const cmDspInst_t* inst, unsigned varId )
  556. { return cmIsFlag(cmDspTypeFlags(inst,varId),kJsonDsvFl); }
  557. bool cmDspBool( cmDspInst_t* inst, unsigned varId )
  558. {
  559. cmDspValue_t* vp;
  560. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  561. return 0;
  562. return cmDsvGetBool(vp);
  563. }
  564. int cmDspInt( cmDspInst_t* inst, unsigned varId )
  565. {
  566. cmDspValue_t* vp;
  567. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  568. return 0;
  569. return cmDsvGetInt(vp);
  570. }
  571. unsigned cmDspUInt( cmDspInst_t* inst, unsigned varId )
  572. {
  573. cmDspValue_t* vp;
  574. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  575. return 0;
  576. return cmDsvGetUInt(vp);
  577. }
  578. double cmDspDouble( cmDspInst_t* inst, unsigned varId )
  579. {
  580. cmDspValue_t* vp;
  581. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  582. return 0;
  583. return cmDsvGetDouble(vp);
  584. }
  585. cmSample_t cmDspSample( cmDspInst_t* inst, unsigned varId )
  586. {
  587. cmDspValue_t* vp;
  588. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  589. return 0;
  590. return cmDsvGetSample(vp);
  591. }
  592. cmReal_t cmDspReal( cmDspInst_t* inst, unsigned varId )
  593. {
  594. cmDspValue_t* vp;
  595. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  596. return 0;
  597. return cmDsvGetReal(vp);
  598. }
  599. const cmChar_t* cmDspStrcz( cmDspInst_t* inst, unsigned varId )
  600. {
  601. cmDspValue_t* vp;
  602. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  603. return NULL;
  604. return cmDsvStrcz(vp);
  605. }
  606. unsigned cmDspSymbol( cmDspInst_t* inst, unsigned varId )
  607. {
  608. cmDspValue_t* vp;
  609. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  610. return cmInvalidId;
  611. return cmDsvSymbol(vp);
  612. }
  613. cmJsonNode_t* cmDspJson( cmDspInst_t* inst, unsigned varId )
  614. {
  615. cmDspValue_t* vp;
  616. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  617. return NULL;
  618. return cmDsvJson(vp);
  619. }
  620. bool cmDspDefaultBool( cmDspInst_t* inst, unsigned varId )
  621. {
  622. cmDspValue_t* vp;
  623. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  624. return 0;
  625. return cmDsvGetBool(vp);
  626. }
  627. int cmDspDefaultInt( cmDspInst_t* inst, unsigned varId )
  628. {
  629. cmDspValue_t* vp;
  630. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  631. return 0;
  632. return cmDsvGetInt(vp);
  633. }
  634. unsigned cmDspDefaultUInt( cmDspInst_t* inst, unsigned varId )
  635. {
  636. cmDspValue_t* vp;
  637. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  638. return 0;
  639. return cmDsvGetUInt(vp);
  640. }
  641. double cmDspDefaultDouble( cmDspInst_t* inst, unsigned varId )
  642. {
  643. cmDspValue_t* vp;
  644. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  645. return 0;
  646. return cmDsvGetDouble(vp);
  647. }
  648. cmSample_t cmDspDefaultSample( cmDspInst_t* inst, unsigned varId )
  649. {
  650. cmDspValue_t* vp;
  651. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  652. return 0;
  653. return cmDsvGetSample(vp);
  654. }
  655. cmReal_t cmDspDefaultReal( cmDspInst_t* inst, unsigned varId )
  656. {
  657. cmDspValue_t* vp;
  658. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  659. return 0;
  660. return cmDsvGetReal(vp);
  661. }
  662. const cmChar_t* cmDspDefaultStrcz( cmDspInst_t* inst, unsigned varId )
  663. {
  664. cmDspValue_t* vp;
  665. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  666. return NULL;
  667. return cmDsvGetStrcz(vp);
  668. }
  669. unsigned cmDspDefaultSymbol( cmDspInst_t* inst, unsigned varId )
  670. {
  671. cmDspValue_t* vp;
  672. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  673. return cmInvalidId;
  674. return cmDsvGetSymbol(vp);
  675. }
  676. cmJsonNode_t* cmDspDefaultJson( cmDspInst_t* inst, unsigned varId )
  677. {
  678. cmDspValue_t* vp;
  679. if(_cmDspVarDefaultPtr(inst,varId,&vp) != kOkDspRC )
  680. return NULL;
  681. return cmDsvGetJson(vp);
  682. }
  683. cmDspRC_t cmDspValueSet( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmDspValue_t* svp, unsigned flags )
  684. {
  685. cmDspRC_t rc;
  686. cmDspVar_t* varPtr;
  687. // get a pointer to the var recd
  688. if((rc = _cmDspVarPtr(inst,varId,&varPtr)) != kOkDspRC )
  689. return rc;
  690. // get a pointer to the target value.
  691. cmDspValue_t* dvp = cmIsFlag(flags,kSetDefaultDspFl) ? &varPtr->dflt : cmDsvValuePtr(&varPtr->value);
  692. // store a pointer to the dst string memory in case we need to delete it later
  693. cmChar_t* rlsPtr = cmAllFlags(dvp->flags,kStrzDsvFl | kDynDsvFl) ? dvp->u.z : NULL;
  694. // set the dest type to the type shared with the source
  695. // ( this assumes that the dst may have multiple types but the source has one type)
  696. unsigned typeFlags = (varPtr->flags & svp->flags) & kTypeDsvMask;
  697. // if svp->flags is set to kNullDsvFl then use just the dst type
  698. if( typeFlags == 0 )
  699. typeFlags = varPtr->flags & kTypeDsvMask;
  700. // convert the source to the var type
  701. switch(typeFlags)
  702. {
  703. case kBoolDsvFl:
  704. cmDsvSetBool( dvp, cmDsvGetBool(svp));
  705. break;
  706. case kIntDsvFl:
  707. cmDsvSetInt( dvp, cmDsvGetInt(svp));
  708. break;
  709. case kUIntDsvFl:
  710. cmDsvSetUInt( dvp, cmDsvGetUInt(svp));
  711. break;
  712. case kDoubleDsvFl:
  713. cmDsvSetDouble(dvp, cmDsvGetDouble(svp));
  714. break;
  715. case kSampleDsvFl:
  716. cmDsvSetSample(dvp, cmDsvGetSample(svp));
  717. break;
  718. case kRealDsvFl:
  719. cmDsvSetReal(dvp, cmDsvGetReal(svp));
  720. break;
  721. case kSymDsvFl:
  722. cmDsvSetSymbol(dvp, cmDsvGetSymbol(svp));
  723. break;
  724. case kJsonDsvFl:
  725. cmDsvSetJson( dvp, cmDsvJson(svp));
  726. break;
  727. case kStrzDsvFl:
  728. {
  729. const cmChar_t* sp;
  730. if( cmDsvIsSymbol(svp) )
  731. sp = cmSymTblLabel(ctx->stH,cmDsvSymbol(svp));
  732. else
  733. sp = cmDsvGetStrcz(svp);
  734. // don't copy over myself
  735. if( sp == dvp->u.z )
  736. rlsPtr = NULL;
  737. else
  738. {
  739. // if the source == NULL then set the dst to NULL
  740. // (NULL should always be a legitimate value)
  741. if( sp == NULL )
  742. cmDsvSetStrcz(dvp,sp);
  743. else
  744. {
  745. // if the source should not be copied into internal memory
  746. if( cmIsFlag(flags,kNoAllocDspFl) )
  747. cmDsvSetStrcz(dvp,sp);
  748. else
  749. {
  750. // allocate memory to hold the new string
  751. unsigned n = strlen(sp)+1;
  752. cmChar_t* dp = cmLhResizeN(ctx->lhH,cmChar_t,rlsPtr,n);
  753. strncpy(dp,sp,n);
  754. cmDsvSetStrz(dvp, dp);
  755. dvp->flags = cmSetFlag(dvp->flags,kDynDsvFl);
  756. rlsPtr = NULL;
  757. }
  758. }
  759. }
  760. }
  761. break;
  762. default:
  763. { assert(0); }
  764. }
  765. // if the dst contained a dynamically alloc'd string prior to being
  766. // set with a new value - then release the memory used by the original
  767. // string here
  768. if( rlsPtr != NULL )
  769. cmLHeapFree(ctx->lhH,rlsPtr);
  770. // notify listeners of the change of value
  771. if( cmIsFlag(flags,kNoSendDspFl) == false )
  772. _cmDspSendEvt( ctx, inst, varId, varPtr );
  773. // notify the UI of the change of value
  774. if( cmIsFlag(varPtr->flags,kUiDsvFl) && cmIsFlag(flags,kNoUpdateUiDspFl)==false )
  775. {
  776. cmDspUiSendVar( ctx, inst, varPtr );
  777. }
  778. return rc;
  779. }
  780. cmDspRC_t cmDspApplyDefault( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId )
  781. {
  782. cmDspRC_t rc;
  783. cmDspVar_t* varPtr;
  784. // get a pointer to the var recd
  785. if((rc = _cmDspVarPtr(inst,varId,&varPtr)) != kOkDspRC )
  786. return rc;
  787. if( cmIsFlag(varPtr->flags,kDfltSetDsvFl) )
  788. {
  789. // unless the var has kSendDfltDsvFl set we don't transmit the default values
  790. unsigned flags = cmIsFlag(varPtr->flags,kSendDfltDsvFl) ? 0 : kNoSendDspFl;
  791. return cmDspValueSet(ctx, inst, varId, &varPtr->dflt, flags );
  792. }
  793. return kOkDspRC;
  794. }
  795. cmDspRC_t cmDspApplyAllDefaults( cmDspCtx_t* ctx, cmDspInst_t* inst )
  796. {
  797. cmDspRC_t rc = kOkDspRC;
  798. unsigned i;
  799. for(i=0; i<inst->varCnt; ++i)
  800. if((rc = cmDspApplyDefault(ctx,inst,inst->varArray[i].constId)) != kOkDspRC )
  801. return rc;
  802. return rc;
  803. }
  804. cmDspRC_t cmDspSetDefault( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmDspValue_t* valPtr )
  805. {
  806. cmDspRC_t rc;
  807. cmDspVar_t* varPtr;
  808. // get a pointer to the var recd
  809. if((rc = _cmDspVarPtr(inst,varId,&varPtr)) != kOkDspRC )
  810. return rc;
  811. if(( cmDspValueSet( ctx, inst, varId, valPtr, kSetDefaultDspFl )) == kOkDspRC )
  812. {
  813. varPtr->flags = cmSetFlag(varPtr->flags, kDfltSetDsvFl);
  814. }
  815. return rc;
  816. }
  817. cmDspRC_t _cmDspDefaultSet( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmDspValue_t* valPtr, bool nonInitValIsEqualFl )
  818. {
  819. cmDspRC_t rc;
  820. cmDspVar_t* varPtr;
  821. // get a pointer to the var recd
  822. if((rc = _cmDspVarPtr(inst,varId,&varPtr)) != kOkDspRC )
  823. return rc;
  824. // if the dflt value was previuosly set and the default value is
  825. // not equal to the non-intialized value for this var then the default value
  826. // has already been set to a legal value
  827. if( cmIsFlag(varPtr->flags,kDfltSetDsvFl) && nonInitValIsEqualFl==false )
  828. return kOkDspRC;
  829. return cmDspSetDefault(ctx,inst,varId,valPtr);
  830. }
  831. cmDspRC_t cmDspSetDefaultBool( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, bool nonInitVal, bool val )
  832. {
  833. cmDspValue_t v;
  834. double dv = cmDspDefaultBool(inst,varId);
  835. cmDsvSetBool(&v,val);
  836. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==nonInitVal);
  837. }
  838. cmDspRC_t cmDspSetDefaultInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, int nonInitVal, int val )
  839. {
  840. cmDspValue_t v;
  841. int dv = cmDspDefaultInt(inst,varId);
  842. cmDsvSetInt(&v,val);
  843. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==nonInitVal);
  844. }
  845. cmDspRC_t cmDspSetDefaultUInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned nonInitVal, unsigned val )
  846. {
  847. cmDspValue_t v;
  848. unsigned dv = cmDspDefaultUInt(inst,varId);
  849. cmDsvSetUInt(&v,val);
  850. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==nonInitVal);
  851. }
  852. cmDspRC_t cmDspSetDefaultDouble( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, double nonInitVal, double val )
  853. {
  854. cmDspValue_t v;
  855. double dv = cmDspDefaultDouble(inst,varId);
  856. cmDsvSetDouble(&v,val);
  857. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==nonInitVal);
  858. }
  859. cmDspRC_t cmDspSetDefaultSample( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmSample_t nonInitVal, cmSample_t val )
  860. {
  861. cmDspValue_t v;
  862. cmSample_t dv = cmDspDefaultSample(inst,varId);
  863. cmDsvSetSample(&v,val);
  864. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==nonInitVal);
  865. }
  866. cmDspRC_t cmDspSetDefaultReal( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmReal_t nonInitVal, cmReal_t val )
  867. {
  868. cmDspValue_t v;
  869. cmReal_t dv = cmDspDefaultReal(inst,varId);
  870. cmDsvSetReal(&v,val);
  871. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==nonInitVal);
  872. }
  873. cmDspRC_t cmDspSetDefaultSymbol( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned val )
  874. {
  875. cmDspValue_t v;
  876. unsigned dv = cmDspDefaultSymbol(inst,varId);
  877. cmDsvSetSymbol(&v,val);
  878. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==cmInvalidId);
  879. }
  880. cmDspRC_t cmDspSetDefaultStrcz( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmChar_t* nonInitVal, const cmChar_t* val )
  881. {
  882. cmDspValue_t v;
  883. const cmChar_t* dv= cmDspDefaultStrcz(inst,varId);
  884. cmDsvSetStrcz(&v,val);
  885. bool fl = false; // assume the default and non-init value are not equal
  886. // if the pointers are the same then the strings must match
  887. if( dv == nonInitVal )
  888. fl = true;
  889. else
  890. // if both strings exist - then test if they are equal
  891. if( dv!=NULL && nonInitVal!=NULL)
  892. fl = strcmp(dv,nonInitVal)==0;
  893. return _cmDspDefaultSet(ctx,inst,varId,&v,fl);
  894. }
  895. cmDspRC_t cmDspSetDefaultJson( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmJsonNode_t* nonInitVal, cmJsonNode_t* val )
  896. {
  897. cmDspValue_t v;
  898. cmJsonNode_t* dv= cmDspDefaultJson(inst,varId);
  899. cmDsvSetJson(&v,val);
  900. return _cmDspDefaultSet(ctx,inst,varId,&v,dv==nonInitVal);
  901. }
  902. cmDspRC_t cmDspSetBool( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, bool val )
  903. {
  904. cmDspValue_t v;
  905. cmDsvSetBool(&v,val);
  906. return cmDspValueSet(ctx, inst, varId, &v, 0);
  907. }
  908. cmDspRC_t cmDspSetInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, int val )
  909. {
  910. cmDspValue_t v;
  911. cmDsvSetInt(&v,val);
  912. return cmDspValueSet(ctx, inst, varId, &v, 0);
  913. }
  914. cmDspRC_t cmDspSetUInt( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned val )
  915. {
  916. cmDspValue_t v;
  917. cmDsvSetUInt(&v,val);
  918. return cmDspValueSet(ctx, inst, varId, &v, 0);
  919. }
  920. cmDspRC_t cmDspSetDouble( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, double val )
  921. {
  922. cmDspValue_t v;
  923. cmDsvSetDouble(&v,val);
  924. return cmDspValueSet(ctx, inst, varId, &v, 0);
  925. }
  926. cmDspRC_t cmDspSetSample( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmSample_t val )
  927. {
  928. cmDspValue_t v;
  929. cmDsvSetSample(&v,val);
  930. return cmDspValueSet(ctx, inst, varId, &v, 0);
  931. }
  932. cmDspRC_t cmDspSetReal( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmReal_t val )
  933. {
  934. cmDspValue_t v;
  935. cmDsvSetReal(&v,val);
  936. return cmDspValueSet(ctx, inst, varId, &v, 0);
  937. }
  938. cmDspRC_t cmDspSetStrcz( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, const cmChar_t* val )
  939. {
  940. cmDspValue_t v;
  941. cmDsvSetStrcz(&v,val);
  942. return cmDspValueSet(ctx, inst, varId, &v, 0);
  943. }
  944. cmDspRC_t cmDspSetSymbol( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned val )
  945. {
  946. cmDspValue_t v;
  947. cmDsvSetSymbol(&v,val);
  948. return cmDspValueSet(ctx, inst, varId, &v, 0);
  949. }
  950. cmDspRC_t cmDspSetJson( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, cmJsonNode_t* val )
  951. {
  952. cmDspValue_t v;
  953. cmDsvSetJson(&v,val);
  954. return cmDspValueSet(ctx, inst, varId, &v, 0);
  955. }
  956. cmDspRC_t cmDspSetEvent( cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt )
  957. {
  958. unsigned flags = kUpdateUiDspFl;
  959. // We will assume that all values should be reflected to the UI - unless
  960. // this event is known to have been generated by the UI (evt->kUiDspFl is set)
  961. // and evt->kUiEchoDspFl is not set.
  962. if( cmIsFlag(evt->flags,kUiDspFl)==true && cmIsFlag(evt->flags,kUiEchoDspFl)==false )
  963. flags = kNoUpdateUiDspFl;
  964. // Note: If the event target variable is not a UI variable
  965. // (i.e. cmDspVar_t.kUiDsvFl is not set) then calling cmDspValueSet()
  966. // with the kUpdateUiDspFl set has no effect.
  967. return cmDspValueSet(ctx,inst,evt->dstVarId, evt->valuePtr, flags);
  968. }
  969. cmDspRC_t cmDspSetEventUi( cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt )
  970. { return cmDspValueSet(ctx,inst,evt->dstVarId, evt->valuePtr, kUpdateUiDspFl); }
  971. cmDspRC_t cmDspSetEventUiId( cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt, unsigned varId )
  972. {
  973. cmDspEvt_t e;
  974. cmDspEvtCopy(&e,evt);
  975. e.dstVarId = varId;
  976. evt = &e;
  977. return cmDspSetEventUi(ctx,inst,evt);
  978. }
  979. unsigned cmDspVarRows( cmDspInst_t* inst, unsigned varId )
  980. {
  981. cmDspValue_t* vp;
  982. if(_cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  983. return 0;
  984. return cmDsvRows(vp);
  985. }
  986. unsigned cmDspVarCols( cmDspInst_t* inst, unsigned varId )
  987. {
  988. cmDspValue_t* vp;
  989. if( _cmDspVarValuePtr(inst,varId,&vp) != kOkDspRC )
  990. return 0;
  991. return cmDsvCols(vp);
  992. }
  993. bool cmDspIsAudioInputConnected( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId )
  994. {
  995. cmDspValue_t* vp;
  996. if( _cmDspVarValuePtr(inst,varId,&vp ) != kOkDspRC )
  997. return false;
  998. if( cmAllFlags(vp->flags, kSampleDsvFl | kMtxDsvFl ))
  999. return true;
  1000. return false;
  1001. }
  1002. cmDspRC_t cmDspZeroAudioBuf( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId )
  1003. {
  1004. cmDspValue_t* valPtr;
  1005. cmDspVar_t* varPtr;
  1006. cmDspRC_t rc;
  1007. if((rc = _cmDspVarAndValuePtr(inst,varId,&varPtr,&valPtr)) != kOkDspRC )
  1008. return rc;
  1009. bool fl0 = cmAllFlags(valPtr->flags, kSampleDsvFl | kMtxDsvFl );
  1010. bool fl1 = cmIsFlag(varPtr->flags,kOutDsvFl);
  1011. if( fl0==false || fl1==false )
  1012. return cmDspInstErr(ctx,inst,kVarTypeErrDspRC,"The variable '%s' of DSP instance %s (id:%i) is not an output audio buffer.", cmDspVarLabel(ctx,inst,varId),inst->classPtr->labelStr,inst->id);
  1013. memset(cmDsvSampleMtx(valPtr), 0, cmDsvEleCount(valPtr)*sizeof(cmSample_t) );
  1014. return rc;
  1015. }
  1016. cmSample_t* cmDspAudioBuf( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned chIdx )
  1017. {
  1018. cmDspValue_t* vp;
  1019. cmDspVar_t* varPtr;
  1020. cmDspRC_t rc;
  1021. if((rc = _cmDspVarAndValuePtr(inst,varId,&varPtr,&vp )) != kOkDspRC )
  1022. return NULL;
  1023. if( !cmAllFlags(vp->flags, kSampleDsvFl | kMtxDsvFl ))
  1024. {
  1025. // this is an unconnected audio input
  1026. if( cmAllFlags(varPtr->flags,kInDsvFl | kAudioBufDsvFl ) )
  1027. return NULL;
  1028. cmDspInstErr(ctx,inst,kVarTypeErrDspRC,"The variable '%s' of DSP instance '%s' (id:%i) is not an audio buffer.", cmDspVarLabel(ctx,inst,varId),inst->classPtr->labelStr,inst->id);
  1029. return NULL;
  1030. }
  1031. if( chIdx >= cmDsvCols(vp) )
  1032. {
  1033. cmDspInstErr(ctx,inst,kVarTypeErrDspRC,"Channel index %i of audio buffer variable '%s' in DSP instance '%s' (id:%i) is outside the channel count (%i).",
  1034. chIdx,cmDspVarLabel(ctx,inst,varId),inst->classPtr->labelStr,inst->id,cmDsvCols(vp));
  1035. }
  1036. return cmDsvSampleMtx(vp) + (chIdx * cmDsvRows(vp));
  1037. }
  1038. unsigned cmDspAudioBufSmpCount( cmDspCtx_t* ctx, cmDspInst_t* inst, unsigned varId, unsigned chIdx )
  1039. {
  1040. cmDspValue_t* vp;
  1041. cmDspRC_t rc;
  1042. if((rc = _cmDspVarValuePtr(inst,varId,&vp)) != kOkDspRC )
  1043. return 0;
  1044. if( !cmAllFlags(vp->flags, kSampleDsvFl | kMtxDsvFl ))
  1045. {
  1046. cmDspInstErr(ctx,inst,kVarTypeErrDspRC,"The variable '%s' of DSP instance '%s' (id:%i) is not an audio buffer or is an unconnected input audio buffer.", cmDspVarLabel(ctx,inst,varId),inst->classPtr->labelStr,inst->id);
  1047. return 0;
  1048. }
  1049. return cmDsvRows(vp);
  1050. }
  1051. cmDspRC_t cmDspInstInstallCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, unsigned srcVarSymId, cmDspInst_t* dstInstPtr, unsigned dstVarSymId, void* dstDataPtr)
  1052. {
  1053. cmDspVar_t* srcVarPtr;
  1054. cmDspVar_t* dstVarPtr;
  1055. // get the src and dst var ptrs
  1056. if((srcVarPtr = cmDspVarSymbolToPtr(ctx,srcInstPtr,srcVarSymId,kOutDsvFl)) == NULL || (dstVarPtr = cmDspVarSymbolToPtr(ctx,dstInstPtr,dstVarSymId,kInDsvFl)) == NULL )
  1057. return cmDspInstErr(ctx,srcInstPtr,kInstCbInstallFailDspRC,"Callback installation failed for connection from '%s' (id:%i) var:'%s' to '%s' (id:%i) var:'%s'.",
  1058. srcInstPtr->classPtr->labelStr, srcInstPtr->id, cmSymTblLabel(ctx->stH,srcVarSymId), dstInstPtr->classPtr->labelStr, dstInstPtr->id, cmSymTblLabel(ctx->stH,dstVarSymId) );
  1059. // check for strict type conversion - this will fail for vars which allow multiple types
  1060. // (e.g. numbers and strings)
  1061. if( cmDsvCanConvertFlags(dstVarPtr->value.flags,srcVarPtr->value.flags) == false )
  1062. {
  1063. // if all the flags in the src are set in the dst then the match is ok
  1064. // (this will cover dst types which admit multiple types)
  1065. if( cmAllFlags(dstVarPtr->flags & kTypeDsvMask,srcVarPtr->flags & kTypeDsvMask) == false )
  1066. cmDspInstErr(ctx,srcInstPtr,kOkDspRC,"Data types may not be compatible for connection to '%s' id:%i var:'%s' from '%s'.",dstInstPtr->classPtr->labelStr, dstInstPtr->id, cmSymTblLabel(ctx->stH,dstVarSymId), cmSymTblLabel(ctx->stH,srcVarSymId));
  1067. }
  1068. if( cmIsFlag(srcVarPtr->flags, kAudioBufDsvFl) )
  1069. cmDspInstErr(ctx,srcInstPtr,kOkDspRC,"An audio source is being used as an event callback connection.");
  1070. if( cmIsFlag(dstVarPtr->flags, kAudioBufDsvFl ) )
  1071. cmDspInstErr(ctx,dstInstPtr,kOkDspRC,"An audio destination is the target of a callback connection.");
  1072. cmDspCb_t* r = cmLhAllocZ( ctx->lhH, cmDspCb_t, 1 );
  1073. r->srcVarSymId = srcVarSymId;
  1074. r->dstInstPtr = dstInstPtr;
  1075. r->dstVarId = dstVarPtr->constId;
  1076. r->dstDataPtr = dstDataPtr;
  1077. r->linkPtr = NULL;
  1078. cmDspCb_t* cp = srcVarPtr->cbList;
  1079. cmDspCb_t* pp = NULL;
  1080. for(; cp != NULL; cp = cp->linkPtr )
  1081. pp = cp;
  1082. if( pp == NULL )
  1083. srcVarPtr->cbList = r;
  1084. else
  1085. pp->linkPtr = r;
  1086. return kOkDspRC;
  1087. }
  1088. cmDspRC_t cmDspInstallCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, const cmChar_t* srcVarLabel, cmDspInst_t* dstInstPtr, const cmChar_t* dstVarLabel, void* dstCbDataPtr)
  1089. {
  1090. unsigned srcVarSymId,dstVarSymId;
  1091. if( srcInstPtr == NULL && dstInstPtr == NULL )
  1092. return cmErrMsg(&ctx->cmCtx->err,kInstNotFoundDspRC,"The callback installation was passed a NULL source and destination processor instance pointer.");
  1093. if( srcInstPtr == NULL )
  1094. return cmErrMsg(&ctx->cmCtx->err,kInstNotFoundDspRC,"The callback installation was passed a NULL source processor instance pointer for connection to '%s'.",cmStringNullGuard(dstInstPtr->classPtr->labelStr));
  1095. if( dstInstPtr == NULL )
  1096. return cmErrMsg(&ctx->cmCtx->err,kInstNotFoundDspRC,"The callback installation was passed a NULL destination processor instance pointer for connection from '%s'.",cmStringNullGuard(srcInstPtr->classPtr->labelStr));
  1097. if((srcVarSymId = cmSymTblId( ctx->stH, srcVarLabel )) == cmInvalidId )
  1098. return cmDspInstErr(ctx,srcInstPtr,kSrcVarNotFoundDspRC,"Connection failed. The source variable '%s' could not found in '%s' (id:%i) for registration by '%s' (id:%i).",
  1099. srcVarLabel,srcInstPtr->classPtr->labelStr,srcInstPtr->id,dstInstPtr->classPtr->labelStr,dstInstPtr->id);
  1100. if((dstVarSymId = cmSymTblId( ctx->stH, dstVarLabel )) == cmInvalidId )
  1101. return cmDspInstErr(ctx,dstInstPtr,kSrcVarNotFoundDspRC,"Connection failed. The destination variable '%s' for the DSP instance '%s' (id:%i).",
  1102. dstVarLabel,dstInstPtr->classPtr->labelStr,dstInstPtr->id);
  1103. return cmDspInstInstallCb(ctx, srcInstPtr, srcVarSymId, dstInstPtr, dstVarSymId, dstCbDataPtr);
  1104. }
  1105. cmDspRC_t cmDspInstRemoveCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, unsigned srcVarSymId, cmDspInst_t* dstInstPtr, unsigned dstVarId )
  1106. {
  1107. cmDspVar_t* varPtr;
  1108. if((varPtr = cmDspVarSymbolToPtr(ctx,srcInstPtr,srcVarSymId,kOutDsvFl)) == NULL )
  1109. return cmDspInstErr(ctx,srcInstPtr,kInstCbInstallFailDspRC,"Callback removal failed for instance '%s' (id:%i).",
  1110. srcInstPtr->classPtr->labelStr, srcInstPtr->id );
  1111. cmDspCb_t* cp = varPtr->cbList;
  1112. cmDspCb_t* pp = NULL;
  1113. for(; cp != NULL; cp = cp->linkPtr )
  1114. {
  1115. if( cp->srcVarSymId == srcVarSymId && cp->dstInstPtr == dstInstPtr && cp->dstVarId == dstVarId )
  1116. break;
  1117. pp = cp;
  1118. }
  1119. if( pp == NULL )
  1120. varPtr->cbList = cp->linkPtr;
  1121. else
  1122. pp->linkPtr = cp->linkPtr;
  1123. return kOkDspRC;
  1124. }
  1125. cmDspRC_t cmDspRemoveCb( cmDspCtx_t* ctx, cmDspInst_t* srcInstPtr, const cmChar_t* srcVarLabel, cmDspInst_t* dstInstPtr, unsigned dstVarId)
  1126. {
  1127. unsigned srcVarSymId;
  1128. if((srcVarSymId = cmSymTblId( ctx->stH, srcVarLabel )) == cmInvalidId )
  1129. return cmDspInstErr(ctx,srcInstPtr,kSrcVarNotFoundDspRC,"The variable '%s' could not found in '%s' (id:%i) do de-register for '%s' (id:%i).",
  1130. srcVarLabel,srcInstPtr->classPtr->labelStr,srcInstPtr->id,dstInstPtr->classPtr->labelStr,dstInstPtr->id);
  1131. return cmDspInstRemoveCb(ctx, srcInstPtr, srcVarSymId, dstInstPtr, dstVarId );
  1132. }
  1133. cmDspRC_t cmDspInstVarSetFlags( cmDspCtx_t* ctx, cmDspInst_t* instPtr, unsigned varId, unsigned flags )
  1134. {
  1135. cmDspVar_t* varPtr;
  1136. if(_cmDspVarPtr(instPtr, varId, &varPtr ) != kOkDspRC )
  1137. return cmDspInstErr(ctx,instPtr,kInstSetFlagsFailDspRC,"Set flags failed for DSP instance %s (id:%i).",instPtr->classPtr->labelStr,instPtr->id);
  1138. varPtr->flags = cmSetFlag(varPtr->flags,flags);
  1139. return kOkDspRC;
  1140. }