libcm is a C development framework with an emphasis on audio signal processing applications.
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.

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