libcm is a C development framework with an emphasis on audio signal processing applications.
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

cmProc3.h 29KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700
  1. #ifndef cmProc3_h
  2. #define cmProc3_h
  3. #ifdef __cplusplus
  4. extern "C" {
  5. #endif
  6. typedef struct
  7. {
  8. double wi;
  9. double xi;
  10. int yn;
  11. cmSample_t* y;
  12. int yii;
  13. int yoi;
  14. int ynn;
  15. } cmPitchShiftOsc_t;
  16. typedef struct
  17. {
  18. cmObj obj;
  19. unsigned procSmpCnt;
  20. double srate;
  21. int outN; // procSmpCnt
  22. int wn; //
  23. int xn; //
  24. int bn; //
  25. cmSample_t* b; // b[bn]
  26. cmSample_t* x; // x[xn]
  27. cmSample_t* wnd; // wnd[wn]
  28. cmSample_t* outV; // outV[outN];
  29. int xni; //
  30. bool cubeFl; //
  31. cmPitchShiftOsc_t osc[2]; //
  32. } cmPitchShift;
  33. cmPitchShift* cmPitchShiftAlloc( cmCtx* c, cmPitchShift* p, unsigned procSmpCnt, cmReal_t srate );
  34. cmRC_t cmPitchShiftFree( cmPitchShift** pp );
  35. cmRC_t cmPitchShiftInit( cmPitchShift* p, unsigned procSmpCnt, cmReal_t srate );
  36. cmRC_t cmPitchShiftFinal(cmPitchShift* p );
  37. cmRC_t cmPitchShiftExec( cmPitchShift* p, const cmSample_t* x, cmSample_t* y, unsigned n, double shiftRatio, bool bypassFl );
  38. //=======================================================================================================================
  39. typedef struct
  40. {
  41. double xi; // index into xV[]
  42. double wi; // index into wV[]
  43. cmSample_t u; // cross-fade window polarity
  44. } cmLoopRecdOsc;
  45. typedef struct
  46. {
  47. cmLoopRecdOsc osc[2]; //
  48. cmSample_t* xV; // xV[ xN ]
  49. int xN; // maxRecdSmpCnt
  50. int xfN; // cross-fade sample count
  51. int xii; // xV[] recording input index
  52. cmSample_t* wV; // wV[ xN ] window function (actually contains xii values after recording)
  53. } cmLoopRecdBuf;
  54. typedef struct
  55. {
  56. cmObj obj;
  57. cmSample_t* bufMem;
  58. unsigned maxRecdSmpCnt;
  59. cmLoopRecdBuf* bufArray;
  60. unsigned bufArrayCnt;
  61. cmSample_t* outV;
  62. unsigned outN;
  63. unsigned procSmpCnt;
  64. unsigned xfadeSmpCnt;
  65. unsigned recdBufIdx;
  66. unsigned playBufIdx;
  67. bool recdFl;
  68. bool playFl;
  69. } cmLoopRecord;
  70. cmLoopRecord* cmLoopRecordAlloc( cmCtx* c, cmLoopRecord* p, unsigned procSmpCnt, unsigned maxRecdSmpCnt, unsigned xfadeSmpCnt );
  71. cmRC_t cmLoopRecordFree( cmLoopRecord** pp );
  72. cmRC_t cmLoopRecordInit( cmLoopRecord* p, unsigned procSmpCnt, unsigned maxRecdSmpCnt, unsigned xfadeSmpCnt );
  73. cmRC_t cmLoopRecordFinal( cmLoopRecord* p );
  74. // rgain=recorder output gain, pgain=pass through gain
  75. cmRC_t cmLoopRecordExec( cmLoopRecord* p, const cmSample_t* x, cmSample_t* y, unsigned xn, bool bypassFl, bool recdFl, bool playFl, double ratio, double pgain, double rgain );
  76. //=======================================================================================================================
  77. typedef struct
  78. {
  79. cmObj obj;
  80. unsigned rmsN;
  81. cmSample_t* rmsV; // rmsV[rmsN] previous rmsN values. rmsV[rmsN-1] == rms
  82. cmSample_t rms; // RMS of last procSmpCnt samples
  83. unsigned wndN;
  84. cmSample_t* wndV;
  85. cmSample_t mean;
  86. cmSample_t d0;
  87. unsigned durSmpCnt; // duration of the current gate polarity in samples
  88. bool gateFl;
  89. bool deltaFl;
  90. cmReal_t onThreshPct;
  91. cmReal_t onThreshDb;
  92. cmReal_t offThreshDb; //
  93. } cmGateDetect;
  94. cmGateDetect* cmGateDetectAlloc( cmCtx* c, cmGateDetect* p, unsigned procSmpCnt, cmReal_t onThreshPct, cmReal_t onThreshDb, cmReal_t offThreshDb );
  95. cmRC_t cmGateDetectFree( cmGateDetect** p );
  96. cmRC_t cmGateDetectInit( cmGateDetect* p, unsigned procSmpCnt, cmReal_t onThreshPct, cmReal_t onThreshDb, cmReal_t offThreshDb );
  97. cmRC_t cmGateDetectFinal(cmGateDetect* p );
  98. cmRC_t cmGateDetectExec( cmGateDetect* p, const cmSample_t* x, unsigned xn );
  99. //=======================================================================================================================
  100. typedef struct
  101. {
  102. unsigned medCnt; // length of the median filter
  103. unsigned avgCnt; // length of the (rms - med) moving avg. filter
  104. unsigned suprCnt; // length of the supression window
  105. unsigned offCnt; // length of the offset detection window
  106. cmReal_t suprCoeff; // supression signal shape coeff
  107. cmReal_t onThreshDb; // onset threshold
  108. cmReal_t offThreshDb; // offset threshold
  109. } cmGateDetectParams;
  110. typedef struct
  111. {
  112. cmObj obj;
  113. cmGateDetectParams args;
  114. cmSample_t* medV; // medV[medCnt]
  115. unsigned medIdx;
  116. cmSample_t* avgV; // avgV[avgCnt]
  117. unsigned avgIdx;
  118. cmSample_t* fcofV; // fcofV[medCnt]
  119. cmSample_t* fdlyV; // fdlyV[medCnt]
  120. cmSample_t* suprV; // suprV[suprCnt]
  121. unsigned suprIdx;
  122. cmSample_t* pkV; // pkV[3]
  123. cmSample_t* offV; // offV[offCnt]
  124. unsigned offIdx;
  125. unsigned pkFl; //
  126. bool gateFl; // set by onset, cleared by offset
  127. bool onFl; // set if an onset was detected
  128. bool offFl; // set if an offset was detected
  129. cmReal_t onThresh;
  130. cmReal_t offThresh;
  131. cmSample_t rms; // RMS
  132. cmSample_t med; // median RMS over last medCnt exec's
  133. cmSample_t dif; // max(0, RMS - median_RMS)
  134. cmSample_t avg; // avg dif's over last avgCnt exec's
  135. cmSample_t ons; // dif - avg
  136. cmSample_t flt; // filtered(ons)
  137. cmSample_t sup; // flt w/ suppression
  138. } cmGateDetect2;
  139. cmGateDetect2* cmGateDetectAlloc2( cmCtx* c, cmGateDetect2* p, unsigned procSmpCnt, const cmGateDetectParams* args );
  140. cmRC_t cmGateDetectFree2( cmGateDetect2** p );
  141. cmRC_t cmGateDetectInit2( cmGateDetect2* p, unsigned procSmpCnt, const cmGateDetectParams* args );
  142. cmRC_t cmGateDetectFinal2(cmGateDetect2* p );
  143. cmRC_t cmGateDetectExec2( cmGateDetect2* p, const cmSample_t* x, unsigned xn );
  144. void cmGateDetectSetOnThreshDb2( cmGateDetect2* p, cmReal_t db );
  145. void cmGateDetectSetOffThreshDb2( cmGateDetect2* p, cmReal_t db );
  146. //=======================================================================================================================
  147. //
  148. // Calculate a set of automatic gain adjustments for a set of audio channels.
  149. //
  150. // 1) Call cmAutoGainInit() to reset the object.
  151. // 2) Call cmAutoGainStartCh() and provide an id to identify the channel.
  152. // 3) Call cmAutoGainProcCh() with audio from the channel identified in 2)
  153. // 4) Repeat 2) and 3) for for all channels.
  154. // 5) Call cmAutoGainCalcGains() to set the value of cmAutoGainCh.gain.
  155. //
  156. // The gain coefficents are set to balance the overall gain.
  157. // (i.e. Loud channels are decreased and quiet channels are increased.)
  158. typedef struct
  159. {
  160. unsigned id; // channel id
  161. cmReal_t gain; // gain adjustment coefficient
  162. unsigned onCnt; // count of onsets detected
  163. unsigned offCnt; // count of offsets detected
  164. cmReal_t gateMaxAvg; // average of the max values for each detected event
  165. } cmAutoGainCh;
  166. typedef struct
  167. {
  168. cmObj obj;
  169. cmShiftBuf* sbp;
  170. cmGateDetect2* gdp;
  171. cmAutoGainCh* chArray; //
  172. unsigned chCnt;
  173. cmAutoGainCh* chp;
  174. unsigned gateCnt;
  175. cmReal_t gateSum;
  176. cmReal_t gateMax;
  177. cmReal_t minRms;
  178. } cmAutoGain;
  179. cmAutoGain* cmAutoGainAlloc( cmCtx* c, cmAutoGain* p, unsigned procSmpCnt, cmReal_t srate, cmReal_t hopMs, unsigned chCnt, const cmGateDetectParams* gd_args );
  180. cmRC_t cmAutoGainFree( cmAutoGain** p );
  181. cmRC_t cmAutoGainInit( cmAutoGain* p, unsigned procSmpCnt, cmReal_t srate, cmReal_t hopMs, unsigned chCnt, const cmGateDetectParams* gd_args );
  182. cmRC_t cmAutoGainFinal( cmAutoGain* p );
  183. // Notify the object that the following calls to cmAutoGainProcCh()
  184. // should be associed with the channel 'id'.
  185. cmRC_t cmAutoGainStartCh( cmAutoGain* p, unsigned id );
  186. // Examine the signal arriving from the channel specified in the previous
  187. // call to cmAutoGainProcCh() and determine the max RMS value for each
  188. // event contained in the signal.
  189. cmRC_t cmAutoGainProcCh( cmAutoGain* p, const cmSample_t* x, unsigned xn );
  190. // Calculate the cmAutoGainCh.gain coefficient for each channel.
  191. cmRC_t cmAutoGainCalcGains( cmAutoGain* p );
  192. void cmAutoGainPrint( cmAutoGain* p, cmRpt_t* rpt );
  193. //=======================================================================================================================
  194. typedef struct
  195. {
  196. unsigned ch;
  197. unsigned ssi;
  198. const cmChar_t* pitchStr;
  199. unsigned midi;
  200. cmReal_t gain;
  201. bool nsFl; // noise shaper channel
  202. bool cdFl; // chord detector channel
  203. } cmChCfgCh;
  204. typedef struct
  205. {
  206. cmObj obj;
  207. cmChCfgCh* chArray;
  208. unsigned chCnt;
  209. unsigned nsChCnt; // count of noise-shaper channels
  210. const cmChar_t* fn;
  211. cmJsonH_t jsH;
  212. cmJsonNode_t* cap;
  213. } cmChCfg;
  214. cmChCfg* cmChCfgAlloc( cmCtx* c, cmChCfg* p, cmCtx_t* ctx, const cmChar_t* fn );
  215. cmRC_t cmChCfgFree( cmChCfg** pp );
  216. cmRC_t cmChCfgInit( cmChCfg* p, cmCtx_t* ctx, const cmChar_t* fn );
  217. cmRC_t cmChCfgFinal( cmChCfg* p );
  218. cmRC_t cmChCfgWrite( cmChCfg* p );
  219. void cmChCfgPrint( cmChCfg* p, cmRpt_t* rpt );
  220. unsigned cmChCfgChannelCount( cmCtx_t* ctx, const cmChar_t* fn, unsigned* nsChCntPtr );
  221. unsigned cmChCfgChannelIndex( cmCtx_t* ctx, const cmChar_t* fn, unsigned chIdx );
  222. //=======================================================================================================================
  223. typedef struct
  224. {
  225. bool readyFl; // This channel has received an offset since it was last a candidate.
  226. bool candFl; // This channel is a chord candidate
  227. unsigned candSmpTime; // Time that this channel became a candidate
  228. cmReal_t candRMS; // RMS when this channel became a candidate
  229. bool chordFl; // This channel is part of the current chord
  230. bool gateFl; // Previous gate state
  231. } cmChordDetectCh;
  232. typedef struct
  233. {
  234. cmObj obj;
  235. unsigned maxTimeSpanSmpCnt; // maximum time between onsets of first and last note of chord
  236. unsigned minNotesPerChord; // the min. number of notes required to form a chord
  237. unsigned chCnt; // count of channels
  238. cmChordDetectCh* chArray; // channel state array
  239. bool detectFl; // true when a new chord has been detected
  240. unsigned timeSmp; // current time
  241. cmReal_t srate;
  242. } cmChordDetect;
  243. cmChordDetect* cmChordDetectAlloc( cmCtx*c, cmChordDetect* p, cmReal_t srate, unsigned chCnt, cmReal_t maxTimeSpanMs, unsigned minNotesPerChord );
  244. cmRC_t cmChordDetectFree( cmChordDetect** pp );
  245. cmRC_t cmChordDetectInit( cmChordDetect* p, cmReal_t srate, unsigned chCnt, cmReal_t maxTimeSpanMs, unsigned minNotesPerChord );
  246. cmRC_t cmChordDetectFinal( cmChordDetect* p );
  247. cmRC_t cmChordDetectExec( cmChordDetect* p, unsigned procSmpCnt, const bool* gateV, const cmReal_t* rmsV, unsigned chCnt );
  248. cmRC_t cmChordDetectSetSpanMs( cmChordDetect* p, cmReal_t maxTimeSpanMs );
  249. //=======================================================================================================================
  250. // This object is not really a cross-fader. It is really just a multichannel
  251. // fader - which just calculates the fade gain but does not actually apply it
  252. // to the audio signal - unless you use cmXfaderExecAudio()
  253. typedef struct
  254. {
  255. cmReal_t gain;
  256. bool gateFl;
  257. } cmXfaderCh;
  258. typedef struct
  259. {
  260. cmObj obj;
  261. unsigned chCnt;
  262. cmXfaderCh* chArray;
  263. unsigned fadeSmpCnt;
  264. cmReal_t srate;
  265. bool gateFl; // true if any channels are on
  266. bool onFl; // true on cycle where gate transitions to 'on'.
  267. bool offFl; // true on cycle where gate transitions to 'off'.
  268. } cmXfader;
  269. cmXfader* cmXfaderAlloc( cmCtx*c, cmXfader* p, cmReal_t srate, unsigned chCnt, cmReal_t fadeTimeMs );
  270. cmRC_t cmXfaderFree( cmXfader** pp );
  271. cmRC_t cmXfaderInit( cmXfader* p, cmReal_t srate, unsigned chCnt, cmReal_t fadeTimeMs );
  272. cmRC_t cmXfaderFinal( cmXfader* p );
  273. cmRC_t cmXfaderExec( cmXfader* p, unsigned procSmpCnt, const bool* gateV, unsigned chCnt );
  274. cmRC_t cmXfaderExecAudio( cmXfader* p, unsigned procSmpCnt, const bool* gateV, unsigned chCnt, const cmSample_t* x[], cmSample_t* y );
  275. void cmXfaderSetXfadeTime( cmXfader* p, cmReal_t fadeTimeMs );
  276. // Set all gates to false except chIdx.
  277. void cmXfaderSelectOne( cmXfader* p, unsigned chIdx );
  278. void cmXfaderAllOff( cmXfader* p );
  279. //=======================================================================================================================
  280. // This fader object accepts a gate signal. When the gate is high it increments
  281. // the gain until it reaches 1.0. When the gate is low it decrements the gain
  282. // until it reaches 0.0. The fade time is the lenght of time the gain will take
  283. // to transition from 0.0 to 1.0 or 1.0 to 0.0.
  284. typedef struct
  285. {
  286. cmObj obj;
  287. unsigned fadeSmpCnt; // time to fade from 0->1 or 1->0
  288. cmReal_t srate;
  289. cmReal_t gain;
  290. } cmFader;
  291. cmFader* cmFaderAlloc( cmCtx*c, cmFader* p, cmReal_t srate, cmReal_t fadeTimeMs );
  292. cmRC_t cmFaderFree( cmFader** pp );
  293. cmRC_t cmFaderInit( cmFader* p, cmReal_t srate, cmReal_t fadeTimeMs );
  294. cmRC_t cmFaderFinal( cmFader* p );
  295. cmRC_t cmFaderExec( cmFader* p, unsigned procSmpCnt, bool gateFl, bool mixFl, const cmSample_t* x, cmSample_t* y );
  296. void cmFaderSetFadeTime( cmFader* p, cmReal_t fadeTimeMs );
  297. //=======================================================================================================================
  298. struct cmIDelay_str;
  299. typedef struct
  300. {
  301. cmObj obj;
  302. cmReal_t srate; // system sample rate
  303. bool feedbackFl; // set if this is a feedback comb filter
  304. cmReal_t minHz; // lowest comb frequency this comb filter can support
  305. cmReal_t hz; // location of first comb
  306. cmReal_t alpha; // filter coeff.
  307. cmReal_t dN; // max length of the the cf delay line
  308. unsigned dn; // current length of cf delay line
  309. cmReal_t* d; // d[dn] filter delay line
  310. cmReal_t* b; // b[dn] feedforward coeff's
  311. cmReal_t* a; // a[dn] feedback coeff's
  312. cmReal_t b0; // feedforward coeff 0
  313. bool bypassFl; // bypass enable flag
  314. struct cmIDelay_str* idp;
  315. } cmCombFilt;
  316. cmCombFilt* cmCombFiltAlloc( cmCtx* c, cmCombFilt* p, cmReal_t srate, bool feedbackFl, cmReal_t minHz, cmReal_t alpha, cmReal_t hz, bool bypassFl );
  317. cmRC_t cmCombFiltFree( cmCombFilt** pp);
  318. cmRC_t cmCombFiltInit( cmCombFilt* p, cmReal_t srate, bool feedbackFl, cmReal_t minHz, cmReal_t alpha, cmReal_t hz, bool bypassFl );
  319. cmRC_t cmCombFiltFinal( cmCombFilt* p );
  320. cmRC_t cmCombFiltExec( cmCombFilt* p, const cmSample_t* x, cmSample_t* y, unsigned n );
  321. void cmCombFiltSetAlpha( cmCombFilt* p, cmReal_t alpha );
  322. cmRC_t cmCombFiltSetHz( cmCombFilt* p, cmReal_t hz );
  323. //=======================================================================================================================
  324. typedef struct
  325. {
  326. cmObj obj;
  327. cmReal_t d[2]; //
  328. cmReal_t b[1]; //
  329. cmReal_t a[1]; // a[dn] feedback coeff's
  330. cmReal_t b0; // feedforward coeff 0
  331. bool bypassFl;
  332. } cmDcFilt;
  333. cmDcFilt* cmDcFiltAlloc( cmCtx* c, cmDcFilt* p, bool bypassFl );
  334. cmRC_t cmDcFiltFree( cmDcFilt** pp);
  335. cmRC_t cmDcFiltInit( cmDcFilt* p, bool bypassFl );
  336. cmRC_t cmDcFiltFinal( cmDcFilt* p );
  337. cmRC_t cmDcFiltExec( cmDcFilt* p, const cmSample_t* x, cmSample_t* y, unsigned n );
  338. //=======================================================================================================================
  339. // interpolating delay - used by the comb filter
  340. typedef struct cmIDelay_str
  341. {
  342. cmObj obj;
  343. cmSample_t* d; // d[dn] delay line
  344. int dn; // sizeo of delay
  345. cmSample_t* m; // memory buffer
  346. int mn; // size of memory bufer (dn+3)
  347. int ii; // input index
  348. unsigned tn; // count of taps
  349. cmReal_t* ti; // ti[tn] tap locations (fractional delay from t->ii)
  350. cmReal_t* tff; // tg[tn] tap out gain
  351. cmReal_t* tfb;// tfb[tn] tap feedback gain
  352. cmReal_t srate;
  353. } cmIDelay;
  354. cmIDelay* cmIDelayAlloc( cmCtx* c, cmIDelay* p, cmReal_t srate, cmReal_t maxDelayMs, const cmReal_t* tapMs, const cmReal_t* tapFfGain, const cmReal_t* tapFbGain, unsigned tapCnt );
  355. cmRC_t cmIDelayFree( cmIDelay** pp );
  356. cmRC_t cmIDelayInit( cmIDelay* p, cmReal_t srate, cmReal_t maxDelayMs, const cmReal_t* tapMs, const cmReal_t* tapFfGain, const cmReal_t* tapFbGain, unsigned tapCnt );
  357. cmRC_t cmIDelayFinal(cmIDelay* p );
  358. cmRC_t cmIDelayExec( cmIDelay* p, const cmSample_t* x, cmSample_t* y, unsigned n );
  359. cmRC_t cmIDelaySetTapMs( cmIDelay* p, unsigned tapIdx, cmReal_t tapMs );
  360. //=======================================================================================================================
  361. // This object sequentially assigns channels to groups when their gates go high.
  362. // 'chsPerGroup' channels will be assigned to each group. No channel will be
  363. // assigned to any group unless there are at least 'chsPerGroup' available
  364. // (unassigned) channels.
  365. // Channels are released from groups when one of the member channels gates goes low.
  366. //
  367. typedef struct
  368. {
  369. cmReal_t rms; // current rms of this input channel
  370. bool gateFl; // current gate state of this input channel
  371. bool readyFl; // this channel is available to be assigned to a group
  372. bool offsetFl; // the gate went low during this cycle (cleared on exec)
  373. unsigned groupIdx; // group this channel is assigned to or cmInvalidIdx if it is not assigned to any group
  374. } cmGroupSelCh;
  375. typedef struct
  376. {
  377. unsigned* chIdxArray; // chIdxArray[p->chCnt] array of indexes to channels assigned to this group
  378. unsigned chIdxCnt; // count indexes in chIdxArray[] or 0 if the channel is not in use
  379. bool releaseFl; // true during the cycle that this group was released on
  380. bool createFl; // true during the cycle that this group was created on
  381. } cmGroupSelGrp;
  382. typedef struct
  383. {
  384. cmObj obj;
  385. cmGroupSelCh* chArray; // chArray[chCnt]
  386. unsigned chCnt; // count of channels
  387. cmGroupSelGrp* groupArray; // groupArray[groupCnt]
  388. unsigned groupCnt; // count of groups - must be <= chCnt - can be changed at any time
  389. unsigned chsPerGroup; // channels per group
  390. bool updateFl; // set during exec if channels were assigned or released
  391. } cmGroupSel;
  392. cmGroupSel* cmGroupSelAlloc( cmCtx* c, cmGroupSel* p, unsigned chCnt, unsigned groupCnt, unsigned chsPerGroup );
  393. cmRC_t cmGroupSelFree( cmGroupSel** pp );
  394. cmRC_t cmGroupSelInit( cmGroupSel* p, unsigned chCnt, unsigned groupCnt, unsigned chsPerGroup );
  395. cmRC_t cmGroupSelFinal( cmGroupSel* p );
  396. cmRC_t cmGroupSetChannelGate( cmGroupSel* p, unsigned chIdx, bool gateFl );
  397. cmRC_t cmGroupSetChannelRMS( cmGroupSel* p, unsigned chIdx, cmReal_t rms );
  398. // After exec if the p->updateFl is set then iterate through
  399. // p->groupArray[]. Groups that have been created will have their 'createFl' set
  400. // and groups that will be removed on the next cycle have their 'releaseFl' set.
  401. cmRC_t cmGroupSelExec( cmGroupSel* p );
  402. //=======================================================================================================================
  403. // Route N of M input channels to N output channels.
  404. // The N channels are selected from the first N gates to go high.
  405. typedef struct cmAudioNofM_In_str
  406. {
  407. bool gateFl;
  408. bool onsetFl;
  409. bool offsetFl;
  410. unsigned outChIdx;
  411. cmFader* fader;
  412. struct cmAudioNofM_In_str* link;
  413. } cmAudioNofM_In;
  414. typedef struct
  415. {
  416. struct cmAudioNofM_In_str* list;
  417. } cmAudioNofM_Out;
  418. typedef struct
  419. {
  420. cmObj obj;
  421. unsigned iChCnt; // (M) input channel count
  422. cmAudioNofM_In* inArray; // chArray[ M ] - input channel array
  423. unsigned oChCnt; // (N) output channel count
  424. cmAudioNofM_Out* outArray; // outArray[N] - output channel array
  425. unsigned nxtOutChIdx; // ch assoc;d with the next onset gate will be assined to this output channel
  426. } cmAudioNofM;
  427. cmAudioNofM* cmAudioNofMAlloc( cmCtx* c, cmAudioNofM* p, cmReal_t srate, unsigned iChCnt, unsigned oChCnt, cmReal_t fadeTimeMs );
  428. cmRC_t cmAudioNofMFree( cmAudioNofM** pp );
  429. cmRC_t cmAudioNofMInit( cmAudioNofM* p, cmReal_t srate, unsigned iChCnt, unsigned oChCnt, cmReal_t fadeTimeMs );
  430. cmRC_t cmAudioNofMFinal( cmAudioNofM* p );
  431. cmRC_t cmAudioNofMSetChannelGate( cmAudioNofM* p, unsigned inChIdx, bool gateFl );
  432. // Sum the audio contained in x[inChCnt][n] into y[outChCnt][n] according
  433. // to the state of the object.
  434. // Notes
  435. // 1) y[n] should be zeroed by the caller as the output is summed into this buffer.
  436. // 2) inChCnt should equal p->iChCnt and outChCnt should equal p->oChCnt
  437. cmRC_t cmAudioNofMExec( cmAudioNofM* p, const cmSample_t* x[], unsigned inChCnt, cmSample_t* y[], unsigned outChCnt, unsigned n );
  438. cmRC_t cmAudioNofMSetFadeMs( cmAudioNofM* p, cmReal_t fadeTimeMs );
  439. //=======================================================================================================================
  440. enum { kDlyAdsrId, kAtkAdsrId, kDcyAdsrId, kSusAdsrId, kRlsAdsrId, kDoneAdsrId };
  441. typedef struct
  442. {
  443. cmObj obj;
  444. cmReal_t srate;
  445. bool trigModeFl; // gate on triggers start, gate-off ignored
  446. cmReal_t levelMin;
  447. cmReal_t scaleDur; //
  448. int dlySmp;
  449. int atkSmp;
  450. cmReal_t atkLevel;
  451. int dcySmp;
  452. int susSmp; // only used in trigger mode
  453. cmReal_t susLevel;
  454. int rlsSmp;
  455. unsigned state; // current state
  456. int durSmp; // time in current state
  457. cmReal_t level; // current level
  458. bool gateFl; // last gate state
  459. cmReal_t atkBegLevel; // attack starting level
  460. cmReal_t atkDurSmp; // attack duration
  461. cmReal_t rlsLevel; // release starting level
  462. cmReal_t rlsDurSmp; // release duration
  463. cmReal_t actAtkLevel;
  464. cmReal_t actSusLevel;
  465. } cmAdsr;
  466. cmAdsr* cmAdsrAlloc( cmCtx* c, cmAdsr* p, cmReal_t srate, bool trigFl, cmReal_t minL, cmReal_t dlyMs, cmReal_t atkMs, cmReal_t atkL, cmReal_t dcyMs, cmReal_t susMs, cmReal_t susL, cmReal_t rlsMs );
  467. cmRC_t cmAdsrFree( cmAdsr** pp );
  468. cmRC_t cmAdsrInit( cmAdsr* p, cmReal_t srate, bool trigFl, cmReal_t minL, cmReal_t dlyMs, cmReal_t atkMs, cmReal_t atkL, cmReal_t dcyMs, cmReal_t susMs, cmReal_t susL, cmReal_t rlsMs );
  469. cmRC_t cmAdsrFinal( cmAdsr* p );
  470. cmReal_t cmAdsrExec( cmAdsr* p, unsigned procSmpCnt, bool gateFl, cmReal_t tscale, cmReal_t ascale );
  471. void cmAdsrSetTime( cmAdsr* p, cmReal_t ms, unsigned id );
  472. void cmAdsrSetLevel( cmAdsr* p, cmReal_t level, unsigned id );
  473. void cmAdsrReport( cmAdsr* p, cmRpt_t* rpt );
  474. //=======================================================================================================================
  475. enum { kAtkCompId, kRlsCompId };
  476. typedef struct
  477. {
  478. cmObj obj;
  479. cmReal_t srate; // system sample rate
  480. unsigned procSmpCnt; // samples per exec cycle
  481. cmReal_t inGain; // input gain
  482. cmReal_t threshDb; // threshold in dB (max:100 min:0)
  483. cmReal_t ratio_num; // numerator of the ratio
  484. unsigned atkSmp; // time to reduce the signal by 10.0 db
  485. unsigned rlsSmp; // time to increase the signal by 10.0 db
  486. cmReal_t outGain; // makeup gain
  487. bool bypassFl; // bypass enable
  488. cmSample_t* rmsWnd; // rmsWnd[rmsWndAllocCnt]
  489. unsigned rmsWndAllocCnt; //
  490. unsigned rmsWndCnt; // current RMS window size (rmsWndCnt must be <= rmsWndAllocCnt)
  491. unsigned rmsWndIdx; // next RMS window input index
  492. unsigned state; // env. state
  493. cmReal_t rmsDb; // current incoming signal RMS (max:100 min:0)
  494. cmReal_t gain; // current compressor gain
  495. cmReal_t timeConstDb; // the atk/rls will incr/decr by 'timeConstDb' per atkMs/rlsMs.
  496. cmReal_t pkDb; //
  497. cmReal_t accumDb; //
  498. } cmCompressor;
  499. cmCompressor* cmCompressorAlloc( cmCtx* c, cmCompressor* p, cmReal_t srate, unsigned procSmpCnt, cmReal_t inGain, cmReal_t rmsWndMaxMs, cmReal_t rmsWndMs, cmReal_t threshDb, cmReal_t ratio, cmReal_t atkMs, cmReal_t rlsMs, cmReal_t outGain, bool bypassFl );
  500. cmRC_t cmCompressorFree( cmCompressor** pp );
  501. cmRC_t cmCompressorInit( cmCompressor* p, cmReal_t srate, unsigned procSmpCnt, cmReal_t inGain, cmReal_t rmsWndMaxMs, cmReal_t rmsWndMs, cmReal_t threshDb, cmReal_t ratio, cmReal_t atkMs, cmReal_t rlsMs, cmReal_t outGain, bool bypassFl );
  502. cmRC_t cmCompressorFinal( cmCompressor* p );
  503. cmRC_t cmCompressorExec( cmCompressor* p, const cmSample_t* x, cmSample_t* y, unsigned n );
  504. void cmCompressorSetAttackMs( cmCompressor* p, cmReal_t ms );
  505. void cmCompressorSetReleaseMs( cmCompressor* p, cmReal_t ms );
  506. void cmCompressorSetThreshDb( cmCompressor* p, cmReal_t thresh );
  507. void cmCompressorSetRmsWndMs( cmCompressor* p, cmReal_t ms );
  508. //=======================================================================================================================
  509. // BiQuad Audio Eq's based on Robert Bristow-Johnson's recipes.
  510. // http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
  511. // See filter_rbj.m for equivalent octave code.
  512. enum
  513. {
  514. kLpfBqId,
  515. kHpFBqId,
  516. kBpfBqId,
  517. kNotchBqId,
  518. kAllpassBqId,
  519. kPeakBqId,
  520. kLowShelfBqId,
  521. kHighShelfBqId
  522. };
  523. typedef struct
  524. {
  525. cmObj obj;
  526. cmReal_t srate;
  527. unsigned mode;
  528. cmReal_t f0Hz;
  529. cmReal_t Q;
  530. cmReal_t gainDb;
  531. cmReal_t d[4];
  532. cmReal_t b[3];
  533. cmReal_t a[3];
  534. bool bypassFl;
  535. } cmBiQuadEq;
  536. cmBiQuadEq* cmBiQuadEqAlloc( cmCtx* c, cmBiQuadEq* p, cmReal_t srate, unsigned mode, cmReal_t f0Hz, cmReal_t Q, cmReal_t gainDb, bool bypassFl );
  537. cmRC_t cmBiQuadEqFree( cmBiQuadEq** pp );
  538. cmRC_t cmBiQuadEqInit( cmBiQuadEq* p, cmReal_t srate, unsigned mode, cmReal_t f0Hz, cmReal_t Q, cmReal_t gainDb, bool bypassFl );
  539. cmRC_t cmBiQuadEqFinal( cmBiQuadEq* p );
  540. cmRC_t cmBiQuadEqExec( cmBiQuadEq* p, const cmSample_t* x, cmSample_t* y, unsigned n );
  541. void cmBiQuadEqSet( cmBiQuadEq* p, unsigned mode, cmReal_t f0Hz, cmReal_t Q, cmReal_t gainDb );
  542. //=======================================================================================================================
  543. typedef struct
  544. {
  545. cmObj obj;
  546. cmReal_t srate;
  547. cmReal_t downSrate;
  548. cmReal_t bits;
  549. bool rectFl;
  550. bool fullFl;
  551. cmReal_t clipDb;
  552. cmReal_t inGain;
  553. cmReal_t outGain;
  554. bool bypassFl;
  555. double fracIdx;
  556. cmSample_t lastVal;
  557. cmSample_t lastY;
  558. cmSample_t lastX;
  559. } cmDistDs;
  560. cmDistDs* cmDistDsAlloc( cmCtx* c, cmDistDs* p, cmReal_t srate, cmReal_t inGain, cmReal_t downSrate, cmReal_t bits, bool rectFl, bool fullFl, cmReal_t clipDb, cmReal_t outGain, bool bypassFl );
  561. cmRC_t cmDistDsFree( cmDistDs** p );
  562. cmRC_t cmDistDsInit( cmDistDs* p, cmReal_t srate, cmReal_t inGain, cmReal_t downSrate, cmReal_t bits, bool rectFl, bool fullFl, cmReal_t clipDb, cmReal_t outGain, bool bypassFl );
  563. cmRC_t cmDistDsFinal( cmDistDs* p );
  564. cmRC_t cmDistDsExec( cmDistDs* p, const cmSample_t* x, cmSample_t* y, unsigned n );
  565. //=======================================================================================================================
  566. /*
  567. typedef struct
  568. {
  569. cmObj obj;
  570. } cmUnitDelay;
  571. cmUnitDelay* cmUnitDelayAlloc( cmCtx* c, cmUnitDelay* p, cmReal_t srate, unsigned smpCnt, unsigned inCnt, unsigned outCnt, const cmReal_t delayMsV, unsigned delayCnt );
  572. cmRC_t cmUnitDelayFree( cmUnitDelay* p );
  573. cmRC_t cmUnitDelayInit( cmUnitDelay* p, cmReal_t srate, unsigned smpCnt, braunsigned inCnt, unsigned outCnt, const cmReal_t delayMsV, unsigned delayCnt );
  574. cmRC_t cmUnitDelayFinal( cmUnitDelay* p );
  575. cmRC_t cmUnitDelayExec( cmUnitDelay* p, const cmSample_t** x, unsigned inChCnt, cmSample_t** y, unsigned outChCnt, unsigned smpCnt );
  576. */
  577. #ifdef __cplusplus
  578. }
  579. #endif
  580. #endif