libcm is a C development framework with an emphasis on audio signal processing applications.
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.

cmDevCfg.c 35KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354
  1. #include "cmGlobal.h"
  2. #include "cmFloatTypes.h"
  3. #include "cmRpt.h"
  4. #include "cmErr.h"
  5. #include "cmCtx.h"
  6. #include "cmMem.h"
  7. #include "cmMallocDebug.h"
  8. #include "cmLinkedHeap.h"
  9. #include "cmFileSys.h"
  10. #include "cmJson.h"
  11. #include "cmText.h"
  12. #include "cmThread.h"
  13. #include "cmMidi.h"
  14. #include "cmMidiPort.h"
  15. #include "cmAudioPort.h"
  16. #include "cmUdpPort.h"
  17. #include "cmUdpNet.h"
  18. #include "cmAudioSysMsg.h"
  19. #include "cmAudioSys.h"
  20. #include "cmDevCfg.h"
  21. cmDevCfgH_t cmDevCfgNullHandle = cmSTATIC_NULL_HANDLE;
  22. typedef struct cmDcmCfg_str
  23. {
  24. cmChar_t* dcLabelStr; // the cfg label
  25. unsigned cfgId; // unique among all cfg's assigned to a loc
  26. cmTypeDcmId_t typeId; // the cfg type id (e.g. midi, audio, net, ...)
  27. cmChar_t* descStr; // summary description string
  28. // NOTE: any fields added to this structure, type generic (above)
  29. // or type specific (below), must be explicitely duplicated in cmDevCfgLocStore().
  30. union
  31. {
  32. cmDcmMidi_t m;
  33. cmDcmAudio_t a;
  34. cmDcmNet_t n;
  35. } u;
  36. struct cmDcmCfg_str* next;
  37. struct cmDcmCfg_str* prev;
  38. } cmDcmCfg_t;
  39. typedef struct
  40. {
  41. cmTypeDcmId_t tid; // Type Id for this map or tInvalidDcmTId if the record is not active.
  42. unsigned cfgId; // cfgId of the cfg recd assoc'd with this map
  43. cmDcmCfg_t* cfg; // pointer to the cfg recd assoc'd with this map (cfg->cfgId == cmDcmMap_t.cfgId)
  44. } cmDcmMap_t;
  45. typedef struct
  46. {
  47. bool activeFl;
  48. cmDcmMap_t* map;
  49. unsigned mapCnt;
  50. } cmDcmApp_t;
  51. typedef struct cmDcmLoc_str
  52. {
  53. cmChar_t* labelStr;
  54. cmDcmApp_t* app;
  55. unsigned appCnt;
  56. cmDcmCfg_t* cfg;
  57. struct cmDcmLoc_str* next;
  58. struct cmDcmLoc_str* prev;
  59. } cmDcmLoc_t;
  60. typedef struct
  61. {
  62. cmErr_t err;
  63. cmCtx_t* ctx;
  64. cmDcmLoc_t* loc;
  65. cmDcmLoc_t* clp;
  66. cmChar_t* fn;
  67. } cmDcm_t;
  68. cmDcm_t* _cmDcmHandleToPtr( cmDevCfgH_t h )
  69. {
  70. cmDcm_t* p = (cmDcm_t*)h.h;
  71. assert( p!=NULL );
  72. return p;
  73. }
  74. const cmChar_t* _cmDcmTrimLabel( cmDcm_t*p, const cmChar_t* s, const cmChar_t* title )
  75. {
  76. if( s == NULL )
  77. {
  78. cmErrMsg(&p->err,kBlankLabelDcRC,"A blank '%s' label was encountered.",title);
  79. return NULL;
  80. }
  81. while( *s && isspace(*s) )
  82. ++s;
  83. if( strlen(s) == 0 )
  84. {
  85. cmErrMsg(&p->err,kBlankLabelDcRC,"An empty '%s' label was encountered.",title);
  86. return NULL;
  87. }
  88. return s;
  89. }
  90. void _cmDcmFreeMidi( cmDcmMidi_t* r )
  91. {
  92. cmMemFree(r->devLabelStr);
  93. cmMemFree(r->portLabelStr);
  94. }
  95. void _cmDcmDuplMidi( cmDcmMidi_t* d, const cmDcmMidi_t* s )
  96. {
  97. d->devLabelStr = cmMemAllocStr(s->devLabelStr);
  98. d->portLabelStr = cmMemAllocStr(s->portLabelStr);
  99. d->inputFl = s->inputFl;
  100. d->devIdx = s->devIdx;
  101. d->portIdx = s->portIdx;
  102. }
  103. void _cmDcmFreeAudio( cmDcmAudio_t* r )
  104. {
  105. cmMemFree(r->inDevLabelStr);
  106. cmMemFree(r->outDevLabelStr);
  107. }
  108. void _cmDcmDuplAudio( cmDcmAudio_t* d, const cmDcmAudio_t* s )
  109. {
  110. d->inDevLabelStr = cmMemAllocStr(s->inDevLabelStr);
  111. d->outDevLabelStr = cmMemAllocStr(s->outDevLabelStr);
  112. d->audioSysArgs = s->audioSysArgs;
  113. }
  114. void _cmDcmFreeNet( cmDcmNet_t* r )
  115. {
  116. cmMemFree(r->sockAddr);
  117. }
  118. void _cmDcmDuplNet( cmDcmNet_t* d, const cmDcmNet_t* s )
  119. {
  120. d->sockAddr = cmMemAllocStr(s->sockAddr);
  121. d->portNumber = s->portNumber;
  122. }
  123. void _cmDcmFreeCfg( cmDcm_t* p, cmDcmLoc_t* lp, cmDcmCfg_t* cp )
  124. {
  125. // unlink the cfg recd
  126. if( cp->prev == NULL )
  127. lp->cfg = cp->next;
  128. else
  129. cp->prev->next = cp->next;
  130. if( cp->next != NULL )
  131. cp->next->prev = cp->prev;
  132. cmMemFree(cp->dcLabelStr);
  133. cmMemFree(cp->descStr);
  134. switch( cp->typeId )
  135. {
  136. case kMidiDcmTId: _cmDcmFreeMidi(&cp->u.m); break;
  137. case kAudioDcmTId: _cmDcmFreeAudio(&cp->u.a); break;
  138. case kNetDcmTId: _cmDcmFreeNet(&cp->u.n); break;
  139. default:
  140. assert(0);
  141. break;
  142. }
  143. cmMemFree(cp);
  144. }
  145. void _cmDcmFreeLoc( cmDcm_t* p, cmDcmLoc_t* lp )
  146. {
  147. unsigned i;
  148. // unlink the loc recd
  149. if( lp->prev == NULL )
  150. p->loc = lp->next;
  151. else
  152. lp->prev->next = lp->next;
  153. if( lp->next != NULL )
  154. lp->next->prev = lp->prev;
  155. // free each app
  156. for(i=0; i<lp->appCnt; ++i)
  157. cmMemFree(lp->app[i].map);
  158. cmMemFree(lp->app);
  159. cmMemFree(lp->labelStr);
  160. while( lp->cfg != NULL )
  161. _cmDcmFreeCfg(p,lp,lp->cfg);
  162. cmMemFree(lp);
  163. }
  164. void _cmDcmFreeAllLocs( cmDcm_t* p )
  165. {
  166. while( p->loc != NULL )
  167. _cmDcmFreeLoc(p,p->loc);
  168. p->clp = NULL;
  169. }
  170. cmDcRC_t _cmDcmFree( cmDcm_t* p )
  171. {
  172. cmDcRC_t rc = kOkDcRC;
  173. _cmDcmFreeAllLocs(p);
  174. cmMemFree(p->fn);
  175. cmMemFree(p);
  176. return rc;
  177. }
  178. cmDcmLoc_t* _cmDcmFindLoc( cmDcm_t* p, const cmChar_t* labelStr )
  179. {
  180. cmDcmLoc_t* lp = p->loc;
  181. for(; lp!=NULL; lp=lp->next)
  182. if(strcmp(lp->labelStr,labelStr)==0)
  183. return lp;
  184. return NULL;
  185. }
  186. cmDcRC_t _cmDcmNewLoc( cmDcm_t* p, const cmChar_t* labelStr, cmDcmLoc_t** locRef)
  187. {
  188. cmDcmLoc_t* lp;
  189. assert(locRef != NULL);
  190. *locRef = NULL;
  191. // verify and condition the label
  192. if((labelStr = _cmDcmTrimLabel(p,labelStr,"location")) == NULL )
  193. return cmErrLastRC(&p->err);
  194. // verify that the label is not already in use
  195. if((lp = _cmDcmFindLoc(p,labelStr)) != NULL )
  196. return cmErrMsg(&p->err,kDuplLabelDcRC,"The location label '%s' is already in use.",labelStr);
  197. // create a new loc recd
  198. lp = cmMemAllocZ(cmDcmLoc_t,1);
  199. lp->labelStr = cmMemAllocStr(labelStr);
  200. // if the cur loc is not current set - then prepend loc
  201. if( p->clp == NULL )
  202. {
  203. lp->prev = NULL;
  204. lp->next = p->loc;
  205. if( p->loc == NULL )
  206. p->loc = lp;
  207. else
  208. p->loc->prev = lp;
  209. }
  210. else // otherwise insert loc after the cur loc
  211. {
  212. lp->prev = p->clp;
  213. lp->next = p->clp->next;
  214. if( p->clp->next != NULL )
  215. p->clp->next->prev = lp;
  216. p->clp->next = lp;
  217. }
  218. // make the new loc the current loc
  219. p->clp = lp;
  220. *locRef = lp;
  221. return kOkDcRC;
  222. }
  223. cmDcRC_t _cmDevCfgRead( cmDcm_t* p, cmJsonH_t jsH, const cmJsonNode_t* rootObjPtr );
  224. cmDcRC_t _cmDevCfgReadFile( cmDcm_t* p, const cmChar_t* fn )
  225. {
  226. cmDcRC_t rc = kOkDcRC;
  227. cmJsonH_t jsH = cmJsonNullHandle;
  228. // initialize the JSON tree from the preferences file
  229. if( cmJsonInitializeFromFile( &jsH, fn, p->ctx ) != kOkJsRC )
  230. {
  231. rc = cmErrMsg(&p->err,kJsonFailDcRC,"JSON initialization from '%s' failed.",cmStringNullGuard(fn));
  232. goto errLabel;
  233. }
  234. if((rc = _cmDevCfgRead(p, jsH, cmJsonRoot(jsH))) != kOkJsRC )
  235. goto errLabel;
  236. errLabel:
  237. if( cmJsonFinalize(&jsH) != kOkJsRC )
  238. cmErrMsg(&p->err,kJsonFailDcRC,"JSON finalization failed following dev cfg read.");
  239. return rc;
  240. }
  241. cmDcRC_t cmDevCfgAlloc( cmCtx_t* c, cmDevCfgH_t* hp, const cmChar_t* fn )
  242. {
  243. cmDcRC_t rc;
  244. cmDcmLoc_t* lp;
  245. if((rc = cmDevCfgFree(hp)) != kOkDcRC )
  246. return rc;
  247. cmDcm_t* p = cmMemAllocZ(cmDcm_t,1);
  248. cmErrSetup(&p->err,&c->rpt,"cmDevCfg");
  249. p->ctx = c;
  250. if( fn != NULL )
  251. {
  252. p->fn = cmMemAllocStr(fn);
  253. if( cmFsIsFile(fn) )
  254. {
  255. // if the file read fails then reset and go with the default empty setup.
  256. if(_cmDevCfgReadFile(p,fn) != kOkDcRC )
  257. _cmDcmFreeAllLocs(p);
  258. }
  259. }
  260. // if the location array is empty then create a default location
  261. if( p->loc == NULL )
  262. {
  263. if((rc = _cmDcmNewLoc(p,"Default", &lp)) != kOkDcRC )
  264. goto errLabel;
  265. }
  266. hp->h = p;
  267. errLabel:
  268. if( rc != kOkDcRC )
  269. _cmDcmFree(p);
  270. return rc;
  271. }
  272. cmDcRC_t cmDevCfgFree( cmDevCfgH_t* hp )
  273. {
  274. cmDcRC_t rc = kOkDcRC;
  275. if( hp == NULL || cmDevCfgIsValid(*hp)==false )
  276. return rc;
  277. cmDcm_t* p = _cmDcmHandleToPtr(*hp);
  278. if((rc = _cmDcmFree(p)) != kOkDcRC )
  279. return rc;
  280. hp->h = NULL;
  281. return rc;
  282. }
  283. bool cmDevCfgIsValid( cmDevCfgH_t h )
  284. { return h.h != NULL; }
  285. unsigned cmDevCfgCount( cmDevCfgH_t h, cmTypeDcmId_t typeId )
  286. {
  287. unsigned n=0;
  288. cmDcm_t* p = _cmDcmHandleToPtr(h);
  289. assert( p->clp != NULL);
  290. const cmDcmCfg_t* cp = p->clp->cfg;
  291. for(; cp!= NULL; cp=cp->next)
  292. if( cp->typeId == typeId )
  293. ++n;
  294. return n;
  295. }
  296. cmDcmCfg_t* _cmDevCfgIndexToPtr( cmDcm_t* p, cmTypeDcmId_t typeId, unsigned index, bool errFl )
  297. {
  298. unsigned n=0;
  299. assert( p->clp != NULL);
  300. cmDcmCfg_t* cp = p->clp->cfg;
  301. for(; cp!= NULL; cp=cp->next)
  302. if( cp->typeId == typeId )
  303. {
  304. if( n == index )
  305. return cp;
  306. ++n;
  307. }
  308. if( errFl )
  309. cmErrMsg(&p->err,kInvalidCfgIdxDcRC,"The cfg index %i is not valid in location '%s'.",cmStringNullGuard(p->clp->labelStr));
  310. return NULL;
  311. }
  312. const cmChar_t* cmDevCfgLabel( cmDevCfgH_t h, cmTypeDcmId_t typeId, unsigned index )
  313. {
  314. cmDcm_t* p = _cmDcmHandleToPtr(h);
  315. cmDcmCfg_t* cp;
  316. if((cp = _cmDevCfgIndexToPtr(p,typeId,index,false)) == NULL )
  317. return NULL;
  318. return cp->dcLabelStr;
  319. }
  320. const cmChar_t* cmDevCfgDesc( cmDevCfgH_t h, cmTypeDcmId_t typeId, unsigned index )
  321. {
  322. cmDcm_t* p = _cmDcmHandleToPtr(h);
  323. cmDcmCfg_t* cp;
  324. if((cp = _cmDevCfgIndexToPtr(p,typeId,index,false)) == NULL )
  325. return NULL;
  326. return cp->descStr;
  327. }
  328. cmDcmCfg_t* _cmDcmCfgLabelToPtr( cmDcm_t* p, cmTypeDcmId_t typeId, const cmChar_t* label, bool errFl )
  329. {
  330. assert( p->clp != NULL);
  331. cmDcmCfg_t* cp = p->clp->cfg;
  332. for(; cp!= NULL; cp=cp->next)
  333. if( cp->typeId == typeId )
  334. {
  335. if( strcmp(cp->dcLabelStr,label)==0 )
  336. return cp;
  337. }
  338. if( errFl )
  339. cmErrMsg(&p->err,kLabelNotFoundDcRC, "The cfg label '%s' was not found.",cmStringNullGuard(label));
  340. return NULL;
  341. }
  342. unsigned cmDevCfgLabelToIndex( cmDevCfgH_t h, cmTypeDcmId_t typeId, const cmChar_t* label )
  343. {
  344. unsigned n = 0;
  345. cmDcm_t* p = _cmDcmHandleToPtr(h);
  346. assert( p->clp != NULL);
  347. const cmDcmCfg_t* cp = p->clp->cfg;
  348. for(; cp!= NULL; cp=cp->next)
  349. if( cp->typeId == typeId )
  350. {
  351. if( strcmp(cp->dcLabelStr,label)==0 )
  352. break;
  353. ++n;
  354. }
  355. return n;
  356. }
  357. cmDcmCfg_t* _cmDcmFindOrCreateCfg( cmDcm_t* p, cmTypeDcmId_t typeId, const cmChar_t* dcLabelStr )
  358. {
  359. assert( p->clp != NULL );
  360. cmDcmCfg_t* cp;
  361. // validate the label
  362. if( (dcLabelStr=_cmDcmTrimLabel(p,dcLabelStr,"cfg")) == NULL )
  363. return NULL;
  364. // if the cfg recd already exists then return it
  365. if((cp = _cmDcmCfgLabelToPtr(p, typeId, dcLabelStr, false )) != NULL )
  366. return cp;
  367. unsigned newCfgId = 0;
  368. // use ep to track the end of the list
  369. cmDcmCfg_t* ep = NULL;
  370. // find the max cfgId used by this loc
  371. cp = p->clp->cfg;
  372. for(; cp!=NULL; cp=cp->next)
  373. {
  374. if( cp->cfgId > newCfgId )
  375. newCfgId = cp->cfgId;
  376. ep = cp;
  377. }
  378. // add one to the max cfgId to create a unique cfgId
  379. newCfgId += 1;
  380. // allocate a new cfg recd
  381. cp = cmMemAllocZ(cmDcmCfg_t,1);
  382. cp->dcLabelStr = cmMemAllocStr(dcLabelStr);
  383. cp->cfgId = newCfgId;
  384. cp->typeId = typeId;
  385. // link to the end of the loc's cfg list
  386. if( ep == NULL )
  387. p->clp->cfg = cp;
  388. else
  389. {
  390. ep->next = cp;
  391. cp->prev = ep;
  392. }
  393. return cp;
  394. }
  395. void _cmDcmDisconnectMap( cmDcmMap_t* mp )
  396. {
  397. mp->tid = kInvalidDcmTId;
  398. mp->cfgId = cmInvalidId;
  399. mp->cfg = NULL;
  400. }
  401. cmDcRC_t cmDevCfgDeleteCfg( cmDevCfgH_t h, cmTypeDcmId_t typeId, const cmChar_t* dcLabelStr )
  402. {
  403. cmDcmCfg_t* cp;
  404. cmDcm_t* p = _cmDcmHandleToPtr(h);
  405. unsigned i,j;
  406. // locate the cfg to delete
  407. if((cp = _cmDcmCfgLabelToPtr(p,typeId,dcLabelStr,true)) == NULL )
  408. return cmErrLastRC(&p->err);
  409. // for every app in the current location ...
  410. for(i=0; i<p->clp->appCnt; ++i)
  411. {
  412. cmDcmApp_t* ap = p->clp->app + i;
  413. // ... disconnect any maps to this cfg
  414. if( ap->activeFl && ap->map != NULL )
  415. for(j=0; j<ap->mapCnt; ++j)
  416. if( ap->map[j].cfgId == cp->cfgId )
  417. _cmDcmDisconnectMap(ap->map + j );
  418. }
  419. // unlink and release the cfg recd
  420. _cmDcmFreeCfg(p,p->clp,cp);
  421. return kOkDcRC;
  422. }
  423. cmDcRC_t cmDevCfgCreateMap( cmDevCfgH_t h, cmTypeDcmId_t typeId, const cmChar_t* dcLabelStr, unsigned usrAppId, unsigned usrMapId )
  424. {
  425. cmDcRC_t rc = kOkDcRC;
  426. cmDcm_t* p = _cmDcmHandleToPtr(h);
  427. cmDcmCfg_t* cp;
  428. // locate the cfg to map to
  429. if((cp = _cmDcmCfgLabelToPtr(p,typeId,dcLabelStr,true)) == NULL )
  430. return cmErrLastRC(&p->err);
  431. // if usrAppId references a new app
  432. if( usrAppId >= p->clp->appCnt )
  433. {
  434. p->clp->appCnt = usrAppId + 1;
  435. p->clp->app = cmMemResizePZ(cmDcmApp_t,p->clp->app,p->clp->appCnt);
  436. }
  437. cmDcmApp_t* ap = p->clp->app + usrAppId;
  438. // if usrMapId ref's a new map
  439. if( usrMapId >= ap->mapCnt )
  440. {
  441. ap->mapCnt = usrMapId+1;
  442. ap->map = cmMemResizePZ(cmDcmMap_t,ap->map,ap->mapCnt);
  443. }
  444. cmDcmMap_t* mp = ap->map + usrMapId;
  445. mp->tid = typeId;
  446. mp->cfgId = cp->cfgId;
  447. mp->cfg = cp;
  448. return rc;
  449. }
  450. cmDcmMap_t* _cmDcmFindMap( cmDcm_t* p, cmTypeDcmId_t typeId, unsigned usrAppId, unsigned usrMapId, bool activeFl )
  451. {
  452. if( usrAppId >= p->clp->appCnt )
  453. {
  454. cmErrMsg(&p->err,kInvalidUserAppIdRC,"The user app. id %i is out of range %i in location '%s'.",usrAppId,p->clp->appCnt,cmStringNullGuard(p->clp->labelStr));
  455. goto errLabel;
  456. }
  457. cmDcmApp_t* ap = p->clp->app + usrAppId;
  458. if( usrMapId >= ap->mapCnt )
  459. {
  460. cmErrMsg(&p->err,kInvalidUserMapIdRC,"The user map id %i is out of range %i in location '%s'.",usrMapId,ap->mapCnt,cmStringNullGuard(p->clp->labelStr));
  461. goto errLabel;
  462. }
  463. if( activeFl && (ap->map[usrMapId].tid == kInvalidDcmTId || ap->map[usrMapId].cfg == NULL))
  464. {
  465. cmErrMsg(&p->err,kInvalidUserMapIdRC,"The user map id %i inactive in location '%s'.",usrMapId,cmStringNullGuard(p->clp->labelStr));
  466. goto errLabel;
  467. }
  468. return ap->map + usrMapId;
  469. errLabel:
  470. return NULL;
  471. }
  472. cmDcRC_t cmDevCfgDeleteMap( cmDevCfgH_t h, cmTypeDcmId_t typeId, unsigned usrAppId, unsigned usrMapId )
  473. {
  474. cmDcm_t* p = _cmDcmHandleToPtr(h);
  475. cmDcmMap_t* mp;
  476. if((mp = _cmDcmFindMap(p,typeId,usrAppId,usrMapId,false)) == NULL )
  477. return cmErrLastRC(&p->err);
  478. _cmDcmDisconnectMap( mp );
  479. return kOkDcRC;
  480. }
  481. cmDcRC_t cmDevCfgNameMidiPort(
  482. cmDevCfgH_t h,
  483. const cmChar_t* dcLabelStr,
  484. const cmChar_t* devLabelStr,
  485. const cmChar_t* portLabelStr,
  486. bool inputFl )
  487. {
  488. cmDcm_t* p = _cmDcmHandleToPtr(h);
  489. cmDcmCfg_t* cp;
  490. unsigned midiDevIdx;
  491. unsigned midiPortIdx;
  492. // validate the label
  493. if((dcLabelStr = _cmDcmTrimLabel(p,dcLabelStr,"MIDI cfg")) == NULL)
  494. return cmErrLastRC(&p->err);
  495. // verify that the device label is valid
  496. if((midiDevIdx = cmMpDeviceNameToIndex( devLabelStr )) == cmInvalidIdx )
  497. return cmErrMsg(&p->err, kInvalidArgDcRC,"The MIDI device name '%s' is not valid.",devLabelStr);
  498. // verify that the port label is valid
  499. if((midiPortIdx = cmMpDevicePortNameToIndex( midiDevIdx, inputFl ? kInMpFl : kOutMpFl, portLabelStr )) == cmInvalidIdx )
  500. return cmErrMsg(&p->err, kInvalidArgDcRC,"The MIDI port name '%s' is not valid on the device '%s'.",portLabelStr,devLabelStr);
  501. // if dcLabelStr is already in use for this location and type then update
  502. // the assoc'd recd otherwise create a new one.
  503. if((cp = _cmDcmFindOrCreateCfg(p,kMidiDcmTId, dcLabelStr)) == NULL )
  504. return cmErrLastRC(&p->err);
  505. cp->u.m.devLabelStr = cmMemResizeStr(cp->u.m.devLabelStr,devLabelStr);
  506. cp->u.m.portLabelStr = cmMemResizeStr(cp->u.m.portLabelStr,portLabelStr);
  507. cp->u.m.inputFl = inputFl;
  508. cp->u.m.devIdx = midiDevIdx;
  509. cp->u.m.portIdx = midiPortIdx;
  510. cp->descStr = cmTsPrintfP(cp->descStr,"%s %s %s",inputFl?"Input":"Output",devLabelStr,portLabelStr);
  511. return kOkDcRC;
  512. }
  513. const cmDcmMidi_t* cmDevCfgMidiCfg( cmDevCfgH_t h, unsigned cfgIdx )
  514. {
  515. cmDcm_t* p = _cmDcmHandleToPtr(h);
  516. cmDcmCfg_t* cp;
  517. if((cp = _cmDevCfgIndexToPtr(p, kMidiDcmTId, cfgIdx, true )) == NULL )
  518. return NULL;
  519. return &cp->u.m;
  520. }
  521. const cmDcmMidi_t* cmDevCfgMidiDevMap( cmDevCfgH_t h, unsigned usrAppId, unsigned usrMapId )
  522. {
  523. cmDcm_t* p = _cmDcmHandleToPtr(h);
  524. cmDcmMap_t* mp;
  525. if((mp =_cmDcmFindMap(p,kMidiDcmTId, usrAppId, usrMapId, true )) == NULL )
  526. return NULL;
  527. return &mp->cfg->u.m;
  528. }
  529. cmDcRC_t cmDevCfgNameAudioPort(
  530. cmDevCfgH_t h,
  531. const cmChar_t* dcLabelStr,
  532. const cmChar_t* inDevNameStr,
  533. const cmChar_t* outDevNameStr,
  534. bool syncInputFl,
  535. unsigned msgQueueByteCnt,
  536. unsigned devFramesPerCycle,
  537. unsigned dspFramesPerCycle,
  538. unsigned audioBufCnt,
  539. double srate )
  540. {
  541. cmDcm_t* p = _cmDcmHandleToPtr(h);
  542. cmDcmCfg_t* cp;
  543. unsigned inDevIdx;
  544. unsigned outDevIdx;
  545. // validate the label
  546. if((dcLabelStr = _cmDcmTrimLabel(p,dcLabelStr,"Audio cfg")) == NULL)
  547. return cmErrLastRC(&p->err);
  548. // validate the input device
  549. if(( inDevIdx = cmApDeviceLabelToIndex(inDevNameStr)) == cmInvalidIdx )
  550. return cmErrMsg(&p->err, kInvalidArgDcRC,"The input audio device name '%s' is not valid.",cmStringNullGuard(inDevNameStr));
  551. // validate the output device
  552. if(( outDevIdx = cmApDeviceLabelToIndex(outDevNameStr)) == cmInvalidIdx )
  553. return cmErrMsg(&p->err, kInvalidArgDcRC,"The output audio device name '%s' is not valid.",cmStringNullGuard(outDevNameStr));
  554. // validate the msg byte cnt
  555. if( msgQueueByteCnt == 0 )
  556. return cmErrMsg(&p->err, kInvalidArgDcRC,"The 'message queue size' must be greater than zero.");
  557. // validate the dev. frames per cycle
  558. if( devFramesPerCycle == 0 )
  559. return cmErrMsg(&p->err, kInvalidArgDcRC,"The 'device frames per cycle' must be greater than zero.");
  560. // validate the dsp frames per cycle
  561. if( dspFramesPerCycle == 0 || ((devFramesPerCycle/dspFramesPerCycle) * dspFramesPerCycle != devFramesPerCycle) )
  562. return cmErrMsg(&p->err, kInvalidArgDcRC,"The 'DSP frames per cycle' must be greater than zero and an integer factor of 'Device frames per cycle.'.");
  563. // validate the sample rate
  564. if( srate == 0 )
  565. return cmErrMsg(&p->err, kInvalidArgDcRC,"The audio sample rate must be greater than zero.");
  566. // if dcLabelStr is already in use for this location and type then update
  567. // the assoc'd recd otherwise create a new one.
  568. if((cp = _cmDcmFindOrCreateCfg(p,kAudioDcmTId, dcLabelStr)) == NULL )
  569. return cmErrLastRC(&p->err);
  570. unsigned inChCnt = cmApDeviceChannelCount( inDevIdx, true );
  571. unsigned outChCnt = cmApDeviceChannelCount( outDevIdx, false );
  572. cp->u.a.inDevLabelStr = cmMemAllocStr(inDevNameStr);
  573. cp->u.a.outDevLabelStr = cmMemAllocStr(outDevNameStr);
  574. cp->u.a.audioSysArgs.rpt = p->err.rpt;
  575. cp->u.a.audioSysArgs.inDevIdx = inDevIdx;
  576. cp->u.a.audioSysArgs.outDevIdx = outDevIdx;
  577. cp->u.a.audioSysArgs.syncInputFl = syncInputFl;
  578. cp->u.a.audioSysArgs.msgQueueByteCnt = msgQueueByteCnt;
  579. cp->u.a.audioSysArgs.devFramesPerCycle = devFramesPerCycle;
  580. cp->u.a.audioSysArgs.dspFramesPerCycle = dspFramesPerCycle;
  581. cp->u.a.audioSysArgs.audioBufCnt = audioBufCnt;
  582. cp->u.a.audioSysArgs.srate = srate;
  583. cp->descStr = cmTsPrintfP(cp->descStr,"In: Chs:%i %s\nOut: Chs:%i %s",inChCnt,inDevNameStr,outChCnt,outDevNameStr);
  584. return kOkDcRC;
  585. }
  586. cmDcRC_t cmDevCfgAudioSetDefaultCfgIndex( cmDevCfgH_t h, unsigned cfgIdx )
  587. {
  588. cmDcm_t* p = _cmDcmHandleToPtr(h);
  589. assert( p->clp != NULL );
  590. cmDcmCfg_t* cp = p->clp->cfg;
  591. unsigned i;
  592. for(i=0; cp!=NULL; cp=cp->next)
  593. if( cp->typeId == kAudioDcmTId )
  594. {
  595. if( i == cfgIdx )
  596. cp->u.a.dfltFl = true;
  597. else
  598. {
  599. if( cp->u.a.dfltFl )
  600. cp->u.a.dfltFl = false;
  601. }
  602. ++i;
  603. }
  604. return kOkDcRC;
  605. }
  606. unsigned cmDevCfgAudioGetDefaultCfgIndex( cmDevCfgH_t h )
  607. {
  608. cmDcm_t* p = _cmDcmHandleToPtr(h);
  609. assert( p->clp != NULL );
  610. cmDcmCfg_t* cp = p->clp->cfg;
  611. unsigned i;
  612. for(i=0; cp!=NULL; cp=cp->next)
  613. if( cp->typeId == kAudioDcmTId )
  614. {
  615. if( cp->u.a.dfltFl )
  616. return i;
  617. ++i;
  618. }
  619. return cmInvalidIdx;
  620. }
  621. const cmDcmAudio_t* cmDevCfgAudioCfg( cmDevCfgH_t h, unsigned cfgIdx )
  622. {
  623. cmDcm_t* p = _cmDcmHandleToPtr(h);
  624. cmDcmCfg_t* cp;
  625. if((cp = _cmDevCfgIndexToPtr(p, kAudioDcmTId, cfgIdx, true )) == NULL )
  626. return NULL;
  627. return &cp->u.a;
  628. }
  629. const cmDcmAudio_t* cmDevCfgAudioDevMap( cmDevCfgH_t h, unsigned usrAppId, unsigned usrMapId )
  630. {
  631. cmDcm_t* p = _cmDcmHandleToPtr(h);
  632. cmDcmMap_t* mp;
  633. if((mp =_cmDcmFindMap(p,kAudioDcmTId, usrAppId, usrMapId, true )) == NULL )
  634. return NULL;
  635. return &mp->cfg->u.a;
  636. }
  637. cmDcRC_t cmDevCfgNameNetPort(
  638. cmDevCfgH_t h,
  639. const cmChar_t* dcLabelStr,
  640. const cmChar_t* sockAddr,
  641. unsigned portNumber )
  642. {
  643. cmDcm_t* p = _cmDcmHandleToPtr(h);
  644. cmDcmCfg_t* cp;
  645. if( portNumber > 0xffff )
  646. return cmErrMsg(&p->err,kInvalidArgDcRC,"The network port number %i is invalid. The valid IP port number range is:0-0xffff.");
  647. // validate the label
  648. if((dcLabelStr = _cmDcmTrimLabel(p,dcLabelStr,"MIDI cfg")) == NULL)
  649. return cmErrLastRC(&p->err);
  650. // if dcLabelStr is already in use for this location and type then update
  651. // the assoc'd recd otherwise create a new one.
  652. if((cp = _cmDcmFindOrCreateCfg(p,kNetDcmTId, dcLabelStr)) == NULL )
  653. return cmErrLastRC(&p->err);
  654. cp->u.n.sockAddr = cmMemAllocStr(sockAddr);
  655. cp->u.n.portNumber = portNumber;
  656. cp->descStr = cmTsPrintfP(cp->descStr,"%s:%i",sockAddr,portNumber);
  657. return kOkDcRC;
  658. }
  659. const cmDcmNet_t* cmDevCfgNetCfg( cmDevCfgH_t h, unsigned cfgIdx )
  660. {
  661. cmDcm_t* p = _cmDcmHandleToPtr(h);
  662. cmDcmCfg_t* cp;
  663. if((cp = _cmDevCfgIndexToPtr(p, kNetDcmTId, cfgIdx, true )) == NULL )
  664. return NULL;
  665. return &cp->u.n;
  666. }
  667. const cmDcmNet_t* cmDevCfgNetDevMap( cmDevCfgH_t h, unsigned usrAppId, unsigned usrMapId )
  668. {
  669. cmDcm_t* p = _cmDcmHandleToPtr(h);
  670. cmDcmMap_t* mp;
  671. if((mp =_cmDcmFindMap(p,kNetDcmTId, usrAppId, usrMapId, true )) == NULL )
  672. return NULL;
  673. return &mp->cfg->u.n;
  674. }
  675. unsigned cmDevCfgLocCount( cmDevCfgH_t h )
  676. {
  677. unsigned n = 0;
  678. cmDcm_t* p = _cmDcmHandleToPtr(h);
  679. const cmDcmLoc_t* lp = p->loc;
  680. for(; lp!=NULL; lp=lp->next)
  681. ++n;
  682. return n;
  683. }
  684. const cmChar_t* cmDevCfgLocLabel( cmDevCfgH_t h, unsigned locIdx )
  685. {
  686. cmDcm_t* p = _cmDcmHandleToPtr(h);
  687. const cmDcmLoc_t* lp = p->loc;
  688. unsigned i;
  689. for(i=0; lp!=NULL; lp=lp->next,++i)
  690. if( i == locIdx )
  691. return lp->labelStr;
  692. assert(0);
  693. return NULL;
  694. }
  695. cmDcmLoc_t* _cmDcmLocLabelToPtr( cmDcm_t* p, const cmChar_t* locLabelStr, bool errFl)
  696. {
  697. if((locLabelStr = _cmDcmTrimLabel(p,locLabelStr,"location")) == NULL )
  698. return NULL;
  699. cmDcmLoc_t* lp = p->loc;
  700. for(; lp!=NULL; lp=lp->next)
  701. if( strcmp(lp->labelStr,locLabelStr) == 0 )
  702. return lp;
  703. if( errFl )
  704. cmErrMsg(&p->err,kLabelNotFoundDcRC,"The location label '%s' was not found.",locLabelStr);
  705. return NULL;
  706. }
  707. cmDcRC_t cmDevCfgLocStore( cmDevCfgH_t h, const cmChar_t* locLabelStr )
  708. {
  709. cmDcRC_t rc = kOkDcRC;
  710. cmDcm_t* p = _cmDcmHandleToPtr(h);
  711. unsigned i,j;
  712. // if this location label is already in use then it has already been stored.
  713. if( _cmDcmLocLabelToPtr(p,locLabelStr,false) != NULL )
  714. return kOkDcRC;
  715. // store the current loc ptr
  716. cmDcmLoc_t* olp = p->clp;
  717. cmDcmLoc_t* nlp;
  718. // create a new location recd and make it current
  719. if((rc = _cmDcmNewLoc(p,locLabelStr,&nlp)) != kOkDcRC )
  720. return kOkDcRC;
  721. // duplicate the cfg's
  722. cmDcmCfg_t* ocp = olp->cfg;
  723. for(; ocp!=NULL; ocp=ocp->next)
  724. {
  725. cmDcmCfg_t* ncp;
  726. // this will always create (never find) a new cfg recd
  727. if((ncp = _cmDcmFindOrCreateCfg(p,ocp->typeId, ocp->dcLabelStr)) == NULL )
  728. {
  729. rc = cmErrLastRC(&p->err);
  730. goto errLabel;
  731. }
  732. // duplicate the desc. string
  733. ncp->descStr = cmMemAllocStr(ocp->descStr);
  734. switch( ncp->typeId )
  735. {
  736. case kMidiDcmTId: _cmDcmDuplMidi(&ncp->u.m,&ocp->u.m); break;
  737. case kAudioDcmTId: _cmDcmDuplAudio(&ncp->u.a,&ocp->u.a); break;
  738. case kNetDcmTId: _cmDcmDuplNet( &ncp->u.n,&ocp->u.n); break;
  739. default:
  740. assert(0);
  741. break;
  742. }
  743. }
  744. // duplicate the app array
  745. nlp->appCnt = olp->appCnt;
  746. nlp->app = cmMemAllocZ(cmDcmApp_t,nlp->appCnt);
  747. for(i=0; i<nlp->appCnt; ++i)
  748. {
  749. cmDcmApp_t* nap = nlp->app + i;
  750. cmDcmApp_t* oap = olp->app + i;
  751. //nap->usrAppId = oap->usrAppId;
  752. nap->activeFl = oap->activeFl;
  753. nap->mapCnt = oap->mapCnt;
  754. nap->map = cmMemAllocZ(cmDcmMap_t,nap->mapCnt);
  755. for(j=0; j<nap->mapCnt; ++j)
  756. {
  757. cmDcmMap_t* nmp = nap->map + j;
  758. cmDcmMap_t* omp = oap->map + j;
  759. nmp->tid = omp->tid;
  760. nmp->cfgId = omp->cfgId;
  761. if( omp->tid != kInvalidDcmTId && omp->cfg->dcLabelStr != NULL )
  762. nmp->cfg = _cmDcmCfgLabelToPtr(p,nmp->tid,omp->cfg->dcLabelStr,true);
  763. }
  764. }
  765. errLabel:
  766. if( rc != kOkDcRC )
  767. _cmDcmFreeLoc(p,nlp);
  768. return rc;
  769. }
  770. cmDcRC_t cmDevCfgLocRecall( cmDevCfgH_t h, const cmChar_t* locLabelStr )
  771. {
  772. cmDcm_t* p = _cmDcmHandleToPtr(h);
  773. cmDcmLoc_t* lp;
  774. if((lp = _cmDcmLocLabelToPtr(p,locLabelStr,true)) == NULL)
  775. return cmErrLastRC(&p->err);
  776. p->clp = lp;
  777. return kOkDcRC;
  778. }
  779. cmDcRC_t cmDevCfgLocDelete( cmDevCfgH_t h, const cmChar_t* locLabelStr )
  780. {
  781. cmDcm_t* p = _cmDcmHandleToPtr(h);
  782. cmDcmLoc_t* lp;
  783. if((lp = _cmDcmLocLabelToPtr(p,locLabelStr,true)) == NULL )
  784. return cmErrLastRC(&p->err);
  785. _cmDcmFreeLoc(p,lp);
  786. return kOkDcRC;
  787. }
  788. unsigned cmDevCfgLocCurIndex( cmDevCfgH_t h )
  789. {
  790. unsigned i;
  791. cmDcm_t* p = _cmDcmHandleToPtr(h);
  792. cmDcmLoc_t* lp = p->loc;
  793. for(i=0; lp!=NULL; lp=lp->next,++i)
  794. if( lp == p->clp )
  795. return i;
  796. assert(0);
  797. return cmInvalidIdx;
  798. }
  799. cmDcRC_t _cmDcmJsonNotFound( cmDcm_t* p, const cmChar_t* tagStr )
  800. { return cmErrMsg(&p->err,kJsonFailDcRC,"JSON element '%s' not found.",tagStr); }
  801. cmDcRC_t _cmDcmJsonSyntaxErr( cmDcm_t* p, const cmChar_t* tagStr )
  802. { return cmErrMsg(&p->err,kJsonFailDcRC,"JSON syntax error '%s' not found.",tagStr); }
  803. cmDcRC_t _cmDevCfgRead( cmDcm_t* p, cmJsonH_t jsH, const cmJsonNode_t* rootObjPtr )
  804. {
  805. cmDcRC_t rc = kOkDcRC;
  806. const cmChar_t* errLabelPtr = NULL;
  807. cmJsonNode_t* cfgNp, *locArrNp;
  808. unsigned i,j;
  809. cmDevCfgH_t h;
  810. h.h = p;
  811. // clear the all locations
  812. _cmDcmFreeAllLocs(p);
  813. if((cfgNp = cmJsonFindValue(jsH, "cfg", rootObjPtr, kObjectTId )) == NULL )
  814. return _cmDcmJsonNotFound(p,"cfg");
  815. // get loc array
  816. if((locArrNp = cmJsonFindValue(jsH,"loc",cfgNp, kArrayTId )) == NULL )
  817. return _cmDcmJsonNotFound(p,"loc");
  818. // for each loc object
  819. for(i=0; i<cmJsonChildCount(locArrNp); ++i)
  820. {
  821. cmJsonNode_t* locObjNp, *cfgArrNp;
  822. const cmChar_t* locLabelStr = NULL;
  823. // get the loc object
  824. if((locObjNp = cmJsonArrayElement(locArrNp,i)) == NULL || cmJsonIsObject(locObjNp)==false )
  825. return _cmDcmJsonSyntaxErr(p,"loc object");
  826. // read the loc object fields
  827. if( cmJsonMemberValues(locObjNp, &errLabelPtr,
  828. "label", kStringTId, &locLabelStr,
  829. "cfg", kArrayTId, &cfgArrNp,
  830. NULL ) != kOkJsRC )
  831. { return _cmDcmJsonNotFound(p,errLabelPtr); }
  832. // create a new location recd
  833. cmDcmLoc_t* locPtr = NULL;
  834. if((rc = _cmDcmNewLoc(p,locLabelStr,&locPtr)) != kOkDcRC )
  835. return cmErrMsg(&p->err,kJsonFailDcRC,"Location '%s' create failed.",cmStringNullGuard(locLabelStr));
  836. /*
  837. // read each app object
  838. for(j=0; j<cmJsonChildCount(appArrNp); ++j)
  839. {
  840. cmJsonNode_t* appObjNp;
  841. // get the app object
  842. if((appObjNp = cmJsonArrayElement(appArrNp,j)) == NULL || cmJsonIsObject(appObjNp)==false )
  843. return _cmDcmJsonSyntaxErr(p,"loc object");
  844. // locate the map array
  845. cmJsonNode_t* mapArrNp;
  846. if((mapArrNp = cmJsonFindValue(jsH,"map",appObjNp,kArrayTId)) == NULL )
  847. return _cmDcmJsonNotFound(p,"map");
  848. // for each map array
  849. for(k=0; k<cmJsonChildCount(mapArrNp); ++k)
  850. {
  851. unsigned tid,cfgId;
  852. cmJsonNode_t* mapObjNp;
  853. if((mapObjNp = cmJsonArrayElement(mapArrNp,j))==NULL || cmJsonIsObject(mapObjNp)==false)
  854. return _cmDcmJsonSyntaxErr(p,"cfg object");
  855. if( cmJsonMemberValues( mapObjNp, &errLabelPtr,
  856. "tid", kIntTId, &tid,
  857. "cfgId", kIntTId, &cfgId,
  858. NULL ) != kOkDcRC )
  859. { return _cmDcmJsonSyntaxErr(p,errLabelPtr); }
  860. }
  861. }
  862. */
  863. // read each cfg object
  864. for(j=0; j<cmJsonChildCount(cfgArrNp); ++j)
  865. {
  866. cmJsonNode_t* cfgObjNp;
  867. const cmChar_t* dcLabelStr;
  868. const cmChar_t* descStr;
  869. unsigned cfgId, typeId;
  870. if((cfgObjNp = cmJsonArrayElement(cfgArrNp,j))==NULL || cmJsonIsObject(cfgObjNp)==false)
  871. return _cmDcmJsonSyntaxErr(p,"cfg object");
  872. if( cmJsonMemberValues( cfgObjNp, &errLabelPtr,
  873. "label", kStringTId, &dcLabelStr,
  874. "cfgId", kIntTId, &cfgId,
  875. "typeId", kIntTId, &typeId,
  876. "desc", kStringTId, &descStr,
  877. NULL ) != kOkJsRC )
  878. { _cmDcmJsonSyntaxErr(p,errLabelPtr); }
  879. cmDcmMidi_t m;
  880. cmDcmAudio_t a;
  881. cmDcmNet_t n;
  882. switch( typeId )
  883. {
  884. case kMidiDcmTId:
  885. if( cmJsonMemberValues( cfgObjNp, &errLabelPtr,
  886. "devLabelStr", kStringTId, &m.devLabelStr,
  887. "portLabelStr",kStringTId, &m.portLabelStr,
  888. "inputFl", kBoolTId, &m.inputFl,
  889. NULL) != kOkJsRC )
  890. {
  891. rc = _cmDcmJsonSyntaxErr(p,errLabelPtr);
  892. goto errLabel;
  893. }
  894. if((rc = cmDevCfgNameMidiPort(h,dcLabelStr,m.devLabelStr,m.portLabelStr,m.inputFl)) != kOkDcRC )
  895. goto errLabel;
  896. break;
  897. case kAudioDcmTId:
  898. if( cmJsonMemberValues( cfgObjNp, &errLabelPtr,
  899. "inDevLabelStr", kStringTId, &a.inDevLabelStr,
  900. "outDevLabelStr", kStringTId, &a.outDevLabelStr,
  901. "syncInputFl", kBoolTId, &a.audioSysArgs.syncInputFl,
  902. "msgQueueByteCnt", kIntTId, &a.audioSysArgs.msgQueueByteCnt,
  903. "devFramesPerCycle", kIntTId, &a.audioSysArgs.devFramesPerCycle,
  904. "dspFramesPerCycle", kIntTId, &a.audioSysArgs.dspFramesPerCycle,
  905. "audioBufCnt", kIntTId, &a.audioSysArgs.audioBufCnt,
  906. "srate", kRealTId, &a.audioSysArgs.srate,
  907. NULL ) != kOkJsRC )
  908. {
  909. rc = _cmDcmJsonSyntaxErr(p,errLabelPtr);
  910. goto errLabel;
  911. }
  912. if((rc = cmDevCfgNameAudioPort(h,dcLabelStr,a.inDevLabelStr,a.outDevLabelStr,
  913. a.audioSysArgs.syncInputFl,
  914. a.audioSysArgs.msgQueueByteCnt,
  915. a.audioSysArgs.devFramesPerCycle,
  916. a.audioSysArgs.dspFramesPerCycle,
  917. a.audioSysArgs.audioBufCnt,
  918. a.audioSysArgs.srate )) != kOkDcRC )
  919. {
  920. goto errLabel;
  921. }
  922. break;
  923. case kNetDcmTId:
  924. if( cmJsonMemberValues( cfgObjNp, &errLabelPtr,
  925. "sockAddr", kStringTId, &n.sockAddr,
  926. "portNumber", kIntTId, &n.portNumber,
  927. NULL ) != kOkJsRC )
  928. {
  929. rc = _cmDcmJsonSyntaxErr(p,errLabelPtr);
  930. goto errLabel;
  931. }
  932. if((rc = cmDevCfgNameNetPort(h,dcLabelStr,n.sockAddr,n.portNumber)) != kOkDcRC )
  933. goto errLabel;
  934. break;
  935. default:
  936. assert(0);
  937. break;
  938. }
  939. }
  940. }
  941. errLabel:
  942. return kOkDcRC;
  943. }
  944. cmDcRC_t _cmDevCfgWrite( cmDcm_t* p, cmJsonH_t jsH, cmJsonNode_t* rootObjPtr )
  945. {
  946. cmDcRC_t rc = kOkDcRC;
  947. const cmDcmLoc_t* lp = p->loc;
  948. cmJsonNode_t* cfgNp = cmJsonInsertPairObject(jsH, rootObjPtr, "cfg" );
  949. // create the loc array
  950. cmJsonNode_t* locArrNp = cmJsonInsertPairArray( jsH, cfgNp, "loc" );
  951. for(; lp!=NULL; lp=lp->next)
  952. {
  953. // create the 'loc' object
  954. cmJsonNode_t* locObjNp = cmJsonCreateObject(jsH,locArrNp);
  955. // set the loc label
  956. cmJsonInsertPairString(jsH, locObjNp, "label", lp->labelStr );
  957. /*
  958. // create the 'loc.app[]' array
  959. cmJsonNode_t* appArrNp = cmJsonInsertPairArray(jsH,locObjNp,"app");
  960. // for each app recd
  961. for(i=0; i<lp->appCnt; ++i)
  962. if( lp->app[i].activeFl )
  963. {
  964. // create the app recd
  965. cmJsonNode_t* appNp = cmJsonCreateObject(jsH,appArrNp );
  966. // create the map array
  967. cmJsonNode_t* mapArrNp = cmJsonInsertPairArray(jsH, appNp, "map" );
  968. // for each map recd
  969. for(j=0; j<lp->app[i].mapCnt; ++j)
  970. {
  971. cmJsonNode_t* mapNp = cmJsonCreateObject(jsH,mapArrNp);
  972. cmJsonInsertPairs(jsH, mapNp,
  973. "tid", kIntTId, lp->app[i].map[j].tid,
  974. "cfgId", kIntTId, lp->app[i].map[j].cfgId,
  975. NULL );
  976. }
  977. }
  978. */
  979. // create the 'loc.cfg[]' array
  980. cmJsonNode_t* cfgArrNp = cmJsonInsertPairArray(jsH,locObjNp,"cfg");
  981. // for each cfg recd
  982. cmDcmCfg_t* cp = lp->cfg;
  983. for(; cp!=NULL; cp=cp->next)
  984. {
  985. // create the cfg recd
  986. cmJsonNode_t* cfgObjNp = cmJsonCreateObject(jsH,cfgArrNp);
  987. // fill the cfg recd
  988. cmJsonInsertPairs(jsH, cfgObjNp,
  989. "label", kStringTId, cp->dcLabelStr,
  990. "cfgId", kIntTId, cp->cfgId,
  991. "typeId", kIntTId, cp->typeId,
  992. "desc", kStringTId, cp->descStr,
  993. NULL );
  994. switch( cp->typeId )
  995. {
  996. case kMidiDcmTId:
  997. cmJsonInsertPairs(jsH, cfgObjNp,
  998. "devLabelStr", kStringTId, cp->u.m.devLabelStr,
  999. "portLabelStr",kStringTId, cp->u.m.portLabelStr,
  1000. "inputFl", kBoolTId, cp->u.m.inputFl,
  1001. NULL );
  1002. break;
  1003. case kAudioDcmTId:
  1004. cmJsonInsertPairs(jsH, cfgObjNp,
  1005. "inDevLabelStr", kStringTId, cp->u.a.inDevLabelStr,
  1006. "outDevLabelStr", kStringTId, cp->u.a.outDevLabelStr,
  1007. "syncInputFl", kBoolTId, cp->u.a.audioSysArgs.syncInputFl,
  1008. "msgQueueByteCnt", kIntTId, cp->u.a.audioSysArgs.msgQueueByteCnt,
  1009. "devFramesPerCycle", kIntTId, cp->u.a.audioSysArgs.devFramesPerCycle,
  1010. "dspFramesPerCycle", kIntTId, cp->u.a.audioSysArgs.dspFramesPerCycle,
  1011. "audioBufCnt", kIntTId, cp->u.a.audioSysArgs.audioBufCnt,
  1012. "srate", kRealTId, cp->u.a.audioSysArgs.srate,
  1013. NULL );
  1014. break;
  1015. case kNetDcmTId:
  1016. cmJsonInsertPairs(jsH, cfgObjNp,
  1017. "sockAddr", kStringTId, cp->u.n.sockAddr,
  1018. "portNumber",kIntTId, cp->u.n.portNumber,
  1019. NULL );
  1020. break;
  1021. default:
  1022. assert(0);
  1023. break;
  1024. }
  1025. }
  1026. }
  1027. return rc;
  1028. }
  1029. cmDcRC_t cmDevCfgWrite( cmDevCfgH_t h, const cmChar_t* fn )
  1030. {
  1031. cmDcRC_t rc = kOkDcRC;
  1032. cmDcm_t* p = _cmDcmHandleToPtr(h);
  1033. cmJsonH_t jsH = cmJsonNullHandle;
  1034. if( fn == NULL )
  1035. fn = p->fn;
  1036. // validate the filename
  1037. if( fn == NULL || strlen(fn)==0 )
  1038. return cmErrMsg(&p->err,kInvalidFnDcRC,"No output file name was provided.");
  1039. // create a json object
  1040. if( cmJsonInitialize( &jsH, p->ctx ) != kOkJsRC )
  1041. {
  1042. rc = cmErrMsg(&p->err,kJsonFailDcRC,"An empty JSON tree could not be created.");
  1043. goto errLabel;
  1044. }
  1045. // insert a wrapper object as the root
  1046. if( cmJsonCreateObject( jsH, NULL ) == NULL )
  1047. {
  1048. rc = cmErrMsg(&p->err,kJsonFailDcRC,"The JSON root object could not be created.");
  1049. goto errLabel;
  1050. }
  1051. // fill the JSON tree
  1052. if((rc = _cmDevCfgWrite(p,jsH,cmJsonRoot(jsH))) != kOkDcRC )
  1053. goto errLabel;
  1054. // write the output file
  1055. if( cmJsonWrite(jsH, cmJsonRoot(jsH), fn ) != kOkJsRC )
  1056. {
  1057. rc = cmErrMsg(&p->err,kJsonFailDcRC,"The JSON file write failed on '%s'.",cmStringNullGuard(fn));
  1058. goto errLabel;
  1059. }
  1060. errLabel:
  1061. if( cmJsonFinalize(&jsH) != kOkJsRC )
  1062. cmErrMsg(&p->err,kJsonFailDcRC,"JSON tree finalization failed.");
  1063. return rc;
  1064. }