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.

cmProc2.h 48KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187
  1. #ifndef cmProc2_h
  2. #define cmProc2_h
  3. #ifdef __cplusplus
  4. extern "C" {
  5. #endif
  6. //------------------------------------------------------------------------------------------------------------
  7. // cmArray is an expandable array designed to work easily with the alloc/init/final/free model
  8. // used by this library. The arrays can be safely used by using the cmArrayAllocXXX macros
  9. // with static cmArray member fields during object allocation. cmArrayResizeXXX macros are then
  10. // used during the object initialization phase to allocate the actual array data space. Notice that
  11. // when used this way there is no need to call cmArrayFinal() prior to cmArrayResizeXXX().
  12. // The data memory used by cmArray's is allocated through the cmAllocData() and cmAllocDataZ()
  13. // macros. The resulting base memory address is therefore guaranteed to be aligned to a
  14. // 16 byte address boundary.
  15. typedef struct
  16. {
  17. cmObj obj;
  18. char* ptr;
  19. unsigned allocByteCnt;
  20. unsigned eleCnt;
  21. unsigned eleByteCnt;
  22. } cmArray;
  23. enum
  24. {
  25. kZeroArrayFl = 0x01
  26. };
  27. cmArray* cmArrayAllocate( cmCtx* c, cmArray* p, unsigned eleCnt, unsigned eleByteCnt, unsigned flags );
  28. cmRC_t cmArrayFree( cmArray** pp );
  29. cmRC_t cmArrayInit( cmArray* p, unsigned eleCnt, unsigned eleByteCnt, unsigned flags );
  30. cmRC_t cmArrayFinal( cmArray* p );
  31. char* cmArrayReallocDestroy( cmArray* p, unsigned newEleCnt, unsigned newEleByteCnt, unsigned flags );
  32. void cmArrayReallocDestroyV(cmArray* p, int eleByteCnt,unsigned flags, ... );
  33. char* cmArrayReallocPreserve(cmArray* p, unsigned newEleCnt, unsigned newEleByteCnt, unsigned flags );
  34. #define cmArrayAlloc( c, p ) cmArrayAllocate(c,p,0,0,0);
  35. #define cmArrayAllocInit( c, p, eleCnt, type ) cmArrayAllocate(c,p,eleCnt,sizeof(type),0)
  36. #define cmArrayAllocInitZ( c, p, eleCnt, type ) cmArrayAllocate(c,p,eleCnt,sizeof(type),kZeroArrayFl)
  37. #define cmArrayResize( c, p, newEleCnt, type ) (type*)cmArrayReallocDestroy(c,p,newEleCnt,sizeof(type), 0 )
  38. #define cmArrayResizeZ( c, p, newEleCnt, type ) (type*)cmArrayReallocDestroy(c,p,newEleCnt,sizeof(type), kZeroArrayFl )
  39. #define cmArrayResizePreserve( c, p, newEleCnt, type ) (type*)cmArrayReallocPreserve(c,p,newEleCnt,sizeof(type), 0 )
  40. #define cmArrayResizePreserveZ(c, p, newEleCnt, type ) (type*)cmArrayReallocPreserve(c,p,newEleCnt,sizeof(type), kZeroArrayFl )
  41. #define cmArrayResizeV( c, p, type, ... ) cmArrayReallocDestroyV(c,p,sizeof(type),0,##__VA_ARGS__)
  42. #define cmArrayResizeVZ( c, p, type, ... ) cmArrayReallocDestroyV(c,p,sizeof(type),kZeroArrayFl,##__VA_ARGS__)
  43. #define cmArrayPtr( type, p ) (type*)(p)->ptr
  44. #define cmArrayCount( p ) (p)->eleCnt
  45. //------------------------------------------------------------------------------------------------------------
  46. typedef struct
  47. {
  48. cmObj obj;
  49. cmAudioFileH_t h;
  50. unsigned chCnt;
  51. unsigned curChCnt;
  52. unsigned procSmpCnt;
  53. char* fn;
  54. cmSample_t* bufV;
  55. } cmAudioFileWr;
  56. cmAudioFileWr* cmAudioFileWrAlloc( cmCtx* c, cmAudioFileWr* p, unsigned procSmpCnt, const char* fn, double srate, unsigned chCnt, unsigned bitsPerSample );
  57. cmRC_t cmAudioFileWrFree( cmAudioFileWr** pp );
  58. cmRC_t cmAudioFileWrInit( cmAudioFileWr* p, unsigned procSmpCnt, const char* fn, double srate, unsigned chCnt, unsigned bitsPerSample );
  59. cmRC_t cmAudioFileWrFinal( cmAudioFileWr* p );
  60. cmRC_t cmAudioFileWrExec( cmAudioFileWr* p, unsigned chIdx, const cmSample_t* sp, unsigned sn );
  61. void cmAudioFileWrTest();
  62. //------------------------------------------------------------------------------------------------------------
  63. typedef struct
  64. {
  65. cmObj obj;
  66. unsigned rn;
  67. unsigned cn;
  68. cmSample_t *bufPtr;
  69. } cmMatrixBuf;
  70. /// Set p to NULL to dynamically allocate the object
  71. cmMatrixBuf* cmMatrixBufAllocFile(cmCtx* c, cmMatrixBuf* p, const char* fn );
  72. cmMatrixBuf* cmMatrixBufAllocCopy(cmCtx* c, cmMatrixBuf* p, unsigned rn, unsigned cn, const cmSample_t* sp );
  73. cmMatrixBuf* cmMatrixBufAlloc( cmCtx* c, cmMatrixBuf* p, unsigned rn, unsigned cn );
  74. cmRC_t cmMatrixBufFree( cmMatrixBuf**p );
  75. cmRC_t cmMatrixBufInitFile( cmMatrixBuf* p, const char* fn );
  76. cmRC_t cmMatrixBufInitCopy( cmMatrixBuf* p, unsigned rn, unsigned cn, const cmSample_t* sp );
  77. cmRC_t cmMatrixBufInit( cmMatrixBuf* p, unsigned rn, unsigned cn );
  78. cmRC_t cmMatrixBufFinal( cmMatrixBuf* p );
  79. cmSample_t* cmMatrixBufColPtr( cmMatrixBuf* p, unsigned ci );
  80. cmSample_t* cmMatrixBufRowPtr( cmMatrixBuf* p, unsigned ri );
  81. void cmMatrixBufTest();
  82. //------------------------------------------------------------------------------------------------------------
  83. enum
  84. {
  85. kInvalidWfId,
  86. kSineWfId,
  87. kCosWfId,
  88. kSquareWfId,
  89. kTriangleWfId,
  90. kSawtoothWfId,
  91. kWhiteWfId,
  92. kPinkWfId,
  93. kPulseWfId,
  94. kImpulseWfId,
  95. kSilenceWfId,
  96. kPhasorWfId,
  97. kSeqWfId, // always incrementing integer sequence (srate,frq,otCnt is ignored)
  98. };
  99. typedef struct
  100. {
  101. cmObj obj;
  102. unsigned wfId;
  103. unsigned overToneCnt;
  104. double fundFrqHz;
  105. cmSample_t* outV;
  106. unsigned outN; // outN == procSmpCnt
  107. unsigned phase;
  108. cmSample_t delaySmp;
  109. double srate;
  110. } cmSigGen;
  111. /// Set p to NULL to dynamically allocate the object
  112. /// The last three arguments are optional. Set wfId to kInvalidWfId to allocate the signal generator without initializint it.
  113. cmSigGen* cmSigGenAlloc( cmCtx* c, cmSigGen* p, unsigned procSmpCnt, double srate, unsigned wfId, double fundFrqHz, unsigned overToneCnt );
  114. cmRC_t cmSigGenFree( cmSigGen** p );
  115. cmRC_t cmSigGenInit( cmSigGen* p, unsigned procSmpCnt, double srate, unsigned wfId, double fundFrqHz, unsigned overToneCnt );
  116. cmRC_t cmSigGenFinal( cmSigGen* p );
  117. cmRC_t cmSigGenExec( cmSigGen* p );
  118. //------------------------------------------------------------------------------------------------------------
  119. typedef struct
  120. {
  121. cmObj* obj;
  122. cmSample_t* bufPtr;
  123. unsigned bufSmpCnt; // count of samples in the delay line (bufSmpCnt = procSmpCnt+delaySmpCnt)
  124. unsigned procSmpCnt; // maximum legal samples to receive in a single call to cmDelayExec()
  125. unsigned delaySmpCnt; // delay time in samples
  126. int delayInIdx; // index into bufPtr[] of next element to receive an incoming sample
  127. unsigned outCnt; // count of valid buffers in outV[]
  128. cmSample_t* outV[2]; // pointers to output buffers
  129. unsigned outN[2]; // length of output buffers (the sum of the length of both output buffers is always procSmpCnt)
  130. } cmDelay;
  131. cmDelay* cmDelayAlloc( cmCtx* c, cmDelay* p, unsigned procSmpCnt, unsigned delaySmpCnt );
  132. cmRC_t cmDelayFree( cmDelay** p );
  133. cmRC_t cmDelayInit( cmDelay* p, unsigned procSmpCnt, unsigned delaySmpCnt );
  134. cmRC_t cmDelayFinal( cmDelay* p );
  135. cmRC_t cmDelayCopyIn( cmDelay* p, const cmSample_t* sp, unsigned sn );
  136. cmRC_t cmDelayAdvance( cmDelay* p, unsigned sn );
  137. cmRC_t cmDelayExec( cmDelay* p, const cmSample_t* sp, unsigned sn, bool bypassFl );
  138. void cmDelayTest();
  139. //------------------------------------------------------------------------------------------------------------
  140. typedef struct
  141. {
  142. cmObj obj;
  143. double* coeffV; // FIR coefficient vector (impulse response)
  144. unsigned coeffCnt; // count of elements in coeffV
  145. double* delayV; // delay vector contains one less elements than the coeff array
  146. cmSample_t* outV; // output signal
  147. unsigned outN; // length of the output signal (outN == ctx.procSmpCnt)
  148. unsigned delayIdx; // current next sample to receive input in the the delay line
  149. } cmFIR;
  150. enum { kHighPassFIRFl = 0x01 };
  151. /// Set p to NULL to dynamically allocate the object.
  152. cmFIR* cmFIRAllocKaiser(cmCtx* c, cmFIR* p, unsigned procSmpCnt, double srate, double passHz, double stopHz, double passDb, double stopDb );
  153. cmFIR* cmFIRAllocSinc( cmCtx* c, cmFIR* p, unsigned procSmpCnt, double srate, unsigned sincSmpCnt, double fcHz, unsigned flags );
  154. cmRC_t cmFIRFree( cmFIR** pp );
  155. cmRC_t cmFIRInitKaiser( cmFIR* p, unsigned procSmpCnt, double srate, double passHz, double stopHz, double passDb, double stopDb );
  156. cmRC_t cmFIRInitSinc( cmFIR* p, unsigned procSmpCnt, double srate, unsigned sincSmpCnt, double fcHz, unsigned flags );
  157. cmRC_t cmFIRFinal( cmFIR* p );
  158. cmRC_t cmFIRExec( cmFIR* p, const cmSample_t* sp, unsigned sn );
  159. void cmFIRTest();
  160. //------------------------------------------------------------------------------------------------------------
  161. // Apply a generic function to a windowed signal with a one sample hop size.
  162. typedef cmSample_t (*cmFuncFiltPtr_t)( const cmSample_t* sp, unsigned sn, void* userPtr );
  163. typedef struct
  164. {
  165. cmObj obj;
  166. cmFuncFiltPtr_t funcPtr;
  167. cmShiftBuf shiftBuf;
  168. cmSample_t* outV;
  169. unsigned outN; // outN == procSmpCnt
  170. unsigned curWndSmpCnt;
  171. unsigned wndSmpCnt;
  172. void* userPtr;
  173. } cmFuncFilter;
  174. /// Set p to NULL to dynamically allocate the object.
  175. cmFuncFilter* cmFuncFilterAlloc( cmCtx* c, cmFuncFilter* p, unsigned procSmpCnt, cmFuncFiltPtr_t funcPtr, void* userPtr, unsigned wndSmpCnt );
  176. cmRC_t cmFuncFilterFree( cmFuncFilter** pp );
  177. cmRC_t cmFuncFilterInit( cmFuncFilter* p, unsigned procSmpCnt, cmFuncFiltPtr_t funcPtr, void* userPtr, unsigned wndSmpCnt );
  178. cmRC_t cmFuncFilterFinal( cmFuncFilter* p );
  179. cmRC_t cmFuncFilterExec( cmFuncFilter* p, const cmSample_t* sp, unsigned sn );
  180. void cmFuncFilterTest();
  181. //------------------------------------------------------------------------------------------------------------
  182. typedef struct
  183. {
  184. cmObj obj;
  185. unsigned stateN; // count of states
  186. unsigned symN; // count of discrete observation symbols
  187. cmReal_t* initV; // initial state probability vector init[ stateN ]
  188. cmReal_t* transM; // transition probability matrix trans[ stateN (current), stateN (next) ]
  189. cmReal_t* stsM; // state to symbol prob. matrix stsM[ stateN, symN ]
  190. } cmDhmm;
  191. cmDhmm* cmDhmmAlloc( cmCtx* c, cmDhmm* p, unsigned stateN, unsigned symN, cmReal_t* initV, cmReal_t* transM, cmReal_t* stsM );
  192. cmRC_t cmDhmmFree( cmDhmm** pp );
  193. cmRC_t cmDhmmInit( cmDhmm* p, unsigned stateN, unsigned symN, cmReal_t* initV, cmReal_t* transM, cmReal_t* stsM );
  194. cmRC_t cmDhmmFinal( cmDhmm* p );
  195. cmRC_t cmDhmmExec( cmDhmm* p );
  196. cmRC_t cmDhmmGenObsSequence( cmDhmm* p, unsigned* dbp, unsigned dn );
  197. cmRC_t cmDhmmForwardEval( cmDhmm* p, const cmReal_t* statePrV, const unsigned* obsV, unsigned obsN, cmReal_t* alphaM, unsigned flags, cmReal_t* logProbPtr );
  198. cmRC_t cmDhmmReport( cmDhmm* p );
  199. void cmDhmmTest();
  200. //------------------------------------------------------------------------------------------------------------
  201. typedef struct
  202. {
  203. cmObj obj;
  204. cmFftSR* fft;
  205. cmIFftRS* ifft;
  206. cmComplexR_t* H;
  207. unsigned hn;
  208. cmSample_t* olaV; // olaV[hn-1];
  209. cmSample_t* outV; // outV[procSmpCnt]
  210. unsigned outN; // outN == procSmpCnt
  211. } cmConvolve;
  212. // After cmConvolveExec() outV[outN] contains the first outN samples
  213. // which are complete and can be used by the application.
  214. // The tail of the convolution is held in olaV[hn-1] and will
  215. // be automatically summed with the beginning of the next convolution
  216. // frame.
  217. // BUG BUG BUG
  218. // This code seems to have a problem when hn != procSmpCnt (or maybe hn > procSmpCnt ???).
  219. // See mas/main.c convolve() where procSmpCnt must be set to wndSmpCnt size or
  220. // only the first half of the window is emitted.
  221. // h[hn] is the impulse response to convolve with
  222. cmConvolve* cmConvolveAlloc( cmCtx* c, cmConvolve* p, const cmSample_t* h, unsigned hn, unsigned procSmpCnt );
  223. cmRC_t cmConvolveFree( cmConvolve** pp );
  224. cmRC_t cmConvolveInit( cmConvolve* p, const cmSample_t* h, unsigned hn, unsigned procSmpCnt );
  225. cmRC_t cmConvolveFinal( cmConvolve* p );
  226. // xn must be <= procSmpCnt
  227. cmRC_t cmConvolveExec( cmConvolve* p, const cmSample_t* x, unsigned xn );
  228. cmRC_t cmConvolveSignal( cmCtx* c, const cmSample_t* h, unsigned hn, const cmSample_t* x, unsigned xn, cmSample_t* y, unsigned yn );
  229. cmRC_t cmConvolveTest( cmRpt_t* rpt, cmLHeapH_t lhH, cmSymTblH_t stH );
  230. //------------------------------------------------------------------------------------------------------------
  231. typedef struct
  232. {
  233. cmObj obj;
  234. cmReal_t* dctMtx; // dctMtx[ binCnt, bandCnt ]
  235. cmReal_t* filtMask; // filtMask[ bandCnt, bandCnt ]
  236. unsigned binCnt; // bin cnt of input magnitude spectrum
  237. unsigned bandCnt; // must be <= kDefaultBarkBandCnt
  238. cmReal_t* outV; // outV[binCnt]
  239. } cmBfcc;
  240. cmBfcc* cmBfccAlloc( cmCtx* ctx, cmBfcc* p, unsigned bandCnt, unsigned binCnt, double binHz );
  241. cmRC_t cmBfccFree( cmBfcc** pp );
  242. cmRC_t cmBfccInit( cmBfcc* p, unsigned bandCnt, unsigned binCnt, double binHz );
  243. cmRC_t cmBfccFinal( cmBfcc* p );
  244. cmRC_t cmBfccExec( cmBfcc* p, const cmReal_t* magV, unsigned binCnt );
  245. void cmBfccTest( cmRpt_t* rpt, cmLHeapH_t lhH, cmSymTblH_t stH );
  246. //------------------------------------------------------------------------------------------------------------
  247. typedef struct
  248. {
  249. cmObj obj;
  250. //cmIFftRR ft;
  251. unsigned dct_cn; // (binCnt-1)*2
  252. cmReal_t* dctM; // dctM[ outN, dct_cn ]
  253. unsigned binCnt; // bin cnt of input magnitude spectrum
  254. unsigned outN; // count of cepstral coeff's
  255. cmReal_t* outV; // outV[outN]
  256. } cmCeps;
  257. // outN is the number of cepstral coeff's in the output vector
  258. cmCeps* cmCepsAlloc( cmCtx* ctx, cmCeps* p, unsigned binCnt, unsigned outN );
  259. cmRC_t cmCepsFree( cmCeps** pp );
  260. cmRC_t cmCepsInit( cmCeps* p, unsigned binCnt, unsigned outN );
  261. cmRC_t cmCepsFinal( cmCeps* p );
  262. cmRC_t cmCepsExec( cmCeps* p, const cmReal_t* magV, const cmReal_t* phsV, unsigned binCnt );
  263. //------------------------------------------------------------------------------------------------------------
  264. typedef struct
  265. {
  266. cmObj obj;
  267. cmWndFunc wf;
  268. unsigned wndSmpCnt;
  269. unsigned hopSmpCnt;
  270. unsigned procSmpCnt;
  271. cmSample_t* bufV; // bufV[wndSmpCnt] overlap add buffer
  272. cmSample_t* outV; // outV[hopSmpCnt] output vector
  273. cmSample_t* outPtr; // outPtr[procSmpCnt] output vector
  274. unsigned idx; // idx of next val in bufV[] to be moved to outV[]
  275. } cmOla;
  276. // hopSmpCnt must be <= wndSmpCnt.
  277. // hopSmpCnt must be an even multiple of procSmpCnt.
  278. // Call cmOlaExecR() or cmOlaExecS() at the spectral frame rate.
  279. // Call cmOlaExecOut() at the time domain audio frame rate.
  280. // Set wndTypeId to one of the cmWndFuncXXX enumerated widnow type id's.
  281. cmOla* cmOlaAlloc( cmCtx* ctx, cmOla* p, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned procSmpCnt, unsigned wndTypeId );
  282. cmRC_t cmOlaFree( cmOla** pp );
  283. cmRC_t cmOlaInit( cmOla* p, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned procSmpCnt, unsigned wndTypeId );
  284. cmRC_t cmOlaFinal( cmOla* p );
  285. cmRC_t cmOlaExecS( cmOla* p, const cmSample_t* xV, unsigned xN );
  286. cmRC_t cmOlaExecR( cmOla* p, const cmReal_t* xV, unsigned xN );
  287. const cmSample_t* cmOlaExecOut(cmOla* p );
  288. //------------------------------------------------------------------------------------------------------------
  289. typedef struct
  290. {
  291. cmObj obj;
  292. cmReal_t* hzV; // hzV[binCnt] output vector - frequency in Hertz
  293. cmReal_t* phsV; // phsV[binCnt]
  294. cmReal_t* wV; // bin freq in rads/hop
  295. double srate;
  296. unsigned hopSmpCnt;
  297. unsigned binCnt;
  298. } cmPhsToFrq;
  299. cmPhsToFrq* cmPhsToFrqAlloc( cmCtx* c, cmPhsToFrq* p, double srate, unsigned binCnt, unsigned hopSmpCnt );
  300. cmRC_t cmPhsToFrqFree( cmPhsToFrq** p );
  301. cmRC_t cmPhsToFrqInit( cmPhsToFrq* p, double srate, unsigned binCnt, unsigned hopSmpCnt );
  302. cmRC_t cmPhsToFrqFinal(cmPhsToFrq* p );
  303. cmRC_t cmPhsToFrqExec( cmPhsToFrq* p, const cmReal_t* phsV );
  304. //------------------------------------------------------------------------------------------------------------
  305. enum
  306. {
  307. kNoCalcHzPvaFl = 0x00,
  308. kCalcHzPvaFl = 0x01
  309. };
  310. typedef struct
  311. {
  312. cmObj obj;
  313. cmShiftBuf sb;
  314. cmFftSR ft;
  315. cmWndFunc wf;
  316. cmPhsToFrq pf;
  317. unsigned flags;
  318. unsigned procSmpCnt;
  319. double srate;
  320. unsigned wndSmpCnt;
  321. unsigned hopSmpCnt;
  322. unsigned binCnt;
  323. const cmReal_t* magV; // amplitude NOT power
  324. const cmReal_t* phsV;
  325. const cmReal_t* hzV;
  326. } cmPvAnl;
  327. cmPvAnl* cmPvAnlAlloc( cmCtx* ctx, cmPvAnl* p, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned flags );
  328. cmRC_t cmPvAnlFree( cmPvAnl** pp );
  329. cmRC_t cmPvAnlInit( cmPvAnl* p, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned flags );
  330. cmRC_t cmPvAnlFinal(cmPvAnl* p );
  331. // Returns true when a new spectrum has been computed
  332. bool cmPvAnlExec( cmPvAnl* p, const cmSample_t* x, unsigned xN );
  333. //------------------------------------------------------------------------------------------------------------
  334. typedef struct
  335. {
  336. cmObj obj;
  337. cmIFftRS ft;
  338. cmWndFunc wf;
  339. cmOla ola;
  340. cmReal_t* minRphV;
  341. cmReal_t* maxRphV;
  342. cmReal_t* itrV;
  343. cmReal_t* phs0V;
  344. cmReal_t* mag0V;
  345. cmReal_t* phsV;
  346. cmReal_t* magV;
  347. double outSrate;
  348. unsigned procSmpCnt;
  349. unsigned wndSmpCnt;
  350. unsigned hopSmpCnt;
  351. unsigned binCnt;
  352. } cmPvSyn;
  353. cmPvSyn* cmPvSynAlloc( cmCtx* ctx, cmPvSyn* p, unsigned procSmpCnt, double outSrate, unsigned wndSmpCnt, unsigned hopSmpCnt,unsigned wndTypeId );
  354. cmRC_t cmPvSynFree( cmPvSyn** pp );
  355. cmRC_t cmPvSynInit( cmPvSyn* p, unsigned procSmpCnt, double outSrate, unsigned wndSmpCnt, unsigned hopSmpCnt,unsigned wndTypeId );
  356. cmRC_t cmPvSynFinal(cmPvSyn* p );
  357. cmRC_t cmPvSynExec( cmPvSyn* p, const cmReal_t* magV, const cmReal_t* phsV );
  358. const cmSample_t* cmPvSynExecOut(cmPvSyn* p );
  359. //------------------------------------------------------------------------------------------------------------
  360. // callback selector values
  361. enum
  362. {
  363. kAttackMsId,
  364. kReleaseMsId,
  365. kDspMsId // return 0 if the voice is no longer active
  366. };
  367. // voice flags
  368. enum
  369. {
  370. kActiveMsFl = 0x01, // set if the voice is active
  371. kKeyGateMsFl = 0x02, // set if the key is down for this note
  372. };
  373. struct cmMidiSynth_str;
  374. struct cmMidiSynthCh_str;
  375. struct cmMidiVoice_str;
  376. // voice update callback - use voicePtr->pgm.cbDataPtr to get voice specific data
  377. typedef int (*cmMidiSynthCb_t)( struct cmMidiVoice_str* voicePtr, unsigned sel, cmSample_t* outChArray[], unsigned outChCnt );
  378. typedef struct
  379. {
  380. cmMidiByte_t pgm; // MIDI pgm number
  381. cmMidiSynthCb_t cbPtr; // voice update callback
  382. void* cbDataPtr; // user data pointer
  383. } cmMidiSynthPgm;
  384. typedef struct cmMidiVoice_str
  385. {
  386. unsigned index; // voice index
  387. unsigned flags; // see kXXXMsFl above
  388. cmMidiByte_t pitch; // note-on pitch
  389. cmMidiByte_t velocity; // note-on/off veloctiy
  390. cmMidiSynthPgm pgm; // pgm associated with this voice
  391. struct cmMidiSynthCh_str* chPtr; // pointer to owning ch
  392. struct cmMidiVoice_str* link; // link to next active/avail voice in chain
  393. } cmMidiVoice;
  394. typedef struct cmMidiSynthCh_str
  395. {
  396. cmMidiByte_t midiCtl[ kMidiCtlCnt ]; // current ctl values
  397. short pitchBend; // current pitch bend value
  398. cmMidiByte_t pgm; // last pgm received
  399. cmMidiVoice* active; // first active voice on this channel
  400. struct cmMidiSynth_str* synthPtr; // owning synth
  401. } cmMidiSynthCh;
  402. typedef struct cmMidiSynth_str
  403. {
  404. cmObj obj;
  405. cmMidiSynthCh chArray[ kMidiChCnt ]; // midi channel array
  406. unsigned voiceCnt; // count of voice records
  407. cmMidiVoice* avail; // avail voice chain
  408. unsigned activeVoiceCnt; // current count of active voices
  409. unsigned voiceStealCnt; // count of times voice stealing was required
  410. cmMidiVoice* voiceArray; // array of voice records
  411. cmMidiSynthPgm pgmArray[ kMidiPgmCnt ]; // array of pgm records
  412. unsigned procSmpCnt; // samples per DSP cycle
  413. unsigned outChCnt; // count of output channels
  414. cmSample_t* outM; // outM[ procSmpCnt, outChCnt ] output buffer
  415. cmSample_t** outChArray; // buffer of pointers to each output channel
  416. cmReal_t srate; // output signal sample rate
  417. } cmMidiSynth;
  418. cmMidiSynth* cmMidiSynthAlloc( cmCtx* ctx, cmMidiSynth* p, const cmMidiSynthPgm* pgmArray, unsigned pgmCnt, unsigned voiceCnt, unsigned procSmpCnt, unsigned outChCnt, cmReal_t srate );
  419. cmRC_t cmMidiSynthFree( cmMidiSynth** pp );
  420. cmRC_t cmMidiSynthInit( cmMidiSynth* p, const cmMidiSynthPgm* pgmArray, unsigned pgmCnt, unsigned voiceCnt, unsigned procSmpCnt, unsigned outChCnt, cmReal_t srate );
  421. cmRC_t cmMidiSynthFinal( cmMidiSynth* p );
  422. cmRC_t cmMidiSynthOnMidi(cmMidiSynth* p, const cmMidiPacket_t* pktArray, unsigned pktCnt );
  423. cmRC_t cmMidiSynthExec( cmMidiSynth* p, cmSample_t** outChArray, unsigned outChCnt );
  424. //------------------------------------------------------------------------------------------------------------
  425. // state id's
  426. enum
  427. {
  428. kOffWtId,
  429. kAtkWtId,
  430. kDcyWtId,
  431. kSusWtId,
  432. kRlsWtId
  433. };
  434. typedef struct
  435. {
  436. cmObj obj;
  437. cmReal_t hz; // current frq in Hz
  438. cmReal_t level; // current gain (0.0 to 1.0)
  439. cmReal_t phase; // osc phase (radians)
  440. unsigned durSmpCnt; // count of samples generated so far
  441. unsigned state; // osc state - see kXXXWtId above
  442. cmSample_t* outV; // signal output vector
  443. unsigned outN; // samples in outV[]
  444. } cmWtVoice;
  445. cmWtVoice* cmWtVoiceAlloc( cmCtx* ctx, cmWtVoice* p, unsigned procSmpCnt, cmReal_t hz );
  446. cmRC_t cmWtVoiceFree( cmWtVoice** pp );
  447. cmRC_t cmWtVoiceInit( cmWtVoice* p, unsigned procSmpCnt, cmReal_t hz );
  448. cmRC_t cmWtVoiceFinal( cmWtVoice* p );
  449. // 'sel' values are cmMidiSynthExec (kXXXMsId) values
  450. // Set outChArray[] to NULL to use internal audio buffer.
  451. int cmWtVoiceExec( cmWtVoice* p, struct cmMidiVoice_str* voicePtr, unsigned sel, cmSample_t* outChArray[], unsigned outChCnt );
  452. //------------------------------------------------------------------------------------------------------------
  453. typedef struct
  454. {
  455. cmObj obj;
  456. cmWtVoice** voiceArray; // osc state array
  457. unsigned voiceCnt;
  458. cmSample_t* buf;
  459. cmSample_t** chArray;
  460. unsigned chCnt;
  461. unsigned procSmpCnt; // count of samples in each chArray[i] sample vector
  462. double srate; // synth sample rate
  463. } cmWtVoiceBank;
  464. cmWtVoiceBank* cmWtVoiceBankAlloc( cmCtx* ctx, cmWtVoiceBank* p, double srate, unsigned procSmpCnt, unsigned voiceCnt, unsigned chCnt );
  465. cmRC_t cmWtVoiceBankFree( cmWtVoiceBank** pp );
  466. cmRC_t cmWtVoiceBankInit( cmWtVoiceBank* p, double srate, unsigned procSmpCnt, unsigned voiceCnt, unsigned chCnt );
  467. cmRC_t cmWtVoiceBankFinal( cmWtVoiceBank* p );
  468. // 'sel' values are cmMidiSynthExec (kXXXMsId) values
  469. // Set outChArray[] to NULL to use internal audio buffer.
  470. // Return 0 if the voice has gone inactive otherwise return 1.
  471. int cmWtVoiceBankExec( cmWtVoiceBank* p, struct cmMidiVoice_str* voicePtr, unsigned sel, cmSample_t* chArray[], unsigned chCnt );
  472. //------------------------------------------------------------------------------------------------------------
  473. typedef struct
  474. {
  475. cmObj obj;
  476. cmSample_t* bufV; // bufV[ bufN ]
  477. unsigned bufN;
  478. cmAudioFileInfo_t info;
  479. unsigned begSmpIdx;
  480. unsigned chIdx;
  481. char* fn;
  482. } cmAudioFileBuf;
  483. // set 'durSmpCnt' to cmInvalidCnt to include all samples to the end of the file
  484. cmAudioFileBuf* cmAudioFileBufAlloc( cmCtx* ctx, cmAudioFileBuf* p, unsigned procSmpCnt, const char* fn, unsigned chIdx, unsigned begSmpIdx, unsigned durSmpCnt );
  485. cmRC_t cmAudioFileBufFree( cmAudioFileBuf** pp );
  486. cmRC_t cmAudioFileBufInit( cmAudioFileBuf* p, unsigned procSmpCnt, const char* fn, unsigned chIdx, unsigned begSmpIdx, unsigned durSmpCnt );
  487. cmRC_t cmAudioFileBufFinal(cmAudioFileBuf* p );
  488. // Returns the count of samples copied into outV or 0 if smpIdx >= p->bufN.
  489. // If less than outN samples are available then the remaining samples are set to 0.
  490. unsigned cmAudioFileBufExec( cmAudioFileBuf* p, unsigned smpIdx, cmSample_t* outV, unsigned outN, bool sumIntoOutFl );
  491. //------------------------------------------------------------------------------------------------------------
  492. // Multi-delay. Each of the taps of this delay operates as a independent delay with feedback.
  493. // Delay line specification.
  494. typedef struct
  495. {
  496. cmReal_t delayGain; // delay gain
  497. cmReal_t delayMs; // delay time in milliseconds
  498. cmReal_t delaySmpFrac; // delay time in samples (next fractional delay index = inIdx - delaySmpFrac)
  499. cmSample_t* delayBuf; // delayBuf[delayBufSmpCnt] delay line memory
  500. int delayBufSmpCnt; // delay buffer length in samples
  501. int inIdx; // next delay input index
  502. } cmMDelayHead;
  503. typedef struct
  504. {
  505. cmObj obj;
  506. unsigned delayCnt; // count of taps
  507. cmMDelayHead* delayArray; // tap specs
  508. cmSample_t* outV; // outV[outN] output buffer
  509. unsigned outN; // procSmpCnt
  510. cmReal_t fbCoeff; // feedback coeff.
  511. cmReal_t srate; // system sample rate
  512. } cmMDelay;
  513. cmMDelay* cmMDelayAlloc( cmCtx* ctx, cmMDelay* p, unsigned procSmpCnt, cmReal_t srate, cmReal_t fbCoeff, unsigned delayCnt, const cmReal_t* delayMsArray, const cmReal_t* delayGainArray );
  514. cmRC_t cmMDelayFree( cmMDelay** pp );
  515. cmRC_t cmMDelayInit( cmMDelay* p, unsigned procSmpCnt, cmReal_t srate, cmReal_t fbCoeff, unsigned delayCnt, const cmReal_t* delayMsArray, const cmReal_t* delayGainArray );
  516. cmRC_t cmMDelayFinal( cmMDelay* p );
  517. cmRC_t cmMDelayExec( cmMDelay* p, const cmSample_t* sigV, cmSample_t* outV, unsigned sigN, bool bypassFl );
  518. void cmMDelaySetTapMs( cmMDelay* p, unsigned tapIdx, cmReal_t ms );
  519. void cmMDelaySetTapGain(cmMDelay* p, unsigned tapIdx, cmReal_t gain );
  520. void cmMDelayReport( cmMDelay* p, cmRpt_t* rpt );
  521. //------------------------------------------------------------------------------------------------------------
  522. enum
  523. {
  524. kEnableAspFl = 0x01,
  525. kDelAspFl = 0x02
  526. };
  527. typedef struct cmAudioSeg_str
  528. {
  529. cmAudioFileBuf* bufPtr; // pointer to the audio file buffer this segment is contained in
  530. unsigned id; // id (unique amoung segments)
  531. unsigned smpIdx; // offset into audioBuf[] of first sample
  532. unsigned smpCnt; // total count of samples to play
  533. unsigned outChIdx; // output buffer channel
  534. unsigned outSmpIdx; // outSmpIdx + smpIdx == next sample to play
  535. unsigned flags; // see kXXXAspFl
  536. } cmAudioSeg;
  537. typedef struct
  538. {
  539. cmObj obj;
  540. unsigned segCnt;
  541. cmAudioSeg* segArray;
  542. unsigned procSmpCnt;
  543. cmSample_t** outChArray;
  544. unsigned outChCnt;
  545. cmSample_t* outM;
  546. } cmAudioSegPlayer;
  547. cmAudioSegPlayer* cmAudioSegPlayerAlloc( cmCtx* ctx, cmAudioSegPlayer* p, unsigned procSmpCnt, unsigned outChCnt );
  548. cmRC_t cmAudioSegPlayerFree( cmAudioSegPlayer** pp );
  549. cmRC_t cmAudioSegPlayerInit( cmAudioSegPlayer* p, unsigned procSmpCnt, unsigned outChCnt );
  550. cmRC_t cmAudioSegPlayerFinal( cmAudioSegPlayer* p );
  551. cmRC_t cmAudioSegPlayerInsert( cmAudioSegPlayer* p, unsigned id, cmAudioFileBuf* bufPtr, unsigned smpIdx, unsigned smpCnt, unsigned outChIdx );
  552. cmRC_t cmAudioSegPlayerEdit( cmAudioSegPlayer* p, unsigned id, cmAudioFileBuf* bufPtr, unsigned smpIdx, unsigned smpCnt, unsigned outChIdx );
  553. cmRC_t cmAudioSegPlayerRemove( cmAudioSegPlayer* p, unsigned id, bool delFl );
  554. cmRC_t cmAudioSegPlayerEnable( cmAudioSegPlayer* p, unsigned id, bool enableFl, unsigned outSmpIdx );
  555. cmRC_t cmAudioSegPlayerReset( cmAudioSegPlayer* p );
  556. cmRC_t cmAudioSegPlayerExec( cmAudioSegPlayer* p, cmSample_t** outChPtr, unsigned chCnt, unsigned outSmpCnt );
  557. //------------------------------------------------------------------------------------------------------------
  558. /*
  559. cmReal_t (*cmCluster0DistFunc_t)( void* userPtr, const cmReal_t* v0, const cmReal_t* v1, unsigned binCnt );
  560. typedef struct
  561. {
  562. cmObj obj;
  563. unsigned flags;
  564. unsigned stateCnt;
  565. unsigned binCnt;
  566. cmReal_t* oM; // oM[ binCnt, stateCnt ]
  567. unsigned* tM; // tM[ stateCnt, stateCnt ]
  568. cmReal_t* dV; // dV[ state
  569. cmCluster0DistFunc_t distFunc;
  570. void* distUserPtr;
  571. unsigned cnt;
  572. } cmCluster0;
  573. enum
  574. {
  575. kCalcTransFl = 0x01,
  576. kCalcDurFl = 0x02
  577. };
  578. cmCluster0* cmCluster0Alloc( cmCtx* ctx, cmCluster0* ap, unsigned stateCnt, unsigned binCnt, unsigned flags, cmCluster0DistFunc_t distFunc, void* dstUserPtr );
  579. cmRC_t cmCluster0Free( cmCluster0** pp );
  580. cmRC_t cmCluster0Init( cmCluster0* p, unsigned stateCnt, unsigned binCnt, unsigned flags, cmCluster0DistFunc_t distFunc, void* dstUserPtr );
  581. cmRC_t cmCluster0Final( cmCluster0* p );
  582. cmRC_t cmCluster0Exec( cmCluster0* p, const cmReal_t* v, unsigned vn );
  583. */
  584. //------------------------------------------------------------------------------------------------------------
  585. typedef struct
  586. {
  587. cmObj obj;
  588. unsigned n;
  589. unsigned m;
  590. unsigned r;
  591. unsigned maxIterCnt;
  592. unsigned convergeCnt;
  593. cmReal_t* V; // V[n,m]
  594. cmReal_t* W; // W[n,r]
  595. cmReal_t* H; // H[r,m]
  596. cmReal_t* tr;
  597. cmReal_t* x;
  598. cmReal_t* t0nm;
  599. cmReal_t* t1nm;
  600. cmReal_t* Wt;
  601. cmReal_t* Ht;
  602. cmReal_t* trm;
  603. unsigned* crm;
  604. cmReal_t* tnr;
  605. unsigned* c0;
  606. unsigned* c1;
  607. unsigned* c0m;
  608. unsigned* c1m;
  609. unsigned* idxV;
  610. } cmNmf_t;
  611. cmNmf_t* cmNmfAlloc( cmCtx* ctx, cmNmf_t* ap, unsigned n, unsigned m, unsigned r, unsigned maxIterCnt, unsigned convergeCnt );
  612. cmRC_t cmNmfFree( cmNmf_t** pp );
  613. cmRC_t cmNmfInit( cmNmf_t* p, unsigned n, unsigned m, unsigned r, unsigned maxIterCnt, unsigned convergeCnt );
  614. cmRC_t cmNmfFinal(cmNmf_t* p );
  615. //
  616. cmRC_t cmNmfExec( cmNmf_t* p, const cmReal_t* v, unsigned cn );
  617. //------------------------------------------------------------------------------------------------------------
  618. // cmVectArray buffers row vectors of arbitrary lenght in memory.
  619. // The buffers may then be access using the cmVectArrayGetXXX() functions.
  620. // The entire contents of the file may be written to a file using atVectArrayWrite().
  621. // The file may then be read in back into memory using cmVectArrayAllocFromFile()
  622. // or in octave via readVectArray.m.
  623. // A rectantular matrix in memory may be written to a VectArray file in one operation
  624. // via the function cmVectArrayWriteMatrixXXX().
  625. typedef struct cmVectArrayVect_str
  626. {
  627. unsigned n; // length of this vector in values (not bytes)
  628. union
  629. {
  630. char* v; // raw memory vector pointer
  631. double* dV; // dV[n] vector of doubles
  632. float* fV; // fV[n] vecotr of floats
  633. cmSample_t* sV; // sV[n] vector of cmSample_t
  634. } u;
  635. struct cmVectArrayVect_str* link; // link to next element record
  636. } cmVectArrayVect_t;
  637. enum
  638. {
  639. kFloatVaFl = 0x01,
  640. kDoubleVaFl = 0x02,
  641. kSampleVaFl = 0x04,
  642. kRealVaFl = 0x08,
  643. kIntVaFl = 0x02, // int and uint is converted to double
  644. kUIntVaFl = 0x02 //
  645. };
  646. typedef struct
  647. {
  648. cmObj obj;
  649. cmVectArrayVect_t* bp; // first list element
  650. cmVectArrayVect_t* ep; // last list element
  651. unsigned vectCnt; // count of elements in linked list
  652. unsigned flags; // data vector type (See: kFloatVaFl, kDoubleVaFl, ... )
  653. unsigned typeByteCnt; // size of a single data vector value (e.g. 4=float 8=double)
  654. unsigned maxEleCnt; // length of the longest data vector
  655. double* tempV;
  656. cmVectArrayVect_t* cur;
  657. } cmVectArray_t;
  658. // Flags must be set to one of the kXXXVAFl flag values.
  659. cmVectArray_t* cmVectArrayAlloc( cmCtx* ctx, unsigned flags );
  660. cmVectArray_t* cmVectArrayAllocFromFile(cmCtx* ctx, const char* fn );
  661. cmRC_t cmVectArrayFree( cmVectArray_t** pp );
  662. // Release all the stored vectors but do not release the object.
  663. cmRC_t cmVectArrayClear( cmVectArray_t* p );
  664. // Return the count of vectors contained in the vector array.
  665. cmRC_t cmVectArrayCount( const cmVectArray_t* p );
  666. // Store a new vector by appending it to the end of the internal vector list.
  667. cmRC_t cmVectArrayAppendS( cmVectArray_t* p, const cmSample_t* v, unsigned vn );
  668. cmRC_t cmVectArrayAppendR( cmVectArray_t* p, const cmReal_t* v, unsigned vn );
  669. cmRC_t cmVectArrayAppendF( cmVectArray_t* p, const float* v, unsigned vn );
  670. cmRC_t cmVectArrayAppendD( cmVectArray_t* p, const double* v, unsigned vn );
  671. cmRC_t cmVectArrayAppendI( cmVectArray_t* p, const int* v, unsigned vn );
  672. cmRC_t cmVectArrayAppendU( cmVectArray_t* p, const unsigned* v, unsigned vn );
  673. // Write a vector array in a format that can be read by readVectArray.m.
  674. cmRC_t cmVectArrayWrite( cmVectArray_t* p, const char* fn );
  675. typedef cmRC_t (*cmVectArrayForEachFuncS_t)( void* arg, unsigned idx, const cmSample_t* xV, unsigned xN );
  676. unsigned cmVectArrayForEachS( cmVectArray_t* p, unsigned idx, unsigned cnt, cmVectArrayForEachFuncS_t func, void* arg );
  677. cmRC_t cmVectArrayWriteVectorS( cmCtx* ctx, const char* fn, const cmSample_t* v, unsigned vn );
  678. cmRC_t cmVectArrayWriteVectorI( cmCtx* ctx, const char* fn, const int* v, unsigned vn );
  679. // Write the column-major matrix m[rn,cn] to the file 'fn'. Note that the matrix is transposed as it is
  680. // written and therefore will be read back as a 'cn' by 'rn' matrix.
  681. cmRC_t cmVectArrayWriteMatrixS( cmCtx* ctx, const char* fn, const cmSample_t* m, unsigned rn, unsigned cn );
  682. cmRC_t cmVectArrayWriteMatrixR( cmCtx* ctx, const char* fn, const cmReal_t* m, unsigned rn, unsigned cn );
  683. cmRC_t cmVectArrayWriteMatrixI( cmCtx* ctx, const char* fn, const int* m, unsigned rn, unsigned cn );
  684. cmRC_t cmVectArrayRewind( cmVectArray_t* p );
  685. cmRC_t cmVectArrayAdvance( cmVectArray_t* p, unsigned n );
  686. bool cmVectArrayIsEOL( const cmVectArray_t* p );
  687. unsigned cmVectArrayEleCount( const cmVectArray_t* p );
  688. cmRC_t cmVectArrayGetF( cmVectArray_t* p, float* v, unsigned* vnRef );
  689. cmRC_t cmVectArrayGetD( cmVectArray_t* p, double* v, unsigned* vnRef );
  690. cmRC_t cmVectArrayGetI( cmVectArray_t* p, int* v, unsigned* vnRef );
  691. cmRC_t cmVectArrayGetU( cmVectArray_t* p, unsigned* v, unsigned* vnRef );
  692. // If a vector array is composed of repeating blocks of 'groupCnt' sub-vectors
  693. // where the concatenated ith sub-vectors in each group form a single super-vector then
  694. // this function will return the super-vector. Use cmMemFree(*vRef) to release
  695. // the returned super-vector.
  696. cmRC_t cmVectArrayFormVectF( cmVectArray_t* p, unsigned groupIdx, unsigned groupCnt, float** vRef, unsigned* vnRef );
  697. cmRC_t cmVectArrayFormVectColF( cmVectArray_t* p, unsigned groupIdx, unsigned groupCnt, unsigned colIdx, float** vRef, unsigned* vnRef );
  698. cmRC_t cmVectArrayFormVectColU( cmVectArray_t* p, unsigned groupIdx, unsigned groupCnt, unsigned colIdx, unsigned** vRef, unsigned* vnRef );
  699. cmRC_t cmVectArrayTest( cmCtx* ctx, const char* fn );
  700. #if CM_FLOAT_SMP == 1
  701. #define cmVectArrayGetS cmVectArrayGetF
  702. #define cmVectArrayFormVectS cmVectArrayFormVectF
  703. #else
  704. #define cmVectArrayGetS cmVectArrayGetD
  705. #define cmVectArrayFormVectS cmVectArrayFormVectD
  706. #endif
  707. //-----------------------------------------------------------------------------------------------------------------------
  708. // Spectral whitening filter.
  709. // Based on: Klapuri, A., 2006: Multiple fundamental frequency estimation by summing
  710. // harmonic amplitudes.
  711. typedef struct
  712. {
  713. cmObj obj;
  714. unsigned binCnt; //
  715. cmReal_t binHz; //
  716. unsigned bandCnt; //
  717. cmReal_t coeff; //
  718. cmReal_t* whiV; // whiV[bandCnt+2] - fractional bin index of each center frequency
  719. cmReal_t* whM; // whM[binCnt,bandCnt]
  720. cmReal_t* iV; // iV[ binCnt ] - working memory
  721. } cmWhFilt;
  722. cmWhFilt* cmWhFiltAlloc( cmCtx* c, cmWhFilt* p, unsigned binCnt, cmReal_t binHz, cmReal_t coeff, cmReal_t maxHz );
  723. cmRC_t cmWhFiltFree( cmWhFilt** pp );
  724. cmRC_t cmWhFiltInit( cmWhFilt* p, unsigned binCnt, cmReal_t binHz, cmReal_t coeff, cmReal_t maxHz );
  725. cmRC_t cmWhFiltFinal( cmWhFilt* p );
  726. cmRC_t cmWhFiltExec( cmWhFilt* p, const cmReal_t* xV, cmReal_t* yV, unsigned xyN );
  727. //-----------------------------------------------------------------------------------------------------------------------
  728. typedef enum
  729. {
  730. kNoStateFrqTrkId,
  731. kDlyFrqTrkId,
  732. kAtkFrqTrkId,
  733. kSusFrqTrkId,
  734. kDcyFrqTrkId
  735. } cmFrqTrkAttenStateId_t;
  736. typedef struct
  737. {
  738. double srate; // system sample rate
  739. unsigned chCnt; // tracking channel count
  740. unsigned binCnt; // count of spectrum elements passed in each call to cmFrqTrkExec()
  741. unsigned hopSmpCnt; // phase vocoder hop count in samples
  742. cmReal_t stRange; // maximum allowable semi-tones between a tracker and a peak
  743. cmReal_t wndSecs; // duration of the
  744. cmReal_t minTrkSec; // minimum track length before track is considered stable
  745. cmReal_t maxTrkDeadSec; // maximum length of time a tracker may fail to connect to a peak before being declared disconnected.
  746. cmReal_t pkThreshDb; // minimum amplitide in Decibels of a selected spectral peak.
  747. cmReal_t pkAtkThreshDb; // minimum amplitude in Decibels for the first frame of a new track.
  748. cmReal_t pkMaxHz; // maximum frequency to track
  749. cmReal_t whFiltCoeff;
  750. cmReal_t attenThresh;
  751. cmReal_t attenGain;
  752. cmReal_t attenDlySec;
  753. cmReal_t attenAtkSec;
  754. const char* logFn; // log file name or NULL if no file is to be written
  755. const char* levelFn; // level file name or NULL if no file is to be written
  756. const char* specFn; // spectrum file name or NULL if no file is to be written
  757. const char* attenFn;
  758. } cmFrqTrkArgs_t;
  759. typedef struct
  760. {
  761. bool activeFl;
  762. unsigned id;
  763. unsigned tN; // age of this track in frames
  764. unsigned dN; // count of consecutive times this ch has not connected
  765. cmReal_t hz; // current center frequency
  766. cmReal_t db; // current magnitude
  767. cmReal_t* dbV; // dbV[]
  768. cmReal_t* hzV; // hzV[]
  769. unsigned si;
  770. unsigned sn;
  771. cmReal_t db_mean;
  772. cmReal_t db_std;
  773. cmReal_t hz_mean;
  774. cmReal_t hz_std;
  775. cmReal_t score;
  776. cmFrqTrkAttenStateId_t state;
  777. int attenPhsIdx;
  778. cmReal_t attenGain;
  779. } cmFrqTrkCh_t;
  780. struct cmBinMtxFile_str;
  781. typedef struct cmFrqTrk_str
  782. {
  783. cmObj obj;
  784. cmFrqTrkArgs_t a;
  785. cmFrqTrkCh_t* ch; // ch[ a.chCnt ]
  786. unsigned hN; // count of magnitude buffer frames
  787. unsigned sN; // count of frames in channel statistics buffers
  788. unsigned bN; // count of bins in peak matrices
  789. cmReal_t* dbM; // dbM[ hN, bN ]
  790. unsigned hi; // next row of dbM to fill
  791. unsigned fN; // total count of frames processed.
  792. cmReal_t binHz;
  793. cmReal_t* dbV;
  794. unsigned* pkiV;
  795. unsigned deadN_max; // max. count of hops a tracker may fail to connect before being set to inactive
  796. unsigned minTrkN; // minimum track length in hops
  797. unsigned nextTrkId;
  798. unsigned newTrkCnt;
  799. unsigned curTrkCnt;
  800. unsigned deadTrkCnt;
  801. cmReal_t* aV;
  802. int attenDlyPhsMax;
  803. int attenPhsMax;
  804. cmWhFilt* wf;
  805. cmVectArray_t* logVa;
  806. cmVectArray_t* levelVa;
  807. cmVectArray_t* specVa;
  808. cmVectArray_t* attenVa;
  809. cmChar_t* logFn;
  810. cmChar_t* levelFn;
  811. cmChar_t* specFn;
  812. cmChar_t* attenFn;
  813. } cmFrqTrk;
  814. //
  815. // 1. Calculate the mean spectral magnitude profile over the last hN frames.
  816. // 2. Locate the peaks in the profile.
  817. // 3. Allow each active tracker to select the closest peak to extend its life.
  818. // a) The distance between the trackers current location and a given
  819. // peak is measured based on magnitude and frequency over time.
  820. // b) There is a frequency range limit outside of which a given track-peak
  821. // connection may not go.
  822. // c) There is an amplitude threshold below which a track may not fall.
  823. cmFrqTrk* cmFrqTrkAlloc( cmCtx* c, cmFrqTrk* p, const cmFrqTrkArgs_t* a );
  824. cmRC_t cmFrqTrkFree( cmFrqTrk** pp );
  825. cmRC_t cmFrqTrkInit( cmFrqTrk* p, const cmFrqTrkArgs_t* a );
  826. cmRC_t cmFrqTrkFinal( cmFrqTrk* p );
  827. cmRC_t cmFrqTrkExec( cmFrqTrk* p, const cmReal_t* magV, const cmReal_t* phsV, const cmReal_t* hzV );
  828. void cmFrqTrkPrint( cmFrqTrk* p );
  829. //------------------------------------------------------------------------------------------------------------
  830. typedef struct
  831. {
  832. double srate;
  833. unsigned binCnt;
  834. unsigned hopSmpCnt;
  835. unsigned bufMs;
  836. cmReal_t maxHz;
  837. } cmFbCtlArgs_t;
  838. typedef struct
  839. {
  840. cmObj obj;
  841. cmFbCtlArgs_t a;
  842. unsigned binCnt;
  843. unsigned frmCnt;
  844. cmReal_t* bM; // bM[ frmCnt, binCnt ];
  845. unsigned bfi; // current buffer frame (column) index
  846. unsigned bfN; // currrent count of frames in the buffer
  847. cmReal_t* rmsV; // rmsV[ frmCnt ];
  848. cmReal_t* sV; // sV[ binCnt ]
  849. cmReal_t* uV;
  850. cmVectArray_t* sva;
  851. cmVectArray_t* uva;
  852. } cmFbCtl_t;
  853. cmFbCtl_t* cmFbCtlAlloc( cmCtx* c, cmFbCtl_t* p, const cmFbCtlArgs_t* a );
  854. cmRC_t cmFbCtlFree( cmFbCtl_t** pp );
  855. cmRC_t cmFbCtlInit( cmFbCtl_t* p, const cmFbCtlArgs_t* a );
  856. cmRC_t cmFbCtlFinal(cmFbCtl_t* p );
  857. cmRC_t cmFbCtlExec( cmFbCtl_t* p, const cmReal_t* xV );
  858. //------------------------------------------------------------------------------------------------------------
  859. enum
  860. {
  861. kBypassModeSdId, // 0 - no effect
  862. kBasicModeSdId, // 1 - fixed thresh
  863. kSpecCentSdId, // 2 - thresh = max magn - (offset * spec_cent)
  864. kAmpEnvSdId, // 3 - thresh = max magn - offset
  865. kBumpSdId,
  866. kModeSdCnt
  867. };
  868. typedef struct
  869. {
  870. cmObj obj;
  871. double srate;
  872. unsigned wndSmpCnt;
  873. unsigned hopFcmt;
  874. unsigned hopSmpCnt;
  875. unsigned procSmpCnt;
  876. cmPvAnl* pva;
  877. cmPvSyn* pvs;
  878. cmFrqTrk* ft;
  879. cmFbCtl_t* fbc;
  880. unsigned mode;
  881. double thresh;
  882. double uprSlope;
  883. double lwrSlope;
  884. double offset;
  885. bool invertFl;
  886. double spcBwHz; // spectral centroid bandwidth in Hz
  887. double spcSmArg; // spectral centroid smoothing
  888. double spcMin;
  889. double spcMax;
  890. unsigned spcBinCnt; // count of bins used in the spectral centroid
  891. cmReal_t* hzV; // hzV[spcBinCnt];
  892. cmReal_t spc;
  893. unsigned spcCnt;
  894. cmReal_t spcSum;
  895. cmReal_t spcSqSum;
  896. cmReal_t aeSmMax; // smoothed max bin magn - used by spectral centroid
  897. cmReal_t aeSmOffs; // smoothed offset
  898. cmReal_t ae;
  899. cmReal_t aeMin;
  900. cmReal_t aeMax;
  901. cmReal_t aeUnit;
  902. cmReal_t ogain;
  903. unsigned phaseModIndex;
  904. unsigned fi; // total count of frames processed by cmSpecDistExec()
  905. unsigned hN;
  906. unsigned hi;
  907. cmReal_t* iSpecM; // iSpecMtx[hN binN]
  908. cmReal_t* iSpecV; // mean of rows of iSpecM
  909. cmVectArray_t* iSpecVa;
  910. cmReal_t* oSpecM; // oSpecMtx[hN binN]
  911. cmReal_t* oSpecV; // mean of rows of oSpecM
  912. cmVectArray_t* oSpecVa;
  913. } cmSpecDist_t;
  914. cmSpecDist_t* cmSpecDistAlloc( cmCtx* ctx,cmSpecDist_t* ap, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopFcmt, unsigned olaWndTypeId );
  915. cmRC_t cmSpecDistFree( cmSpecDist_t** pp );
  916. cmRC_t cmSpecDistInit( cmSpecDist_t* p, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopFcmt, unsigned olaWndTypeId );
  917. cmRC_t cmSpecDistFinal(cmSpecDist_t* p );
  918. cmRC_t cmSpecDistExec( cmSpecDist_t* p, const cmSample_t* sp, unsigned sn );
  919. const cmSample_t* cmSpecDistOut( cmSpecDist_t* p );
  920. //------------------------------------------------------------------------------------------------------------
  921. // Write a binary matrix file in the format acceppted by the octave function readBinFile.m
  922. typedef struct cmBinMtxFile_str
  923. {
  924. cmObj obj;
  925. cmFileH_t fh;
  926. unsigned rowCnt;
  927. unsigned maxRowEleCnt;
  928. unsigned eleByteCnt;
  929. } cmBinMtxFile_t;
  930. cmBinMtxFile_t* cmBinMtxFileAlloc( cmCtx* ctx, cmBinMtxFile_t* ap, const cmChar_t* fn );
  931. cmRC_t cmBinMtxFileFree( cmBinMtxFile_t** pp );
  932. cmRC_t cmBinMtxFileInit( cmBinMtxFile_t* p, const cmChar_t* fn );
  933. cmRC_t cmBinMtxFileFinal( cmBinMtxFile_t* p );
  934. // Write one row of 'xn' columns to the matrix file.
  935. cmRC_t cmBinMtxFileExecS( cmBinMtxFile_t* p, const cmSample_t* x, unsigned xn );
  936. cmRC_t cmBinMtxFileExecR( cmBinMtxFile_t* p, const cmReal_t* x, unsigned xn );
  937. bool cmBinMtxFileIsValid( cmBinMtxFile_t* p );
  938. // Write a binary matrix file.
  939. // The matrix data is provided as sp[rowCnt,colCnt] or rp[rowCnt,colCnt].
  940. // The matrix is assumed to be in column major order (like all matrices in the cm library)
  941. // Either 'sp' or 'rp' must be given but not both.
  942. // 'ctx' is optional and defaults to NULL.
  943. // If 'ctx' is not provided then 'rpt' must be provided.
  944. // If 'ctx' is provided then 'rpt' is not used.
  945. // See cmAudioFileReadWriteTest() in cmProcTest.c for an example usage.
  946. cmRC_t cmBinMtxFileWrite( const cmChar_t* fn, unsigned rowCnt, unsigned colCnt, const cmSample_t* sp, const cmReal_t* rp, cmCtx* ctx, cmRpt_t* rpt );
  947. // Return the matrix file geometry.
  948. // rowCntPtr,colCntPtr and eleByteCntPtr are optional
  949. cmRC_t cmBinMtxFileSize( cmCtx_t* ctx, const cmChar_t* fn, unsigned* rowCntPtr, unsigned* colCntPtr, unsigned* eleByteCntPtr );
  950. // Fill buf[rowCnt*colCnt*byteEleCnt] buffer from the binary matrix file 'fn'.
  951. // rowCnt,colCnt,eleByteCnt must be exactly the same as the actual file.
  952. // Use cmBinMtxFileSize() to determine the buffer size prior to calling this function.
  953. // colCntV[colCnt] is optional.
  954. cmRC_t cmBinMtxFileRead( cmCtx_t* ctx, const cmChar_t* fn, unsigned rowCnt, unsigned colCnt, unsigned eleByteCnt, void* buf, unsigned* colCntV );
  955. #ifdef __cplusplus
  956. }
  957. #endif
  958. #endif