falkTX
/
paulstretchplugin
mirror of https://bitbucket.org/xenakios/paulstretchplugin.git
1
0
Fork 0
Code Issues 0 Releases 10 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
123 Commits
1 Branch
752KB
Tree: 22aaaeb836
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '22aaaeb836'
${ noResults }
paulstretchplugin/Source/PS_Source/ProcessedStretch.h

494 lines
14KB
Raw Blame History 

  1. /*

  2.   Copyright (C) 2011 Nasca Octavian Paul

  3.   Author: Nasca Octavian Paul

  4. 

  5.   This program is free software; you can redistribute it and/or modify

  6.   it under the terms of version 2 of the GNU General Public License 

  7.   as published by the Free Software Foundation.

  8. 

  9.   This program is distributed in the hope that it will be useful,

  10.   but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12.   GNU General Public License (version 2) for more details.

  13. 

  14.   You should have received a copy of the GNU General Public License (version 2)

  15.   along with this program; if not, write to the Free Software Foundation,

  16.   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

  17. */

  18. 

  19. 

  20. #pragma once

  21. 

  22. #include "FreeEdit.h"

  23. #include "Stretch.h"

  24. 

  25. struct ProcessParameters

  26. {

  27. 	ProcessParameters()

  28. 	{

  29. 		pitch_shift.enabled=false;

  30. 		pitch_shift.cents=0;

  31. 

  32. 		octave.enabled=false;

  33. 		octave.om2=octave.om1=octave.o1=octave.o15=octave.o2=0.0f;

  34. 		octave.o0=1.0f;

  35. 

  36. 		freq_shift.enabled=false;

  37. 		freq_shift.Hz=0;

  38. 

  39. 		compressor.enabled=false;

  40. 		compressor.power=0.0f;

  41. 

  42. 		filter.enabled=false;

  43. 		filter.stop=false;

  44. 		filter.low=0.0f;

  45. 		filter.high=22000.0f;

  46. 		filter.hdamp=0.0f;

  47. 

  48. 		harmonics.enabled=false;

  49. 		harmonics.freq=440.0f;

  50. 		harmonics.bandwidth=25.0f;

  51. 		harmonics.nharmonics=10;

  52. 		harmonics.gauss=false;

  53. 

  54. 		spread.enabled=false;

  55. 		spread.bandwidth=0.3f;

  56. 		

  57. 		tonal_vs_noise.enabled=false;

  58. 		tonal_vs_noise.preserve=0.5f;

  59. 		tonal_vs_noise.bandwidth=0.9f;

  60. 	};

  61. 	~ProcessParameters(){

  62. 	};

  63. 	

  64. 	

  65. 	struct{

  66. 		bool enabled;

  67. 		int cents;

  68. 	}pitch_shift;

  69. 

  70. 	struct{

  71. 		bool enabled;

  72. 		REALTYPE om2,om1,o0,o1,o15,o2;

  73. 	}octave;

  74. 

  75. 	struct{

  76. 		bool enabled;

  77. 		int Hz;

  78. 	}freq_shift;

  79. 

  80. 	struct{

  81. 		bool enabled;

  82. 		REALTYPE power;

  83. 	}compressor;

  84. 

  85. 	struct{

  86. 		bool enabled;

  87. 		REALTYPE low,high;

  88. 		REALTYPE hdamp;

  89. 		bool stop;

  90. 	}filter;    

  91. 

  92. 	struct{

  93. 		bool enabled;

  94. 		REALTYPE freq;

  95. 		REALTYPE bandwidth;

  96. 		int nharmonics;

  97. 		bool gauss;

  98. 	}harmonics;

  99. 

  100. 	struct{

  101. 		bool enabled;

  102. 		REALTYPE bandwidth;

  103. 	}spread;

  104. 

  105. 	struct{

  106. 		bool enabled;

  107. 		REALTYPE preserve;

  108. 		REALTYPE bandwidth;

  109. 	}tonal_vs_noise;

  110. 

  111. 	//FreeEdit free_filter;

  112. 	//FreeEdit stretch_multiplier;

  113. 	/*

  114. 	auto getMembers() const

  115. 	{

  116. 		return std::make_tuple(pitch_shift.enabled,

  117. 			pitch_shift.cents,

  118. 			octave.enabled,

  119. 			octave.o0,

  120. 			octave.o1,

  121. 			octave.o15,

  122. 			octave.o2,

  123. 			octave.om1,

  124. 			octave.om2,

  125. 			spread.enabled,

  126. 			spread.bandwidth,

  127. 			tonal_vs_noise.enabled,

  128. 			tonal_vs_noise.bandwidth,

  129. 			tonal_vs_noise.preserve,

  130. 			freq_shift.enabled,

  131. 			freq_shift.Hz,

  132. 			compressor.enabled,

  133. 			compressor.power,

  134. 			harmonics.bandwidth,

  135. 			harmonics.enabled,

  136. 			harmonics.freq,

  137. 			harmonics.gauss,

  138. 			harmonics.nharmonics,

  139. 			filter.enabled,

  140. 			filter.hdamp,

  141. 			filter.high,

  142. 			filter.low,

  143. 			filter.stop);

  144. 	}

  145. 	bool operator == (const ProcessParameters& other) const

  146. 	{

  147. 		return getMembers() == other.getMembers();

  148. 	}

  149. 	*/

  150. 	bool operator == (const ProcessParameters& other) const noexcept

  151. 	{

  152. 		return pitch_shift.enabled == other.pitch_shift.enabled &&

  153. 			pitch_shift.cents == other.pitch_shift.cents &&

  154. 			octave.enabled == other.octave.enabled &&

  155. 			octave.o0 == other.octave.o0 &&

  156. 			octave.o1 == other.octave.o1 &&

  157. 			octave.o15 == other.octave.o15 &&

  158. 			octave.o2 == other.octave.o2 &&

  159. 			octave.om1 == other.octave.om1 &&

  160. 			octave.om2 == other.octave.om2 &&

  161. 			spread.enabled == other.spread.enabled &&

  162. 			spread.bandwidth == other.spread.bandwidth &&

  163. 			tonal_vs_noise.enabled == other.tonal_vs_noise.enabled &&

  164. 			tonal_vs_noise.bandwidth == other.tonal_vs_noise.bandwidth &&

  165. 			tonal_vs_noise.preserve == other.tonal_vs_noise.preserve &&

  166. 			freq_shift.enabled == other.freq_shift.enabled &&

  167. 			freq_shift.Hz == other.freq_shift.Hz &&

  168. 			compressor.enabled == other.compressor.enabled &&

  169. 			compressor.power == other.compressor.power &&

  170. 			harmonics.bandwidth == other.harmonics.bandwidth &&

  171. 			harmonics.enabled == other.harmonics.enabled &&

  172. 			harmonics.freq == other.harmonics.freq &&

  173. 			harmonics.gauss == other.harmonics.gauss &&

  174. 			harmonics.nharmonics == other.harmonics.nharmonics &&

  175. 			filter.enabled == other.filter.enabled &&

  176. 			filter.hdamp == other.filter.hdamp &&

  177. 			filter.high == other.filter.high &&

  178. 			filter.low == other.filter.low &&

  179. 			filter.stop == other.filter.stop;

  180. 	}

  181. };

  182. 

  183. inline REALTYPE profile(REALTYPE fi, REALTYPE bwi) {

  184. 	REALTYPE x = fi / bwi;

  185. 	x *= x;

  186. 	if (x>14.71280603) return 0.0;

  187. 	return exp(-x);///bwi;

  188. 

  189. };

  190. 

  191. inline void spectrum_copy(int nfreq, REALTYPE* freq1, REALTYPE* freq2)

  192. {

  193. 	for (int i = 0; i<nfreq; i++) freq2[i] = freq1[i];

  194. };

  195. 

  196. 

  197. inline void spectrum_spread(int nfreq, double samplerate, 

  198. 	std::vector<REALTYPE>& tmpfreq1,

  199. 	REALTYPE *freq1, REALTYPE *freq2, REALTYPE spread_bandwidth) {

  200. 	//convert to log spectrum

  201. 	REALTYPE minfreq = 20.0f;

  202. 	REALTYPE maxfreq = 0.5f*samplerate;

  203. 

  204. 	REALTYPE log_minfreq = log(minfreq);

  205. 	REALTYPE log_maxfreq = log(maxfreq);

  206. 

  207. 	for (int i = 0; i<nfreq; i++) {

  208. 		REALTYPE freqx = i / (REALTYPE)nfreq;

  209. 		REALTYPE x = exp(log_minfreq + freqx * (log_maxfreq - log_minfreq)) / maxfreq * nfreq;

  210. 		REALTYPE y = 0.0f;

  211. 		int x0 = (int)floor(x); if (x0 >= nfreq) x0 = nfreq - 1;

  212. 		int x1 = x0 + 1; if (x1 >= nfreq) x1 = nfreq - 1;

  213. 		REALTYPE xp = x - x0;

  214. 		if (x<nfreq) {

  215. 			y = freq1[x0] * (1.0f - xp) + freq1[x1] * xp;

  216. 		};

  217. 		tmpfreq1[i] = y;

  218. 	};

  219. 

  220. 	//increase the bandwidth of each harmonic (by smoothing the log spectrum)

  221. 	int n = 2;

  222. 	REALTYPE bandwidth = spread_bandwidth;

  223. 	REALTYPE a = 1.0f - pow(2.0f, -bandwidth * bandwidth*10.0f);

  224. 	a = pow(a, 8192.0f / nfreq * n);

  225. 

  226. 	for (int k = 0; k<n; k++) {

  227. 		tmpfreq1[0] = 0.0f;

  228. 		for (int i = 1; i<nfreq; i++) {

  229. 			tmpfreq1[i] = tmpfreq1[i - 1] * a + tmpfreq1[i] * (1.0f - a);

  230. 		};

  231. 		tmpfreq1[nfreq - 1] = 0.0f;

  232. 		for (int i = nfreq - 2; i>0; i--) {

  233. 			tmpfreq1[i] = tmpfreq1[i + 1] * a + tmpfreq1[i] * (1.0f - a);

  234. 		};

  235. 	};

  236. 

  237. 	freq2[0] = 0;

  238. 	REALTYPE log_maxfreq_d_minfreq = log(maxfreq / minfreq);

  239. 	for (int i = 1; i<nfreq; i++) {

  240. 		REALTYPE freqx = i / (REALTYPE)nfreq;

  241. 		REALTYPE x = log((freqx*maxfreq) / minfreq) / log_maxfreq_d_minfreq * nfreq;

  242. 		REALTYPE y = 0.0;

  243. 		if ((x>0.0) && (x<nfreq)) {

  244. 			int x0 = (int)floor(x); if (x0 >= nfreq) x0 = nfreq - 1;

  245. 			int x1 = x0 + 1; if (x1 >= nfreq) x1 = nfreq - 1;

  246. 			REALTYPE xp = x - x0;

  247. 			y = tmpfreq1[x0] * (1.0f - xp) + tmpfreq1[x1] * xp;

  248. 		};

  249. 		freq2[i] = y;

  250. 	};

  251. 

  252. 

  253. };

  254. 

  255. 

  256. inline void spectrum_do_compressor(const ProcessParameters& pars, int nfreq, REALTYPE *freq1, REALTYPE *freq2) {

  257. 	REALTYPE rms = 0.0;

  258. 	for (int i = 0; i<nfreq; i++) rms += freq1[i] * freq1[i];

  259. 	rms = sqrt(rms / nfreq)*0.1f;

  260. 	if (rms<1e-3f) rms = 1e-3f;

  261. 

  262. 	REALTYPE _rap = pow(rms, -pars.compressor.power);

  263. 	for (int i = 0; i<nfreq; i++) freq2[i] = freq1[i] * _rap;

  264. };

  265. 

  266. inline void spectrum_do_tonal_vs_noise(const ProcessParameters& pars, int nfreq, double samplerate,

  267. 	std::vector<REALTYPE>& tmpfreq1,

  268. 	REALTYPE *freq1, REALTYPE *freq2) {

  269. 	spectrum_spread(nfreq, samplerate, tmpfreq1, freq1, tmpfreq1.data(), pars.tonal_vs_noise.bandwidth);

  270. 

  271. 	if (pars.tonal_vs_noise.preserve >= 0.0) {

  272. 		REALTYPE mul = (pow(10.0f, pars.tonal_vs_noise.preserve) - 1.0f);

  273. 		for (int i = 0; i<nfreq; i++) {

  274. 			REALTYPE x = freq1[i];

  275. 			REALTYPE smooth_x = tmpfreq1[i] + 1e-6f;

  276. 

  277. 			REALTYPE result = 0.0f;

  278. 			result = x - smooth_x * mul;

  279. 			if (result<0.0f) result = 0.0f;

  280. 			freq2[i] = result;

  281. 		};

  282. 	}

  283. 	else {

  284. 		REALTYPE mul = (pow(5.0f, 1.0f + pars.tonal_vs_noise.preserve) - 1.0f);

  285. 		for (int i = 0; i<nfreq; i++) {

  286. 			REALTYPE x = freq1[i];

  287. 			REALTYPE smooth_x = tmpfreq1[i] + 1e-6f;

  288. 

  289. 			REALTYPE result = 0.0f;

  290. 			result = x - smooth_x * mul + 0.1f*mul;

  291. 			if (result<0.0f) result = x;

  292. 			else result = 0.0f;

  293. 

  294. 			freq2[i] = result;

  295. 		};

  296. 	};

  297. 

  298. };

  299. 

  300. inline void spectrum_do_harmonics(const ProcessParameters& pars, std::vector<REALTYPE>& tmpfreq1, int nfreq, double samplerate, REALTYPE *freq1, REALTYPE *freq2) {

  301. 	REALTYPE freq = pars.harmonics.freq;

  302. 	REALTYPE bandwidth = pars.harmonics.bandwidth;

  303. 	int nharmonics = pars.harmonics.nharmonics;

  304. 

  305. 	if (freq<10.0) freq = 10.0;

  306. 

  307. 	REALTYPE *amp = tmpfreq1.data();

  308. 	for (int i = 0; i<nfreq; i++) amp[i] = 0.0;

  309. 

  310. 	for (int nh = 1; nh <= nharmonics; nh++) {//for each harmonic

  311. 		REALTYPE bw_Hz;//bandwidth of the current harmonic measured in Hz

  312. 		REALTYPE bwi;

  313. 		REALTYPE fi;

  314. 		REALTYPE f = nh * freq;

  315. 

  316. 		if (f >= samplerate / 2) break;

  317. 

  318. 		bw_Hz = (pow(2.0f, bandwidth / 1200.0f) - 1.0f)*f;

  319. 		bwi = bw_Hz / (2.0f*samplerate);

  320. 		fi = f / samplerate;

  321. 

  322. 		REALTYPE sum = 0.0f;

  323. 		REALTYPE max = 0.0f;

  324. 		for (int i = 1; i<nfreq; i++) {//todo: optimize here

  325. 			REALTYPE hprofile;

  326. 			hprofile = profile((i / (REALTYPE)nfreq*0.5f) - fi, bwi);

  327. 			amp[i] += hprofile;

  328. 			if (max<hprofile) max = hprofile;

  329. 			sum += hprofile;

  330. 		};

  331. 	};

  332. 

  333. 	REALTYPE max = 0.0;

  334. 	for (int i = 1; i<nfreq; i++) {

  335. 		if (amp[i]>max) max = amp[i];

  336. 	};

  337. 	if (max<1e-8f) max = 1e-8f;

  338. 

  339. 	for (int i = 1; i<nfreq; i++) {

  340. 		//REALTYPE c,s;

  341. 		REALTYPE a = amp[i] / max;

  342. 		if (!pars.harmonics.gauss) a = (a<0.368f ? 0.0f : 1.0f);

  343. 		freq2[i] = freq1[i] * a;

  344. 	};

  345. 

  346. };

  347. 

  348. inline void spectrum_add(int nfreq, REALTYPE *freq2, REALTYPE *freq1, REALTYPE a) {

  349. 	for (int i = 0; i<nfreq; i++) freq2[i] += freq1[i] * a;

  350. };

  351. 

  352. inline void spectrum_zero(int nfreq,REALTYPE *freq1) {

  353. 	for (int i = 0; i<nfreq; i++) freq1[i] = 0.0;

  354. };

  355. 

  356. inline void spectrum_do_freq_shift(const ProcessParameters& pars, int nfreq, double samplerate, REALTYPE *freq1, REALTYPE *freq2) {

  357. 	spectrum_zero(nfreq, freq2);

  358. 	int ifreq = (int)(pars.freq_shift.Hz / (samplerate*0.5)*nfreq);

  359. 	for (int i = 0; i<nfreq; i++) {

  360. 		int i2 = ifreq + i;

  361. 		if ((i2>0) && (i2<nfreq)) freq2[i2] = freq1[i];

  362. 	};

  363. };

  364. 

  365. inline void spectrum_do_pitch_shift(const ProcessParameters& pars, int nfreq, REALTYPE *freq1, REALTYPE *freq2, REALTYPE _rap) {

  366. 	spectrum_zero(nfreq,freq2);

  367. 	if (_rap<1.0) {//down

  368. 		for (int i = 0; i<nfreq; i++) {

  369. 			int i2 = (int)(i*_rap);

  370. 			if (i2 >= nfreq) break;

  371. 			freq2[i2] += freq1[i];

  372. 		};

  373. 	};

  374. 	if (_rap >= 1.0) {//up

  375. 		_rap = 1.0f / _rap;

  376. 		for (int i = 0; i<nfreq; i++) {

  377. 			freq2[i] = freq1[(int)(i*_rap)];

  378. 		};

  379. 

  380. 	};

  381. };

  382. 

  383. inline void spectrum_do_octave(const ProcessParameters& pars, int nfreq, double samplerate, 

  384. 	std::vector<REALTYPE>& sumfreq, 

  385. 	std::vector<REALTYPE>& tmpfreq1,

  386. 	REALTYPE *freq1, REALTYPE *freq2) {

  387. 	spectrum_zero(nfreq,sumfreq.data());

  388. 	if (pars.octave.om2>1e-3) {

  389. 		spectrum_do_pitch_shift(pars,nfreq, freq1, tmpfreq1.data(), 0.25);

  390. 		spectrum_add(nfreq, sumfreq.data(), tmpfreq1.data(), pars.octave.om2);

  391. 	};

  392. 	if (pars.octave.om1>1e-3) {

  393. 		spectrum_do_pitch_shift(pars,nfreq, freq1, tmpfreq1.data(), 0.5);

  394. 		spectrum_add(nfreq,sumfreq.data(), tmpfreq1.data(), pars.octave.om1);

  395. 	};

  396. 	if (pars.octave.o0>1e-3) {

  397. 		spectrum_add(nfreq,sumfreq.data(), freq1, pars.octave.o0);

  398. 	};

  399. 	if (pars.octave.o1>1e-3) {

  400. 		spectrum_do_pitch_shift(pars,nfreq, freq1, tmpfreq1.data(), 2.0);

  401. 		spectrum_add(nfreq,sumfreq.data(), tmpfreq1.data(), pars.octave.o1);

  402. 	};

  403. 	if (pars.octave.o15>1e-3) {

  404. 		spectrum_do_pitch_shift(pars,nfreq, freq1, tmpfreq1.data(), 3.0);

  405. 		spectrum_add(nfreq,sumfreq.data(), tmpfreq1.data(), pars.octave.o15);

  406. 	};

  407. 	if (pars.octave.o2>1e-3) {

  408. 		spectrum_do_pitch_shift(pars, nfreq, freq1, tmpfreq1.data(), 4.0);

  409. 		spectrum_add(nfreq,sumfreq.data(), tmpfreq1.data(), pars.octave.o2);

  410. 	};

  411. 

  412. 	REALTYPE sum = 0.01f + pars.octave.om2 + pars.octave.om1 + pars.octave.o0 + pars.octave.o1 + pars.octave.o15 + pars.octave.o2;

  413. 	if (sum<0.5f) sum = 0.5f;

  414. 	for (int i = 0; i<nfreq; i++) freq2[i] = sumfreq[i] / sum;

  415. };

  416. 

  417. inline void spectrum_do_filter(const ProcessParameters& pars, int nfreq, double samplerate, REALTYPE *freq1, REALTYPE *freq2) {

  418. 	REALTYPE low = 0, high = 0;

  419. 	if (pars.filter.low<pars.filter.high) {//sort the low/high freqs

  420. 		low = pars.filter.low;

  421. 		high = pars.filter.high;

  422. 	}

  423. 	else {

  424. 		high = pars.filter.low;

  425. 		low = pars.filter.high;

  426. 	};

  427. 	int ilow = (int)(low / samplerate * nfreq*2.0f);

  428. 	int ihigh = (int)(high / samplerate * nfreq*2.0f);

  429. 	REALTYPE dmp = 1.0;

  430. 	REALTYPE dmprap = 1.0f - pow(pars.filter.hdamp*0.5f, 4.0f);

  431. 	for (int i = 0; i<nfreq; i++) {

  432. 		REALTYPE a = 0.0f;

  433. 		if ((i >= ilow) && (i<ihigh)) a = 1.0f;

  434. 		if (pars.filter.stop) a = 1.0f - a;

  435. 		freq2[i] = freq1[i] * a*dmp;

  436. 		dmp *= dmprap + 1e-8f;

  437. 	};

  438. };

  439. 

  440. class SpectrumProcess

  441. {

  442. public:

  443.     SpectrumProcess() {}

  444.     SpectrumProcess(String name, int index) :

  445.     m_name(name), m_index(index) {}

  446.     String m_name;

  447. 	int m_index = -1;

  448. private:

  449. };

  450. 

  451. std::vector<SpectrumProcess> make_spectrum_processes();

  452. 

  453. class ProcessedStretch final : public Stretch

  454. {

  455. public:

  456.     

  457.     //stereo_mode: 0=mono,1=left,2=right

  458.     ProcessedStretch(REALTYPE rap_,int in_bufsize_,FFTWindow w=W_HAMMING,bool bypass_=false,REALTYPE samplerate_=44100.0f,int stereo_mode=0);

  459.     ~ProcessedStretch();

  460.     void set_parameters(ProcessParameters *ppar);

  461. 	std::vector<int> m_spectrum_processes;

  462. 	void setBufferSize(int sz) override;

  463. private:

  464.     REALTYPE get_stretch_multiplier(REALTYPE pos_percents) override;

  465. //		void process_output(REALTYPE *smps,int nsmps);

  466.     void process_spectrum(REALTYPE *freq) override;

  467.     void do_harmonics(REALTYPE *freq1,REALTYPE *freq2);

  468.     void do_pitch_shift(REALTYPE *freq1,REALTYPE *freq2,REALTYPE rap);

  469.     void do_freq_shift(REALTYPE *freq1,REALTYPE *freq2);

  470.     void do_octave(REALTYPE *freq1,REALTYPE *freq2);

  471.     void do_filter(REALTYPE *freq1,REALTYPE *freq2);

  472.     void do_free_filter(REALTYPE *freq1,REALTYPE *freq2);

  473.     void do_compressor(REALTYPE *freq1,REALTYPE *freq2);

  474.     void do_spread(REALTYPE *freq1,REALTYPE *freq2);

  475.     void do_tonal_vs_noise(REALTYPE *freq1,REALTYPE *freq2);

  476. 

  477.     //void copy(const realvector& freq1,realvector& freq2);

  478.     void copy(REALTYPE* freq1, REALTYPE* freq2);

  479.     void add(REALTYPE *freq2,REALTYPE *freq1,REALTYPE a=1.0);

  480.     void mul(REALTYPE *freq1,REALTYPE a);

  481.     void zero(REALTYPE *freq1);

  482.     void spread(REALTYPE *freq1,REALTYPE *freq2,REALTYPE spread_bandwidth);

  483. 

  484.     void update_free_filter();

  485.     int nfreq=0;

  486. 

  487.     std::vector<REALTYPE> free_filter_freqs;

  488.     ProcessParameters pars;

  489.     

  490.     std::vector<REALTYPE> infreq,sumfreq,tmpfreq1,tmpfreq2;

  491.     

  492. 		//REALTYPE *fbfreq;

  493. };