libcm is a C development framework with an emphasis on audio signal processing applications.
Du kannst nicht mehr als 25 Themen auswählen Themen müssen mit entweder einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.

cmProc2.h 55KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301
  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. // Note that the relative values of passHz and stopHz do not matter
  152. // for low-pass vs high-pass filters. In practice passHz and
  153. // stopHz can be swapped with no effect on the filter in either
  154. // case. Set p to NULL to dynamically allocate the object.
  155. cmFIR* cmFIRAllocKaiser(cmCtx* c, cmFIR* p, unsigned procSmpCnt, double srate, double passHz, double stopHz, double passDb, double stopDb, unsigned flags );
  156. // Set wndV[sincSmpCnt] to NULL to use a unity window otherwise set it to a window
  157. // function of length sincSmpCnt.
  158. cmFIR* cmFIRAllocSinc( cmCtx* c, cmFIR* p, unsigned procSmpCnt, double srate, unsigned sincSmpCnt, double fcHz, unsigned flags, const double* wndV );
  159. cmRC_t cmFIRFree( cmFIR** pp );
  160. cmRC_t cmFIRInitKaiser( cmFIR* p, unsigned procSmpCnt, double srate, double passHz, double stopHz, double passDb, double stopDb, unsigned flags );
  161. cmRC_t cmFIRInitSinc( cmFIR* p, unsigned procSmpCnt, double srate, unsigned sincSmpCnt, double fcHz, unsigned flags, const double* wndV );
  162. cmRC_t cmFIRFinal( cmFIR* p );
  163. cmRC_t cmFIRExec( cmFIR* p, const cmSample_t* sp, unsigned sn );
  164. void cmFIRTest0( cmRpt_t* rpt, cmLHeapH_t lhH, cmSymTblH_t stH );
  165. void cmFIRTest1( cmCtx* ctx );
  166. //------------------------------------------------------------------------------------------------------------
  167. // Apply a generic function to a windowed signal with a one sample hop size.
  168. typedef cmSample_t (*cmFuncFiltPtr_t)( const cmSample_t* sp, unsigned sn, void* userPtr );
  169. typedef struct
  170. {
  171. cmObj obj;
  172. cmFuncFiltPtr_t funcPtr;
  173. cmShiftBuf shiftBuf;
  174. cmSample_t* outV;
  175. unsigned outN; // outN == procSmpCnt
  176. unsigned curWndSmpCnt;
  177. unsigned wndSmpCnt;
  178. void* userPtr;
  179. } cmFuncFilter;
  180. /// Set p to NULL to dynamically allocate the object.
  181. cmFuncFilter* cmFuncFilterAlloc( cmCtx* c, cmFuncFilter* p, unsigned procSmpCnt, cmFuncFiltPtr_t funcPtr, void* userPtr, unsigned wndSmpCnt );
  182. cmRC_t cmFuncFilterFree( cmFuncFilter** pp );
  183. cmRC_t cmFuncFilterInit( cmFuncFilter* p, unsigned procSmpCnt, cmFuncFiltPtr_t funcPtr, void* userPtr, unsigned wndSmpCnt );
  184. cmRC_t cmFuncFilterFinal( cmFuncFilter* p );
  185. cmRC_t cmFuncFilterExec( cmFuncFilter* p, const cmSample_t* sp, unsigned sn );
  186. void cmFuncFilterTest();
  187. //------------------------------------------------------------------------------------------------------------
  188. typedef struct
  189. {
  190. cmObj obj;
  191. unsigned stateN; // count of states
  192. unsigned symN; // count of discrete observation symbols
  193. cmReal_t* initV; // initial state probability vector init[ stateN ]
  194. cmReal_t* transM; // transition probability matrix trans[ stateN (current), stateN (next) ]
  195. cmReal_t* stsM; // state to symbol prob. matrix stsM[ stateN, symN ]
  196. } cmDhmm;
  197. cmDhmm* cmDhmmAlloc( cmCtx* c, cmDhmm* p, unsigned stateN, unsigned symN, cmReal_t* initV, cmReal_t* transM, cmReal_t* stsM );
  198. cmRC_t cmDhmmFree( cmDhmm** pp );
  199. cmRC_t cmDhmmInit( cmDhmm* p, unsigned stateN, unsigned symN, cmReal_t* initV, cmReal_t* transM, cmReal_t* stsM );
  200. cmRC_t cmDhmmFinal( cmDhmm* p );
  201. cmRC_t cmDhmmExec( cmDhmm* p );
  202. cmRC_t cmDhmmGenObsSequence( cmDhmm* p, unsigned* dbp, unsigned dn );
  203. cmRC_t cmDhmmForwardEval( cmDhmm* p, const cmReal_t* statePrV, const unsigned* obsV, unsigned obsN, cmReal_t* alphaM, unsigned flags, cmReal_t* logProbPtr );
  204. cmRC_t cmDhmmReport( cmDhmm* p );
  205. void cmDhmmTest();
  206. //------------------------------------------------------------------------------------------------------------
  207. typedef struct
  208. {
  209. cmObj obj;
  210. cmFftSR* fft;
  211. cmIFftRS* ifft;
  212. cmComplexR_t* H;
  213. unsigned hn;
  214. cmSample_t* olaV; // olaV[hn-1];
  215. cmSample_t* outV; // outV[procSmpCnt]
  216. unsigned outN; // outN == procSmpCnt
  217. } cmConvolve;
  218. // After cmConvolveExec() outV[outN] contains the first outN samples
  219. // which are complete and can be used by the application.
  220. // The tail of the convolution is held in olaV[hn-1] and will
  221. // be automatically summed with the beginning of the next convolution
  222. // frame.
  223. // BUG BUG BUG
  224. // This code seems to have a problem when hn != procSmpCnt (or maybe hn > procSmpCnt ???).
  225. // See mas/main.c convolve() where procSmpCnt must be set to wndSmpCnt size or
  226. // only the first half of the window is emitted.
  227. // h[hn] is the impulse response to convolve with
  228. cmConvolve* cmConvolveAlloc( cmCtx* c, cmConvolve* p, const cmSample_t* h, unsigned hn, unsigned procSmpCnt );
  229. cmRC_t cmConvolveFree( cmConvolve** pp );
  230. cmRC_t cmConvolveInit( cmConvolve* p, const cmSample_t* h, unsigned hn, unsigned procSmpCnt );
  231. cmRC_t cmConvolveFinal( cmConvolve* p );
  232. // xn must be <= procSmpCnt
  233. cmRC_t cmConvolveExec( cmConvolve* p, const cmSample_t* x, unsigned xn );
  234. cmRC_t cmConvolveSignal( cmCtx* c, const cmSample_t* h, unsigned hn, const cmSample_t* x, unsigned xn, cmSample_t* y, unsigned yn );
  235. cmRC_t cmConvolveTest( cmRpt_t* rpt, cmLHeapH_t lhH, cmSymTblH_t stH );
  236. //------------------------------------------------------------------------------------------------------------
  237. typedef struct
  238. {
  239. cmObj obj;
  240. cmReal_t* dctMtx; // dctMtx[ binCnt, bandCnt ]
  241. cmReal_t* filtMask; // filtMask[ bandCnt, bandCnt ]
  242. unsigned binCnt; // bin cnt of input magnitude spectrum
  243. unsigned bandCnt; // must be <= kDefaultBarkBandCnt
  244. cmReal_t* outV; // outV[binCnt]
  245. } cmBfcc;
  246. cmBfcc* cmBfccAlloc( cmCtx* ctx, cmBfcc* p, unsigned bandCnt, unsigned binCnt, double binHz );
  247. cmRC_t cmBfccFree( cmBfcc** pp );
  248. cmRC_t cmBfccInit( cmBfcc* p, unsigned bandCnt, unsigned binCnt, double binHz );
  249. cmRC_t cmBfccFinal( cmBfcc* p );
  250. cmRC_t cmBfccExec( cmBfcc* p, const cmReal_t* magV, unsigned binCnt );
  251. void cmBfccTest( cmRpt_t* rpt, cmLHeapH_t lhH, cmSymTblH_t stH );
  252. //------------------------------------------------------------------------------------------------------------
  253. typedef struct
  254. {
  255. cmObj obj;
  256. //cmIFftRR ft;
  257. unsigned dct_cn; // (binCnt-1)*2
  258. cmReal_t* dctM; // dctM[ outN, dct_cn ]
  259. unsigned binCnt; // bin cnt of input magnitude spectrum
  260. unsigned outN; // count of cepstral coeff's
  261. cmReal_t* outV; // outV[outN]
  262. } cmCeps;
  263. // outN is the number of cepstral coeff's in the output vector
  264. cmCeps* cmCepsAlloc( cmCtx* ctx, cmCeps* p, unsigned binCnt, unsigned outN );
  265. cmRC_t cmCepsFree( cmCeps** pp );
  266. cmRC_t cmCepsInit( cmCeps* p, unsigned binCnt, unsigned outN );
  267. cmRC_t cmCepsFinal( cmCeps* p );
  268. cmRC_t cmCepsExec( cmCeps* p, const cmReal_t* magV, const cmReal_t* phsV, unsigned binCnt );
  269. //------------------------------------------------------------------------------------------------------------
  270. typedef struct
  271. {
  272. cmObj obj;
  273. cmWndFunc wf;
  274. unsigned wndSmpCnt;
  275. unsigned hopSmpCnt;
  276. unsigned procSmpCnt;
  277. cmSample_t* bufV; // bufV[wndSmpCnt] overlap add buffer
  278. cmSample_t* outV; // outV[hopSmpCnt] output vector
  279. cmSample_t* outPtr; // outPtr[procSmpCnt] output vector
  280. unsigned idx; // idx of next val in bufV[] to be moved to outV[]
  281. } cmOla;
  282. // hopSmpCnt must be <= wndSmpCnt.
  283. // hopSmpCnt must be an even multiple of procSmpCnt.
  284. // Call cmOlaExecR() or cmOlaExecS() at the spectral frame rate.
  285. // Call cmOlaExecOut() at the time domain audio frame rate.
  286. // Set wndTypeId to one of the cmWndFuncXXX enumerated widnow type id's.
  287. cmOla* cmOlaAlloc( cmCtx* ctx, cmOla* p, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned procSmpCnt, unsigned wndTypeId );
  288. cmRC_t cmOlaFree( cmOla** pp );
  289. cmRC_t cmOlaInit( cmOla* p, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned procSmpCnt, unsigned wndTypeId );
  290. cmRC_t cmOlaFinal( cmOla* p );
  291. cmRC_t cmOlaExecS( cmOla* p, const cmSample_t* xV, unsigned xN );
  292. cmRC_t cmOlaExecR( cmOla* p, const cmReal_t* xV, unsigned xN );
  293. const cmSample_t* cmOlaExecOut(cmOla* p );
  294. //------------------------------------------------------------------------------------------------------------
  295. typedef struct
  296. {
  297. cmObj obj;
  298. cmReal_t* hzV; // hzV[binCnt] output vector - frequency in Hertz
  299. cmReal_t* phsV; // phsV[binCnt]
  300. cmReal_t* wV; // bin freq in rads/hop
  301. double srate;
  302. unsigned hopSmpCnt;
  303. unsigned binCnt;
  304. } cmPhsToFrq;
  305. cmPhsToFrq* cmPhsToFrqAlloc( cmCtx* c, cmPhsToFrq* p, double srate, unsigned binCnt, unsigned hopSmpCnt );
  306. cmRC_t cmPhsToFrqFree( cmPhsToFrq** p );
  307. cmRC_t cmPhsToFrqInit( cmPhsToFrq* p, double srate, unsigned binCnt, unsigned hopSmpCnt );
  308. cmRC_t cmPhsToFrqFinal(cmPhsToFrq* p );
  309. cmRC_t cmPhsToFrqExec( cmPhsToFrq* p, const cmReal_t* phsV );
  310. //------------------------------------------------------------------------------------------------------------
  311. enum
  312. {
  313. kNoCalcHzPvaFl = 0x00,
  314. kCalcHzPvaFl = 0x01
  315. };
  316. typedef struct
  317. {
  318. cmObj obj;
  319. cmShiftBuf sb;
  320. cmFftSR ft;
  321. cmWndFunc wf;
  322. cmPhsToFrq pf;
  323. unsigned flags;
  324. unsigned procSmpCnt;
  325. double srate;
  326. unsigned wndSmpCnt;
  327. unsigned hopSmpCnt;
  328. unsigned binCnt;
  329. const cmReal_t* magV; // amplitude NOT power
  330. const cmReal_t* phsV;
  331. const cmReal_t* hzV;
  332. } cmPvAnl;
  333. cmPvAnl* cmPvAnlAlloc( cmCtx* ctx, cmPvAnl* p, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned flags );
  334. cmRC_t cmPvAnlFree( cmPvAnl** pp );
  335. cmRC_t cmPvAnlInit( cmPvAnl* p, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopSmpCnt, unsigned flags );
  336. cmRC_t cmPvAnlFinal(cmPvAnl* p );
  337. // Returns true when a new spectrum has been computed
  338. bool cmPvAnlExec( cmPvAnl* p, const cmSample_t* x, unsigned xN );
  339. //------------------------------------------------------------------------------------------------------------
  340. typedef struct
  341. {
  342. cmObj obj;
  343. cmIFftRS ft;
  344. cmWndFunc wf;
  345. cmOla ola;
  346. cmReal_t* minRphV;
  347. cmReal_t* maxRphV;
  348. cmReal_t* itrV;
  349. cmReal_t* phs0V;
  350. cmReal_t* mag0V;
  351. cmReal_t* phsV;
  352. cmReal_t* magV;
  353. double outSrate;
  354. unsigned procSmpCnt;
  355. unsigned wndSmpCnt;
  356. unsigned hopSmpCnt;
  357. unsigned binCnt;
  358. } cmPvSyn;
  359. cmPvSyn* cmPvSynAlloc( cmCtx* ctx, cmPvSyn* p, unsigned procSmpCnt, double outSrate, unsigned wndSmpCnt, unsigned hopSmpCnt,unsigned wndTypeId );
  360. cmRC_t cmPvSynFree( cmPvSyn** pp );
  361. cmRC_t cmPvSynInit( cmPvSyn* p, unsigned procSmpCnt, double outSrate, unsigned wndSmpCnt, unsigned hopSmpCnt,unsigned wndTypeId );
  362. cmRC_t cmPvSynFinal(cmPvSyn* p );
  363. cmRC_t cmPvSynExec( cmPvSyn* p, const cmReal_t* magV, const cmReal_t* phsV );
  364. const cmSample_t* cmPvSynExecOut(cmPvSyn* p );
  365. //------------------------------------------------------------------------------------------------------------
  366. // callback selector values
  367. enum
  368. {
  369. kAttackMsId,
  370. kReleaseMsId,
  371. kDspMsId // return 0 if the voice is no longer active
  372. };
  373. // voice flags
  374. enum
  375. {
  376. kActiveMsFl = 0x01, // set if the voice is active
  377. kKeyGateMsFl = 0x02, // set if the key is down for this note
  378. };
  379. struct cmMidiSynth_str;
  380. struct cmMidiSynthCh_str;
  381. struct cmMidiVoice_str;
  382. // voice update callback - use voicePtr->pgm.cbDataPtr to get voice specific data
  383. typedef int (*cmMidiSynthCb_t)( struct cmMidiVoice_str* voicePtr, unsigned sel, cmSample_t* outChArray[], unsigned outChCnt );
  384. typedef struct
  385. {
  386. cmMidiByte_t pgm; // MIDI pgm number
  387. cmMidiSynthCb_t cbPtr; // voice update callback
  388. void* cbDataPtr; // user data pointer
  389. } cmMidiSynthPgm;
  390. typedef struct cmMidiVoice_str
  391. {
  392. unsigned index; // voice index
  393. unsigned flags; // see kXXXMsFl above
  394. cmMidiByte_t pitch; // note-on pitch
  395. cmMidiByte_t velocity; // note-on/off veloctiy
  396. cmMidiSynthPgm pgm; // pgm associated with this voice
  397. struct cmMidiSynthCh_str* chPtr; // pointer to owning ch
  398. struct cmMidiVoice_str* link; // link to next active/avail voice in chain
  399. } cmMidiVoice;
  400. typedef struct cmMidiSynthCh_str
  401. {
  402. cmMidiByte_t midiCtl[ kMidiCtlCnt ]; // current ctl values
  403. short pitchBend; // current pitch bend value
  404. cmMidiByte_t pgm; // last pgm received
  405. cmMidiVoice* active; // first active voice on this channel
  406. struct cmMidiSynth_str* synthPtr; // owning synth
  407. } cmMidiSynthCh;
  408. typedef struct cmMidiSynth_str
  409. {
  410. cmObj obj;
  411. cmMidiSynthCh chArray[ kMidiChCnt ]; // midi channel array
  412. unsigned voiceCnt; // count of voice records
  413. cmMidiVoice* avail; // avail voice chain
  414. unsigned activeVoiceCnt; // current count of active voices
  415. unsigned voiceStealCnt; // count of times voice stealing was required
  416. cmMidiVoice* voiceArray; // array of voice records
  417. cmMidiSynthPgm pgmArray[ kMidiPgmCnt ]; // array of pgm records
  418. unsigned procSmpCnt; // samples per DSP cycle
  419. unsigned outChCnt; // count of output channels
  420. cmSample_t* outM; // outM[ procSmpCnt, outChCnt ] output buffer
  421. cmSample_t** outChArray; // buffer of pointers to each output channel
  422. cmReal_t srate; // output signal sample rate
  423. } cmMidiSynth;
  424. cmMidiSynth* cmMidiSynthAlloc( cmCtx* ctx, cmMidiSynth* p, const cmMidiSynthPgm* pgmArray, unsigned pgmCnt, unsigned voiceCnt, unsigned procSmpCnt, unsigned outChCnt, cmReal_t srate );
  425. cmRC_t cmMidiSynthFree( cmMidiSynth** pp );
  426. cmRC_t cmMidiSynthInit( cmMidiSynth* p, const cmMidiSynthPgm* pgmArray, unsigned pgmCnt, unsigned voiceCnt, unsigned procSmpCnt, unsigned outChCnt, cmReal_t srate );
  427. cmRC_t cmMidiSynthFinal( cmMidiSynth* p );
  428. cmRC_t cmMidiSynthOnMidi(cmMidiSynth* p, const cmMidiPacket_t* pktArray, unsigned pktCnt );
  429. cmRC_t cmMidiSynthExec( cmMidiSynth* p, cmSample_t** outChArray, unsigned outChCnt );
  430. //------------------------------------------------------------------------------------------------------------
  431. // state id's
  432. enum
  433. {
  434. kOffWtId,
  435. kAtkWtId,
  436. kDcyWtId,
  437. kSusWtId,
  438. kRlsWtId
  439. };
  440. typedef struct
  441. {
  442. cmObj obj;
  443. cmReal_t hz; // current frq in Hz
  444. cmReal_t level; // current gain (0.0 to 1.0)
  445. cmReal_t phase; // osc phase (radians)
  446. unsigned durSmpCnt; // count of samples generated so far
  447. unsigned state; // osc state - see kXXXWtId above
  448. cmSample_t* outV; // signal output vector
  449. unsigned outN; // samples in outV[]
  450. } cmWtVoice;
  451. cmWtVoice* cmWtVoiceAlloc( cmCtx* ctx, cmWtVoice* p, unsigned procSmpCnt, cmReal_t hz );
  452. cmRC_t cmWtVoiceFree( cmWtVoice** pp );
  453. cmRC_t cmWtVoiceInit( cmWtVoice* p, unsigned procSmpCnt, cmReal_t hz );
  454. cmRC_t cmWtVoiceFinal( cmWtVoice* p );
  455. // 'sel' values are cmMidiSynthExec (kXXXMsId) values
  456. // Set outChArray[] to NULL to use internal audio buffer.
  457. int cmWtVoiceExec( cmWtVoice* p, struct cmMidiVoice_str* voicePtr, unsigned sel, cmSample_t* outChArray[], unsigned outChCnt );
  458. //------------------------------------------------------------------------------------------------------------
  459. typedef struct
  460. {
  461. cmObj obj;
  462. cmWtVoice** voiceArray; // osc state array
  463. unsigned voiceCnt;
  464. cmSample_t* buf;
  465. cmSample_t** chArray;
  466. unsigned chCnt;
  467. unsigned procSmpCnt; // count of samples in each chArray[i] sample vector
  468. double srate; // synth sample rate
  469. } cmWtVoiceBank;
  470. cmWtVoiceBank* cmWtVoiceBankAlloc( cmCtx* ctx, cmWtVoiceBank* p, double srate, unsigned procSmpCnt, unsigned voiceCnt, unsigned chCnt );
  471. cmRC_t cmWtVoiceBankFree( cmWtVoiceBank** pp );
  472. cmRC_t cmWtVoiceBankInit( cmWtVoiceBank* p, double srate, unsigned procSmpCnt, unsigned voiceCnt, unsigned chCnt );
  473. cmRC_t cmWtVoiceBankFinal( cmWtVoiceBank* p );
  474. // 'sel' values are cmMidiSynthExec (kXXXMsId) values
  475. // Set outChArray[] to NULL to use internal audio buffer.
  476. // Return 0 if the voice has gone inactive otherwise return 1.
  477. int cmWtVoiceBankExec( cmWtVoiceBank* p, struct cmMidiVoice_str* voicePtr, unsigned sel, cmSample_t* chArray[], unsigned chCnt );
  478. //------------------------------------------------------------------------------------------------------------
  479. typedef struct
  480. {
  481. cmObj obj;
  482. cmSample_t* bufV; // bufV[ bufN ]
  483. unsigned bufN;
  484. cmAudioFileInfo_t info;
  485. unsigned begSmpIdx;
  486. unsigned chIdx;
  487. char* fn;
  488. } cmAudioFileBuf;
  489. // set 'durSmpCnt' to cmInvalidCnt to include all samples to the end of the file
  490. cmAudioFileBuf* cmAudioFileBufAlloc( cmCtx* ctx, cmAudioFileBuf* p, unsigned procSmpCnt, const char* fn, unsigned chIdx, unsigned begSmpIdx, unsigned durSmpCnt );
  491. cmRC_t cmAudioFileBufFree( cmAudioFileBuf** pp );
  492. cmRC_t cmAudioFileBufInit( cmAudioFileBuf* p, unsigned procSmpCnt, const char* fn, unsigned chIdx, unsigned begSmpIdx, unsigned durSmpCnt );
  493. cmRC_t cmAudioFileBufFinal(cmAudioFileBuf* p );
  494. // Returns the count of samples copied into outV or 0 if smpIdx >= p->bufN.
  495. // If less than outN samples are available then the remaining samples are set to 0.
  496. unsigned cmAudioFileBufExec( cmAudioFileBuf* p, unsigned smpIdx, cmSample_t* outV, unsigned outN, bool sumIntoOutFl );
  497. //------------------------------------------------------------------------------------------------------------
  498. // Multi-delay. Each of the taps of this delay operates as a independent delay with feedback.
  499. // Delay line specification.
  500. typedef struct
  501. {
  502. cmReal_t delayGain; // delay gain
  503. cmReal_t delayMs; // delay time in milliseconds
  504. cmReal_t delaySmpFrac; // delay time in samples (next fractional delay index = inIdx - delaySmpFrac)
  505. cmSample_t* delayBuf; // delayBuf[delayBufSmpCnt] delay line memory
  506. int delayBufSmpCnt; // delay buffer length in samples
  507. int inIdx; // next delay input index
  508. } cmMDelayHead;
  509. typedef struct
  510. {
  511. cmObj obj;
  512. unsigned delayCnt; // count of taps
  513. cmMDelayHead* delayArray; // tap specs
  514. cmSample_t* outV; // outV[outN] output buffer
  515. unsigned outN; // procSmpCnt
  516. cmReal_t fbCoeff; // feedback coeff.
  517. cmReal_t srate; // system sample rate
  518. } cmMDelay;
  519. cmMDelay* cmMDelayAlloc( cmCtx* ctx, cmMDelay* p, unsigned procSmpCnt, cmReal_t srate, cmReal_t fbCoeff, unsigned delayCnt, const cmReal_t* delayMsArray, const cmReal_t* delayGainArray );
  520. cmRC_t cmMDelayFree( cmMDelay** pp );
  521. cmRC_t cmMDelayInit( cmMDelay* p, unsigned procSmpCnt, cmReal_t srate, cmReal_t fbCoeff, unsigned delayCnt, const cmReal_t* delayMsArray, const cmReal_t* delayGainArray );
  522. cmRC_t cmMDelayFinal( cmMDelay* p );
  523. cmRC_t cmMDelayExec( cmMDelay* p, const cmSample_t* sigV, cmSample_t* outV, unsigned sigN, bool bypassFl );
  524. void cmMDelaySetTapMs( cmMDelay* p, unsigned tapIdx, cmReal_t ms );
  525. void cmMDelaySetTapGain(cmMDelay* p, unsigned tapIdx, cmReal_t gain );
  526. void cmMDelayReport( cmMDelay* p, cmRpt_t* rpt );
  527. //------------------------------------------------------------------------------------------------------------
  528. enum
  529. {
  530. kEnableAspFl = 0x01,
  531. kDelAspFl = 0x02
  532. };
  533. typedef struct cmAudioSeg_str
  534. {
  535. cmAudioFileBuf* bufPtr; // pointer to the audio file buffer this segment is contained in
  536. unsigned id; // id (unique amoung segments)
  537. unsigned smpIdx; // offset into audioBuf[] of first sample
  538. unsigned smpCnt; // total count of samples to play
  539. unsigned outChIdx; // output buffer channel
  540. unsigned outSmpIdx; // outSmpIdx + smpIdx == next sample to play
  541. unsigned flags; // see kXXXAspFl
  542. } cmAudioSeg;
  543. typedef struct
  544. {
  545. cmObj obj;
  546. unsigned segCnt;
  547. cmAudioSeg* segArray;
  548. unsigned procSmpCnt;
  549. cmSample_t** outChArray;
  550. unsigned outChCnt;
  551. cmSample_t* outM;
  552. } cmAudioSegPlayer;
  553. cmAudioSegPlayer* cmAudioSegPlayerAlloc( cmCtx* ctx, cmAudioSegPlayer* p, unsigned procSmpCnt, unsigned outChCnt );
  554. cmRC_t cmAudioSegPlayerFree( cmAudioSegPlayer** pp );
  555. cmRC_t cmAudioSegPlayerInit( cmAudioSegPlayer* p, unsigned procSmpCnt, unsigned outChCnt );
  556. cmRC_t cmAudioSegPlayerFinal( cmAudioSegPlayer* p );
  557. cmRC_t cmAudioSegPlayerInsert( cmAudioSegPlayer* p, unsigned id, cmAudioFileBuf* bufPtr, unsigned smpIdx, unsigned smpCnt, unsigned outChIdx );
  558. cmRC_t cmAudioSegPlayerEdit( cmAudioSegPlayer* p, unsigned id, cmAudioFileBuf* bufPtr, unsigned smpIdx, unsigned smpCnt, unsigned outChIdx );
  559. cmRC_t cmAudioSegPlayerRemove( cmAudioSegPlayer* p, unsigned id, bool delFl );
  560. cmRC_t cmAudioSegPlayerEnable( cmAudioSegPlayer* p, unsigned id, bool enableFl, unsigned outSmpIdx );
  561. cmRC_t cmAudioSegPlayerReset( cmAudioSegPlayer* p );
  562. cmRC_t cmAudioSegPlayerExec( cmAudioSegPlayer* p, cmSample_t** outChPtr, unsigned chCnt, unsigned outSmpCnt );
  563. //------------------------------------------------------------------------------------------------------------
  564. /*
  565. cmReal_t (*cmCluster0DistFunc_t)( void* userPtr, const cmReal_t* v0, const cmReal_t* v1, unsigned binCnt );
  566. typedef struct
  567. {
  568. cmObj obj;
  569. unsigned flags;
  570. unsigned stateCnt;
  571. unsigned binCnt;
  572. cmReal_t* oM; // oM[ binCnt, stateCnt ]
  573. unsigned* tM; // tM[ stateCnt, stateCnt ]
  574. cmReal_t* dV; // dV[ state
  575. cmCluster0DistFunc_t distFunc;
  576. void* distUserPtr;
  577. unsigned cnt;
  578. } cmCluster0;
  579. enum
  580. {
  581. kCalcTransFl = 0x01,
  582. kCalcDurFl = 0x02
  583. };
  584. cmCluster0* cmCluster0Alloc( cmCtx* ctx, cmCluster0* ap, unsigned stateCnt, unsigned binCnt, unsigned flags, cmCluster0DistFunc_t distFunc, void* dstUserPtr );
  585. cmRC_t cmCluster0Free( cmCluster0** pp );
  586. cmRC_t cmCluster0Init( cmCluster0* p, unsigned stateCnt, unsigned binCnt, unsigned flags, cmCluster0DistFunc_t distFunc, void* dstUserPtr );
  587. cmRC_t cmCluster0Final( cmCluster0* p );
  588. cmRC_t cmCluster0Exec( cmCluster0* p, const cmReal_t* v, unsigned vn );
  589. */
  590. //------------------------------------------------------------------------------------------------------------
  591. typedef struct
  592. {
  593. cmObj obj;
  594. unsigned n;
  595. unsigned m;
  596. unsigned r;
  597. unsigned maxIterCnt;
  598. unsigned convergeCnt;
  599. cmReal_t* V; // V[n,m]
  600. cmReal_t* W; // W[n,r]
  601. cmReal_t* H; // H[r,m]
  602. cmReal_t* tr;
  603. cmReal_t* x;
  604. cmReal_t* t0nm;
  605. cmReal_t* t1nm;
  606. cmReal_t* Wt;
  607. cmReal_t* Ht;
  608. cmReal_t* trm;
  609. unsigned* crm;
  610. cmReal_t* tnr;
  611. unsigned* c0;
  612. unsigned* c1;
  613. unsigned* c0m;
  614. unsigned* c1m;
  615. unsigned* idxV;
  616. } cmNmf_t;
  617. cmNmf_t* cmNmfAlloc( cmCtx* ctx, cmNmf_t* ap, unsigned n, unsigned m, unsigned r, unsigned maxIterCnt, unsigned convergeCnt );
  618. cmRC_t cmNmfFree( cmNmf_t** pp );
  619. cmRC_t cmNmfInit( cmNmf_t* p, unsigned n, unsigned m, unsigned r, unsigned maxIterCnt, unsigned convergeCnt );
  620. cmRC_t cmNmfFinal(cmNmf_t* p );
  621. //
  622. cmRC_t cmNmfExec( cmNmf_t* p, const cmReal_t* v, unsigned cn );
  623. //------------------------------------------------------------------------------------------------------------
  624. // cmVectArray buffers row vectors of arbitrary length in memory.
  625. // The buffers may then be access using the cmVectArrayGetXXX() functions.
  626. // The entire contents of the file may be written to a file using atVectArrayWrite().
  627. // The file may then be read in back into memory using cmVectArrayAllocFromFile()
  628. // or in octave via readVectArray.m.
  629. // A rectantular matrix in memory may be written to a VectArray file in one operation
  630. // via the function cmVectArrayWriteMatrixXXX().
  631. typedef struct cmVectArrayVect_str
  632. {
  633. unsigned n; // length of this vector in values (not bytes)
  634. union
  635. {
  636. char* v; // raw memory vector pointer
  637. double* dV; // dV[n] vector of doubles
  638. float* fV; // fV[n] vecotr of floats
  639. cmSample_t* sV; // sV[n] vector of cmSample_t
  640. int* iV;
  641. unsigned* uV;
  642. } u;
  643. struct cmVectArrayVect_str* link; // link to next element record
  644. } cmVectArrayVect_t;
  645. enum
  646. {
  647. kDoubleVaFl = 0x01,
  648. kRealVaFl = 0x01,
  649. kFloatVaFl = 0x02,
  650. kSampleVaFl = 0x02,
  651. kIntVaFl = 0x04,
  652. kUIntVaFl = 0x08,
  653. kVaMask = 0x0f
  654. };
  655. typedef struct
  656. {
  657. cmObj obj;
  658. cmVectArrayVect_t* bp; // first list element
  659. cmVectArrayVect_t* ep; // last list element
  660. unsigned vectCnt; // count of elements in linked list
  661. unsigned flags; // data vector type (See: kFloatVaFl, kDoubleVaFl, ... )
  662. unsigned typeByteCnt; // size of a single data vector value (e.g. 4=float 8=double)
  663. unsigned maxEleCnt; // length of the longest data vector
  664. double* tempV;
  665. cmVectArrayVect_t* cur;
  666. } cmVectArray_t;
  667. // Flags must be set to one of the kXXXVAFl flag values.
  668. cmVectArray_t* cmVectArrayAlloc( cmCtx* ctx, unsigned flags );
  669. cmVectArray_t* cmVectArrayAllocFromFile(cmCtx* ctx, const char* fn );
  670. cmRC_t cmVectArrayFree( cmVectArray_t** pp );
  671. // Release all the stored vectors but do not release the object.
  672. cmRC_t cmVectArrayClear( cmVectArray_t* p );
  673. // Return the count of vectors contained in the vector array.
  674. cmRC_t cmVectArrayCount( const cmVectArray_t* p );
  675. // Return the maximum element count among all rows.
  676. unsigned cmVectArrayMaxRowCount( const cmVectArray_t* p );
  677. // Store a new vector by appending it to the end of the internal vector list.
  678. // Note:
  679. // 1. The true type of v[] in the call to cmVectArrayAppendV() must match
  680. // the data type set in p->flags.
  681. // 2. The 'vn' argument to atVectArrayAppendV() is an element count not
  682. // a byte count. The size of each element is determined by the data type
  683. // as set by atVectArrayAlloc().
  684. cmRC_t cmVectArrayAppendV( cmVectArray_t* p, const void* v, unsigned vn );
  685. cmRC_t cmVectArrayAppendS( cmVectArray_t* p, const cmSample_t* v, unsigned vn );
  686. cmRC_t cmVectArrayAppendR( cmVectArray_t* p, const cmReal_t* v, unsigned vn );
  687. cmRC_t cmVectArrayAppendF( cmVectArray_t* p, const float* v, unsigned vn );
  688. cmRC_t cmVectArrayAppendD( cmVectArray_t* p, const double* v, unsigned vn );
  689. cmRC_t cmVectArrayAppendI( cmVectArray_t* p, const int* v, unsigned vn );
  690. cmRC_t cmVectArrayAppendU( cmVectArray_t* p, const unsigned* v, unsigned vn );
  691. // Write a vector array in a format that can be read by readVectArray.m.
  692. cmRC_t cmVectArrayWrite( cmVectArray_t* p, const char* fn );
  693. cmRC_t cmVectArrayWriteDirFn(cmVectArray_t* p, const char* dir, const char* fn );
  694. // Print the vector array to rpt.
  695. cmRC_t cmVectArrayPrint( cmVectArray_t* p, cmRpt_t* rpt );
  696. typedef cmRC_t (*cmVectArrayForEachFuncS_t)( void* arg, unsigned idx, const cmSample_t* xV, unsigned xN );
  697. unsigned cmVectArrayForEachS( cmVectArray_t* p, unsigned idx, unsigned cnt, cmVectArrayForEachFuncS_t func, void* arg );
  698. // Write the vector v[vn] in the VectArray file format.
  699. // Note:
  700. // 1. The true type of v[] in cmVectArrayWriteVectoV() must match the
  701. // data type set in the 'flags' parameter.
  702. // 2. The 'vn' argument to atVectArrayWriteVectorV() is an element count not
  703. // a byte count. The size of each element is determined by the data type
  704. // as set by atVectArrayAlloc().
  705. cmRC_t cmVectArrayWriteVectorV( cmCtx* ctx, const char* fn, const void* v, unsigned vn, unsigned flags );
  706. cmRC_t cmVectArrayWriteVectorS( cmCtx* ctx, const char* fn, const cmSample_t* v, unsigned vn );
  707. cmRC_t cmVectArrayWriteVectorR( cmCtx* ctx, const char* fn, const cmReal_t* v, unsigned vn );
  708. cmRC_t cmVectArrayWriteVectorD( cmCtx* ctx, const char* fn, const double* v, unsigned vn );
  709. cmRC_t cmVectArrayWriteVectorF( cmCtx* ctx, const char* fn, const float* v, unsigned vn );
  710. cmRC_t cmVectArrayWriteVectorI( cmCtx* ctx, const char* fn, const int* v, unsigned vn );
  711. cmRC_t cmVectArrayWriteVectorU( cmCtx* ctx, const char* fn, const unsigned* v, unsigned vn );
  712. // Write the column-major matrix m[rn,cn] to the file 'fn'.
  713. // Notes:
  714. // 1. The true type of m[] in cmVectArrayWriteMatrixV() must match the
  715. // data type set in the 'flags' parameter.
  716. // 2. The 'rn','cn' arguments to atVectWriteMatrixV() is are element counts not
  717. // byte counts. The size of each element is determined by the data type
  718. // as set by atVectArrayAlloc().
  719. cmRC_t cmVectArrayWriteMatrixV( cmCtx* ctx, const char* fn, const void* m, unsigned rn, unsigned cn, unsigned flags );
  720. cmRC_t cmVectArrayWriteMatrixS( cmCtx* ctx, const char* fn, const cmSample_t* m, unsigned rn, unsigned cn );
  721. cmRC_t cmVectArrayWriteMatrixR( cmCtx* ctx, const char* fn, const cmReal_t* m, unsigned rn, unsigned cn );
  722. cmRC_t cmVectArrayWriteMatrixD( cmCtx* ctx, const char* fn, const double* m, unsigned rn, unsigned cn );
  723. cmRC_t cmVectArrayWriteMatrixF( cmCtx* ctx, const char* fn, const float* m, unsigned rn, unsigned cn );
  724. cmRC_t cmVectArrayWriteMatrixI( cmCtx* ctx, const char* fn, const int* m, unsigned rn, unsigned cn );
  725. cmRC_t cmVectArrayWriteMatrixU( cmCtx* ctx, const char* fn, const unsigned* m, unsigned rn, unsigned cn );
  726. // Read a VectArray file and return it as a matrix.
  727. // The returned memory must be released with a subsequent call to cmMemFree().
  728. // Note that the true type of the pointer address 'mRef' in the call to
  729. // cmVectArrayReadMatrixV() must match the data type of the cmVectArray_t
  730. // specified by 'fn'.
  731. cmRC_t cmVectArrayReadMatrixV( cmCtx* ctx, const char* fn, void** mRef, unsigned* rnRef, unsigned* cnRef );
  732. cmRC_t cmVectArrayReadMatrixS( cmCtx* ctx, const char* fn, cmSample_t** mRef, unsigned* rnRef, unsigned* cnRef );
  733. cmRC_t cmVectArrayReadMatrixR( cmCtx* ctx, const char* fn, cmReal_t** mRef, unsigned* rnRef, unsigned* cnRef );
  734. cmRC_t cmVectArrayReadMatrixD( cmCtx* ctx, const char* fn, double** mRef, unsigned* rnRef, unsigned* cnRef );
  735. cmRC_t cmVectArrayReadMatrixF( cmCtx* ctx, const char* fn, float** mRef, unsigned* rnRef, unsigned* cnRef );
  736. cmRC_t cmVectArrayReadMatrixI( cmCtx* ctx, const char* fn, int** mRef, unsigned* rnRef, unsigned* cnRef );
  737. cmRC_t cmVectArrayReadMatrixU( cmCtx* ctx, const char* fn, unsigned** mRef, unsigned* rnRef, unsigned* cnRef );
  738. // Row iteration control functions.
  739. cmRC_t cmVectArrayRewind( cmVectArray_t* p );
  740. cmRC_t cmVectArrayAdvance( cmVectArray_t* p, unsigned n );
  741. bool cmVectArrayIsEOL( const cmVectArray_t* p );
  742. unsigned cmVectArrayEleCount( const cmVectArray_t* p );
  743. // Copy the current row vector to v[].
  744. // Note that the true type of v[] in cmVectArrayGetV() must match the data type of 'p'.
  745. cmRC_t cmVectArrayGetV( cmVectArray_t* p, void* v, unsigned* vnRef );
  746. cmRC_t cmVectArrayGetS( cmVectArray_t* p, cmSample_t* v, unsigned* vnRef );
  747. cmRC_t cmVectArrayGetR( cmVectArray_t* p, cmReal_t* v, unsigned* vnRef );
  748. cmRC_t cmVectArrayGetD( cmVectArray_t* p, double* v, unsigned* vnRef );
  749. cmRC_t cmVectArrayGetF( cmVectArray_t* p, float* v, unsigned* vnRef );
  750. cmRC_t cmVectArrayGetI( cmVectArray_t* p, int* v, unsigned* vnRef );
  751. cmRC_t cmVectArrayGetU( cmVectArray_t* p, unsigned* v, unsigned* vnRef );
  752. // Set *resultFlRef to true if m[rn,cn] is equal to the cmVectArray_t specified by 'fn'.
  753. // Note that the true type of 'm[]' in the call to cmVectArrayMatrixIsEqualV()
  754. // must match the data type set in 'flags'.
  755. cmRC_t cmVectArrayMatrixIsEqualV( cmCtx* ctx, const char* fn, const void* m, unsigned rn, unsigned cn, bool* resultFlRef, unsigned flags );
  756. cmRC_t cmVectArrayMatrixIsEqualS( cmCtx* ctx, const char* fn, const cmSample_t* m, unsigned rn, unsigned cn, bool* resultFlRef );
  757. cmRC_t cmVectArrayMatrixIsEqualR( cmCtx* ctx, const char* fn, const cmReal_t* m, unsigned rn, unsigned cn, bool* resultFlRef );
  758. cmRC_t cmVectArrayMatrixIsEqualD( cmCtx* ctx, const char* fn, const double* m, unsigned rn, unsigned cn, bool* resultFlRef );
  759. cmRC_t cmVectArrayMatrixIsEqualF( cmCtx* ctx, const char* fn, const float* m, unsigned rn, unsigned cn, bool* resultFlRef );
  760. cmRC_t cmVectArrayMatrixIsEqualI( cmCtx* ctx, const char* fn, const int* m, unsigned rn, unsigned cn, bool* resultFlRef );
  761. cmRC_t cmVectArrayMatrixIsEqualU( cmCtx* ctx, const char* fn, const unsigned* m, unsigned rn, unsigned cn, bool* resultFlRef );
  762. // If a vector array is composed of repeating blocks of 'groupCnt' sub-vectors
  763. // where the concatenated ith sub-vectors in each group form a single super-vector then
  764. // this function will return the super-vector. Use cmMemFree(*vRef) to release
  765. // the returned super-vector.
  766. cmRC_t cmVectArrayFormVectR( cmVectArray_t* p, unsigned groupIdx, unsigned groupCnt, cmReal_t** vRef, unsigned* vnRef );
  767. cmRC_t cmVectArrayFormVectF( cmVectArray_t* p, unsigned groupIdx, unsigned groupCnt, float** vRef, unsigned* vnRef );
  768. cmRC_t cmVectArrayFormVectColF( cmVectArray_t* p, unsigned groupIdx, unsigned groupCnt, unsigned colIdx, float** vRef, unsigned* vnRef );
  769. cmRC_t cmVectArrayFormVectColU( cmVectArray_t* p, unsigned groupIdx, unsigned groupCnt, unsigned colIdx, unsigned** vRef, unsigned* vnRef );
  770. cmRC_t cmVectArrayTest( cmCtx* ctx, const char* fn, bool genFl );
  771. //-----------------------------------------------------------------------------------------------------------------------
  772. // Spectral whitening filter.
  773. // Based on: Klapuri, A., 2006: Multiple fundamental frequency estimation by summing
  774. // harmonic amplitudes.
  775. typedef struct
  776. {
  777. cmObj obj;
  778. unsigned binCnt; //
  779. cmReal_t binHz; //
  780. unsigned bandCnt; //
  781. cmReal_t coeff; //
  782. cmReal_t* whiV; // whiV[bandCnt+2] - fractional bin index of each center frequency
  783. cmReal_t* whM; // whM[binCnt,bandCnt]
  784. cmReal_t* iV; // iV[ binCnt ] - working memory
  785. } cmWhFilt;
  786. cmWhFilt* cmWhFiltAlloc( cmCtx* c, cmWhFilt* p, unsigned binCnt, cmReal_t binHz, cmReal_t coeff, cmReal_t maxHz );
  787. cmRC_t cmWhFiltFree( cmWhFilt** pp );
  788. cmRC_t cmWhFiltInit( cmWhFilt* p, unsigned binCnt, cmReal_t binHz, cmReal_t coeff, cmReal_t maxHz );
  789. cmRC_t cmWhFiltFinal( cmWhFilt* p );
  790. cmRC_t cmWhFiltExec( cmWhFilt* p, const cmReal_t* xV, cmReal_t* yV, unsigned xyN );
  791. //-----------------------------------------------------------------------------------------------------------------------
  792. typedef enum
  793. {
  794. kNoStateFrqTrkId,
  795. kDlyFrqTrkId,
  796. kAtkFrqTrkId,
  797. kSusFrqTrkId,
  798. kDcyFrqTrkId
  799. } cmFrqTrkAttenStateId_t;
  800. typedef struct
  801. {
  802. double srate; // system sample rate
  803. unsigned chCnt; // tracking channel count
  804. unsigned binCnt; // count of spectrum elements passed in each call to cmFrqTrkExec()
  805. unsigned hopSmpCnt; // phase vocoder hop count in samples
  806. cmReal_t stRange; // maximum allowable semi-tones between a tracker and a peak
  807. cmReal_t wndSecs; // duration of the
  808. cmReal_t minTrkSec; // minimum track length before track is considered stable
  809. cmReal_t maxTrkDeadSec; // maximum length of time a tracker may fail to connect to a peak before being declared disconnected.
  810. cmReal_t pkThreshDb; // minimum amplitide in Decibels of a selected spectral peak.
  811. cmReal_t pkAtkThreshDb; // minimum amplitude in Decibels for the first frame of a new track.
  812. cmReal_t pkMaxHz; // maximum frequency to track
  813. cmReal_t whFiltCoeff;
  814. cmReal_t attenThresh;
  815. cmReal_t attenGain;
  816. cmReal_t attenDlySec;
  817. cmReal_t attenAtkSec;
  818. const char* logFn; // log file name or NULL if no file is to be written
  819. const char* levelFn; // level file name or NULL if no file is to be written
  820. const char* specFn; // spectrum file name or NULL if no file is to be written
  821. const char* attenFn;
  822. } cmFrqTrkArgs_t;
  823. typedef struct
  824. {
  825. bool activeFl;
  826. unsigned id;
  827. unsigned tN; // age of this track in frames
  828. unsigned dN; // count of consecutive times this ch has not connected
  829. cmReal_t hz; // current center frequency
  830. cmReal_t db; // current magnitude
  831. cmReal_t* dbV; // dbV[]
  832. cmReal_t* hzV; // hzV[]
  833. unsigned si;
  834. unsigned sn;
  835. cmReal_t db_mean;
  836. cmReal_t db_std;
  837. cmReal_t hz_mean;
  838. cmReal_t hz_std;
  839. cmReal_t score;
  840. cmFrqTrkAttenStateId_t state;
  841. int attenPhsIdx;
  842. cmReal_t attenGain;
  843. } cmFrqTrkCh_t;
  844. struct cmBinMtxFile_str;
  845. typedef struct cmFrqTrk_str
  846. {
  847. cmObj obj;
  848. cmFrqTrkArgs_t a;
  849. cmFrqTrkCh_t* ch; // ch[ a.chCnt ]
  850. unsigned hN; // count of magnitude buffer frames
  851. unsigned sN; // count of frames in channel statistics buffers
  852. unsigned bN; // count of bins in peak matrices
  853. cmReal_t* dbM; // dbM[ hN, bN ]
  854. unsigned hi; // next row of dbM to fill
  855. unsigned fN; // total count of frames processed.
  856. cmReal_t binHz;
  857. cmReal_t* dbV;
  858. unsigned* pkiV;
  859. unsigned deadN_max; // max. count of hops a tracker may fail to connect before being set to inactive
  860. unsigned minTrkN; // minimum track length in hops
  861. unsigned nextTrkId;
  862. unsigned newTrkCnt;
  863. unsigned curTrkCnt;
  864. unsigned deadTrkCnt;
  865. cmReal_t* aV;
  866. int attenDlyPhsMax;
  867. int attenPhsMax;
  868. cmWhFilt* wf;
  869. cmVectArray_t* logVa;
  870. cmVectArray_t* levelVa;
  871. cmVectArray_t* specVa;
  872. cmVectArray_t* attenVa;
  873. cmChar_t* logFn;
  874. cmChar_t* levelFn;
  875. cmChar_t* specFn;
  876. cmChar_t* attenFn;
  877. } cmFrqTrk;
  878. //
  879. // 1. Calculate the mean spectral magnitude profile over the last hN frames.
  880. // 2. Locate the peaks in the profile.
  881. // 3. Allow each active tracker to select the closest peak to extend its life.
  882. // a) The distance between the trackers current location and a given
  883. // peak is measured based on magnitude and frequency over time.
  884. // b) There is a frequency range limit outside of which a given track-peak
  885. // connection may not go.
  886. // c) There is an amplitude threshold below which a track may not fall.
  887. cmFrqTrk* cmFrqTrkAlloc( cmCtx* c, cmFrqTrk* p, const cmFrqTrkArgs_t* a );
  888. cmRC_t cmFrqTrkFree( cmFrqTrk** pp );
  889. cmRC_t cmFrqTrkInit( cmFrqTrk* p, const cmFrqTrkArgs_t* a );
  890. cmRC_t cmFrqTrkFinal( cmFrqTrk* p );
  891. cmRC_t cmFrqTrkExec( cmFrqTrk* p, const cmReal_t* magV, const cmReal_t* phsV, const cmReal_t* hzV );
  892. void cmFrqTrkPrint( cmFrqTrk* p );
  893. //------------------------------------------------------------------------------------------------------------
  894. typedef struct
  895. {
  896. double srate;
  897. unsigned binCnt;
  898. unsigned hopSmpCnt;
  899. unsigned bufMs;
  900. cmReal_t maxHz;
  901. } cmFbCtlArgs_t;
  902. typedef struct
  903. {
  904. cmObj obj;
  905. cmFbCtlArgs_t a;
  906. unsigned binCnt;
  907. unsigned frmCnt;
  908. cmReal_t* bM; // bM[ frmCnt, binCnt ];
  909. unsigned bfi; // current buffer frame (column) index
  910. unsigned bfN; // currrent count of frames in the buffer
  911. cmReal_t* rmsV; // rmsV[ frmCnt ];
  912. cmReal_t* sV; // sV[ binCnt ]
  913. cmReal_t* uV;
  914. cmVectArray_t* sva;
  915. cmVectArray_t* uva;
  916. } cmFbCtl_t;
  917. cmFbCtl_t* cmFbCtlAlloc( cmCtx* c, cmFbCtl_t* p, const cmFbCtlArgs_t* a );
  918. cmRC_t cmFbCtlFree( cmFbCtl_t** pp );
  919. cmRC_t cmFbCtlInit( cmFbCtl_t* p, const cmFbCtlArgs_t* a );
  920. cmRC_t cmFbCtlFinal(cmFbCtl_t* p );
  921. cmRC_t cmFbCtlExec( cmFbCtl_t* p, const cmReal_t* xV );
  922. //-----------------------------------------------------------------------------------------------------------------------
  923. typedef struct
  924. {
  925. cmObj obj;
  926. cmReal_t* rmsV; // rmsV[rmsN]
  927. unsigned rmsN; //
  928. unsigned rmsIdx;//
  929. cmReal_t rmsValue; // last RMS value
  930. cmSample_t* envV; // envV[envN]
  931. unsigned envN; // atkSmp + rlsSmp;
  932. unsigned threshN;
  933. unsigned threshIdx;
  934. float threshLvl;
  935. float rlsLvl;
  936. unsigned envIdx;
  937. double gain;
  938. unsigned atkCnt;
  939. } cmExpander;
  940. cmExpander* cmExpanderAlloc( cmCtx* c, cmExpander* p, double srate, unsigned procSmpCnt, double threshDb, double rlsDb, double threshMs, double rmsMs, double atkMs, double rlsMs );
  941. cmRC_t cmExpanderFree( cmExpander** pp );
  942. cmRC_t cmExpanderInit( cmExpander* p, double srate, unsigned procSmpCnt, double threshDb, double rlsDb, double threshMs, double rmsMs, double atkMs, double rlsMs );
  943. cmRC_t cmExpanderFinal( cmExpander* p );
  944. cmRC_t cmExpanderExec( cmExpander* p, cmSample_t* x, cmSample_t* y, unsigned xyN );
  945. cmRC_t cmExpanderExecD( cmExpander* p, double* x, double* y, unsigned xyN );
  946. //-----------------------------------------------------------------------------------------------------------------------
  947. typedef struct
  948. {
  949. cmObj obj;
  950. cmExpander** b; // b[bandN]
  951. unsigned bandN;
  952. double rmsValue;
  953. unsigned atkCnt;
  954. } cmExpanderBank;
  955. cmExpanderBank* cmExpanderBankAlloc( cmCtx* c, cmExpanderBank* p, unsigned bandN, double srate, unsigned procSmpCnt, double threshDb, double rlsDb, double threshMs, double rmsMs, double atkMs, double rlsMs );
  956. cmRC_t cmExpanderBankFree( cmExpanderBank** pp );
  957. cmRC_t cmExpanderBankInit( cmExpanderBank* p, unsigned bandN, double srate, unsigned procSmpCnt, double threshDb, double rlsDb, double threshMs, double rmsMs, double atkMs, double rlsMs );
  958. cmRC_t cmExpanderBankFinal( cmExpanderBank* p );
  959. cmRC_t cmExpanderBankExec( cmExpanderBank* p, cmSample_t* x, unsigned bandN );
  960. cmRC_t cmExpanderBankExecD( cmExpanderBank* p, double* x, unsigned bandN );
  961. //------------------------------------------------------------------------------------------------------------
  962. enum
  963. {
  964. kBypassModeSdId, // 0 - no effect
  965. kBasicModeSdId, // 1 - fixed thresh
  966. kSpecCentSdId, // 2 - thresh = max magn - (offset * spec_cent)
  967. kAmpEnvSdId, // 3 - thresh = max magn - offset
  968. kBumpSdId,
  969. kModeSdCnt
  970. };
  971. typedef struct
  972. {
  973. cmObj obj;
  974. double srate;
  975. unsigned wndSmpCnt;
  976. unsigned hopFcmt;
  977. unsigned hopSmpCnt;
  978. unsigned procSmpCnt;
  979. cmPvAnl* pva;
  980. cmPvSyn* pvs;
  981. cmFrqTrk* ft;
  982. cmFbCtl_t* fbc;
  983. cmExpanderBank* exb;
  984. unsigned mode;
  985. double thresh;
  986. double uprSlope;
  987. double lwrSlope;
  988. double offset;
  989. bool invertFl;
  990. double spcBwHz; // spectral centroid bandwidth in Hz
  991. double spcSmArg; // spectral centroid smoothing
  992. double spcMin;
  993. double spcMax;
  994. unsigned spcBinCnt; // count of bins used in the spectral centroid
  995. cmReal_t* hzV; // hzV[spcBinCnt];
  996. cmReal_t spc;
  997. unsigned spcCnt;
  998. cmReal_t spcSum;
  999. cmReal_t spcSqSum;
  1000. cmReal_t aeSmMax; // smoothed max bin magn - used by spectral centroid
  1001. cmReal_t aeSmOffs; // smoothed offset
  1002. cmReal_t ae;
  1003. cmReal_t aeMin;
  1004. cmReal_t aeMax;
  1005. cmReal_t aeUnit;
  1006. cmReal_t ogain;
  1007. unsigned phaseModIndex;
  1008. unsigned fi; // total count of frames processed by cmSpecDistExec()
  1009. unsigned hN;
  1010. unsigned hi;
  1011. cmReal_t* iSpecM; // iSpecMtx[hN binN]
  1012. cmReal_t* iSpecV; // mean of rows of iSpecM
  1013. cmVectArray_t* iSpecVa;
  1014. cmReal_t* oSpecM; // oSpecMtx[hN binN]
  1015. cmReal_t* oSpecV; // mean of rows of oSpecM
  1016. cmVectArray_t* oSpecVa;
  1017. } cmSpecDist_t;
  1018. cmSpecDist_t* cmSpecDistAlloc( cmCtx* ctx,cmSpecDist_t* ap, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopFcmt, unsigned olaWndTypeId );
  1019. cmRC_t cmSpecDistFree( cmSpecDist_t** pp );
  1020. cmRC_t cmSpecDistInit( cmSpecDist_t* p, unsigned procSmpCnt, double srate, unsigned wndSmpCnt, unsigned hopFcmt, unsigned olaWndTypeId );
  1021. cmRC_t cmSpecDistFinal(cmSpecDist_t* p );
  1022. cmRC_t cmSpecDistExec( cmSpecDist_t* p, const cmSample_t* sp, unsigned sn );
  1023. const cmSample_t* cmSpecDistOut( cmSpecDist_t* p );
  1024. //------------------------------------------------------------------------------------------------------------
  1025. // Write a binary matrix file in the format acceppted by the octave function readBinFile.m
  1026. typedef struct cmBinMtxFile_str
  1027. {
  1028. cmObj obj;
  1029. cmFileH_t fh;
  1030. unsigned rowCnt;
  1031. unsigned maxRowEleCnt;
  1032. unsigned eleByteCnt;
  1033. } cmBinMtxFile_t;
  1034. cmBinMtxFile_t* cmBinMtxFileAlloc( cmCtx* ctx, cmBinMtxFile_t* ap, const cmChar_t* fn );
  1035. cmRC_t cmBinMtxFileFree( cmBinMtxFile_t** pp );
  1036. cmRC_t cmBinMtxFileInit( cmBinMtxFile_t* p, const cmChar_t* fn );
  1037. cmRC_t cmBinMtxFileFinal( cmBinMtxFile_t* p );
  1038. // Write one row of 'xn' columns to the matrix file.
  1039. cmRC_t cmBinMtxFileExecS( cmBinMtxFile_t* p, const cmSample_t* x, unsigned xn );
  1040. cmRC_t cmBinMtxFileExecR( cmBinMtxFile_t* p, const cmReal_t* x, unsigned xn );
  1041. bool cmBinMtxFileIsValid( cmBinMtxFile_t* p );
  1042. // Write a binary matrix file.
  1043. // The matrix data is provided as sp[rowCnt,colCnt] or rp[rowCnt,colCnt].
  1044. // The matrix is assumed to be in column major order (like all matrices in the cm library)
  1045. // Either 'sp' or 'rp' must be given but not both.
  1046. // 'ctx' is optional and defaults to NULL.
  1047. // If 'ctx' is not provided then 'rpt' must be provided.
  1048. // If 'ctx' is provided then 'rpt' is not used.
  1049. // See cmAudioFileReadWriteTest() in cmProcTest.c for an example usage.
  1050. cmRC_t cmBinMtxFileWrite( const cmChar_t* fn, unsigned rowCnt, unsigned colCnt, const cmSample_t* sp, const cmReal_t* rp, cmCtx* ctx, cmRpt_t* rpt );
  1051. // Return the matrix file geometry.
  1052. // rowCntPtr,colCntPtr and eleByteCntPtr are optional
  1053. cmRC_t cmBinMtxFileSize( cmCtx_t* ctx, const cmChar_t* fn, unsigned* rowCntPtr, unsigned* colCntPtr, unsigned* eleByteCntPtr );
  1054. // Fill buf[rowCnt*colCnt*byteEleCnt] buffer from the binary matrix file 'fn'.
  1055. // rowCnt,colCnt,eleByteCnt must be exactly the same as the actual file.
  1056. // Use cmBinMtxFileSize() to determine the buffer size prior to calling this function.
  1057. // colCntV[colCnt] is optional.
  1058. cmRC_t cmBinMtxFileRead( cmCtx_t* ctx, const cmChar_t* fn, unsigned rowCnt, unsigned colCnt, unsigned eleByteCnt, void* buf, unsigned* colCntV );
  1059. #ifdef __cplusplus
  1060. }
  1061. #endif
  1062. #endif