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.
474 Commits
1 Branch
639KB
Tree: 409c053057
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '409c053057'
${ noResults }
paulstretchplugin/Source/PluginProcessor.cpp

1095 lines
38KB
Raw Blame History 

  1. /*

  2. 

  3. Copyright (C) 2017 Xenakios

  4. 

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

  6. it under the terms of version 3 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 3) for more details.

  13. 

  14. www.gnu.org/licenses

  15. 

  16. */

  17. 

  18. #include "PluginProcessor.h"

  19. #include "PluginEditor.h"

  20. #include <set>

  21. #include <thread>

  22. 

  23. #ifdef WIN32

  24. #undef min

  25. #undef max

  26. #endif

  27. 

  28. int get_optimized_updown(int n, bool up) {

  29. 	int orig_n = n;

  30. 	while (true) {

  31. 		n = orig_n;

  32. 

  33. 		while (!(n % 11)) n /= 11;

  34. 		while (!(n % 7)) n /= 7;

  35. 

  36. 		while (!(n % 5)) n /= 5;

  37. 		while (!(n % 3)) n /= 3;

  38. 		while (!(n % 2)) n /= 2;

  39. 		if (n<2) break;

  40. 		if (up) orig_n++;

  41. 		else orig_n--;

  42. 		if (orig_n<4) return 4;

  43. 	};

  44. 	return orig_n;

  45. };

  46. 

  47. int optimizebufsize(int n) {

  48. 	int n1 = get_optimized_updown(n, false);

  49. 	int n2 = get_optimized_updown(n, true);

  50. 	if ((n - n1)<(n2 - n)) return n1;

  51. 	else return n2;

  52. };

  53. 

  54. inline AudioParameterFloat* make_floatpar(String id, String name, float minv, float maxv, float defv, float step, float skew)

  55. {

  56. 	return new AudioParameterFloat(id, name, NormalisableRange<float>(minv, maxv, step, skew), defv);

  57. }

  58. 

  59. //==============================================================================

  60. PaulstretchpluginAudioProcessor::PaulstretchpluginAudioProcessor()

  61. 	: m_bufferingthread("pspluginprebufferthread")

  62. {

  63. 	m_filechoose_callback = [this](const FileChooser& chooser)

  64. 	{

  65. 		File resu = chooser.getResult();

  66. 		String pathname = resu.getFullPathName();

  67. 		if (pathname.startsWith("/localhost"))

  68. 		{

  69. 			pathname = pathname.substring(10);

  70. 			resu = File(pathname);

  71. 		}

  72. 		m_propsfile->m_props_file->setValue("importfilefolder", resu.getParentDirectory().getFullPathName());

  73. 		String loaderr = setAudioFile(resu);

  74. 		if (auto ed = dynamic_cast<PaulstretchpluginAudioProcessorEditor*>(getActiveEditor()); ed != nullptr)

  75. 		{

  76. 			ed->m_last_err = loaderr;

  77. 		}

  78. 		

  79. 	};

  80. 	m_playposinfo.timeInSeconds = 0.0;

  81. 	

  82.     m_free_filter_envelope = std::make_shared<breakpoint_envelope>();

  83. 	m_free_filter_envelope->SetName("Free filter");

  84. 	m_free_filter_envelope->AddNode({ 0.0,0.75 });

  85. 	m_free_filter_envelope->AddNode({ 1.0,0.75 });

  86. 	m_free_filter_envelope->set_reset_nodes(m_free_filter_envelope->get_all_nodes());

  87.     m_recbuffer.setSize(2, 44100);

  88. 	m_recbuffer.clear();

  89. 	if (m_afm->getNumKnownFormats()==0)

  90. 		m_afm->registerBasicFormats();

  91. 	m_thumb = std::make_unique<AudioThumbnail>(512, *m_afm, *m_thumbcache);

  92. 	

  93. 	m_sm_enab_pars[0] = new AudioParameterBool("enab_specmodule0", "Enable harmonics", false);

  94. 	m_sm_enab_pars[1] = new AudioParameterBool("enab_specmodule1", "Enable tonal vs noise", false);

  95. 	m_sm_enab_pars[2] = new AudioParameterBool("enab_specmodule2", "Enable frequency shift", true);

  96. 	m_sm_enab_pars[3] = new AudioParameterBool("enab_specmodule3", "Enable pitch shift", true);

  97. 	m_sm_enab_pars[4] = new AudioParameterBool("enab_specmodule4", "Enable ratios", false);

  98. 	m_sm_enab_pars[5] = new AudioParameterBool("enab_specmodule5", "Enable spread", false);

  99. 	m_sm_enab_pars[6] = new AudioParameterBool("enab_specmodule6", "Enable filter", true);

  100. 	m_sm_enab_pars[7] = new AudioParameterBool("enab_specmodule7", "Enable free filter", true);

  101. 	m_sm_enab_pars[8] = new AudioParameterBool("enab_specmodule8", "Enable compressor", false);

  102. 	

  103. 

  104. 	m_stretch_source = std::make_unique<StretchAudioSource>(2, m_afm,m_sm_enab_pars);

  105. 	

  106. 	m_stretch_source->setOnsetDetection(0.0);

  107. 	m_stretch_source->setLoopingEnabled(true);

  108. 	m_stretch_source->setFFTWindowingType(1);

  109. 	addParameter(make_floatpar("mainvolume0", "Main volume", -24.0, 12.0, -3.0, 0.1, 1.0)); 

  110. 	addParameter(make_floatpar("stretchamount0", "Stretch amount", 0.1, 1024.0, 2.0, 0.1, 0.25)); 

  111. 	addParameter(make_floatpar("fftsize0", "FFT size", 0.0, 1.0, 0.7, 0.01, 1.0));

  112. 	addParameter(make_floatpar("pitchshift0", "Pitch shift", -24.0f, 24.0f, 0.0f, 0.1,1.0)); // 3

  113. 	addParameter(make_floatpar("freqshift0", "Frequency shift", -1000.0f, 1000.0f, 0.0f, 1.0, 1.0)); // 4

  114. 	addParameter(make_floatpar("playrange_start0", "Sound start", 0.0f, 1.0f, 0.0f, 0.0001,1.0)); // 5

  115. 	addParameter(make_floatpar("playrange_end0", "Sound end", 0.0f, 1.0f, 1.0f, 0.0001,1.0)); // 6

  116. 	addParameter(new AudioParameterBool("freeze0", "Freeze", false)); // 7

  117. 	addParameter(make_floatpar("spread0", "Frequency spread", 0.0f, 1.0f, 0.0f, 0.001,1.0)); // 8

  118. 	addParameter(make_floatpar("compress0", "Compress", 0.0f, 1.0f, 0.0f, 0.001,1.0)); // 9

  119. 	addParameter(make_floatpar("loopxfadelen0", "Loop xfade length", 0.0f, 1.0f, 0.01f, 0.001, 1.0)); // 10

  120.     addParameter(new AudioParameterInt("numharmonics0", "Num harmonics", 1, 100, 10)); // 11

  121. 	addParameter(make_floatpar("harmonicsfreq0", "Harmonics base freq", 1.0, 5000.0, 128.0, 0.1, 0.5));

  122. 	addParameter(make_floatpar("harmonicsbw0", "Harmonics bandwidth", 0.1f, 200.0f, 25.0f, 0.01, 1.0)); // 13

  123. 	addParameter(new AudioParameterBool("harmonicsgauss0", "Gaussian harmonics", false)); // 14

  124. 	addParameter(make_floatpar("octavemixm2_0", "2 octaves down level", 0.0f, 1.0f, 0.0f, 0.001, 1.0)); // 15

  125. 	addParameter(make_floatpar("octavemixm1_0", "Octave down level", 0.0f, 1.0f, 0.0f, 0.001, 1.0)); // 16

  126. 	addParameter(make_floatpar("octavemix0_0", "Normal pitch level", 0.0f, 1.0f, 1.0f, 0.001, 1.0)); // 17

  127. 	addParameter(make_floatpar("octavemix1_0", "1 octave up level", 0.0f, 1.0f, 0.0f, 0.001, 1.0)); // 18

  128. 	addParameter(make_floatpar("octavemix15_0", "1 octave and fifth up level", 0.0f, 1.0f, 0.0f, 0.001, 1.0)); // 19

  129. 	addParameter(make_floatpar("octavemix2_0", "2 octaves up level", 0.0f, 1.0f, 0.0f, 0.001, 1.0)); // 20

  130. 	addParameter(make_floatpar("tonalvsnoisebw_0", "Tonal vs Noise BW", 0.74f, 1.0f, 0.74f, 0.001, 1.0)); // 21

  131. 	addParameter(make_floatpar("tonalvsnoisepreserve_0", "Tonal vs Noise preserve", -1.0f, 1.0f, 0.5f, 0.001, 1.0)); // 22

  132. 	auto filt_convertFrom0To1Func = [](float rangemin, float rangemax, float value) 

  133. 	{

  134. 		if (value < 0.5f)

  135. 			return jmap<float>(value, 0.0f, 0.5f, 20.0f, 1000.0f);

  136. 		return jmap<float>(value, 0.5f, 1.0f, 1000.0f, 20000.0f);

  137. 	};

  138. 	auto filt_convertTo0To1Func = [](float rangemin, float rangemax, float value)

  139. 	{

  140. 		if (value < 1000.0f)

  141. 			return jmap<float>(value, 20.0f, 1000.0f, 0.0f, 0.5f);

  142. 		return jmap<float>(value, 1000.0f, 20000.0f, 0.5f, 1.0f);

  143. 	};

  144. 	addParameter(new AudioParameterFloat("filter_low_0", "Filter low",

  145.                                          NormalisableRange<float>(20.0f, 20000.0f, 

  146. 											 filt_convertFrom0To1Func, filt_convertTo0To1Func), 20.0f)); // 23

  147. 	addParameter(new AudioParameterFloat("filter_high_0", "Filter high",

  148.                                          NormalisableRange<float>(20.0f, 20000.0f, 

  149. 											 filt_convertFrom0To1Func,filt_convertTo0To1Func), 20000.0f));; // 24

  150. 	addParameter(make_floatpar("onsetdetect_0", "Onset detection", 0.0f, 1.0f, 0.0f, 0.01, 1.0)); // 25

  151. 	addParameter(new AudioParameterBool("capture_enabled0", "Capture", false)); // 26

  152. 	m_outchansparam = new AudioParameterInt("numoutchans0", "Num outs", 2, 8, 2); // 27

  153. 	addParameter(m_outchansparam); // 27

  154. 	addParameter(new AudioParameterBool("pause_enabled0", "Pause", false)); // 28

  155. 	addParameter(new AudioParameterFloat("maxcapturelen_0", "Max capture length", 1.0f, 120.0f, 10.0f)); // 29

  156. 	addParameter(new AudioParameterBool("passthrough0", "Pass input through", false)); // 30

  157. 	addParameter(new AudioParameterBool("markdirty0", "Internal (don't use)", false)); // 31

  158. 	m_inchansparam = new AudioParameterInt("numinchans0", "Num ins", 2, 8, 2); // 32

  159. 	addParameter(m_inchansparam); // 32

  160. 	addParameter(new AudioParameterBool("bypass_stretch0", "Bypass stretch", false)); // 33

  161. 	addParameter(new AudioParameterFloat("freefilter_shiftx_0", "Free filter shift X", -1.0f, 1.0f, 0.0f)); // 34

  162. 	addParameter(new AudioParameterFloat("freefilter_shifty_0", "Free filter shift Y", -1.0f, 1.0f, 0.0f)); // 35

  163. 	addParameter(new AudioParameterFloat("freefilter_scaley_0", "Free filter scale Y", -1.0f, 1.0f, 1.0f)); // 36

  164. 	addParameter(new AudioParameterFloat("freefilter_tilty_0", "Free filter tilt Y", -1.0f, 1.0f, 0.0f)); // 37

  165. 	addParameter(new AudioParameterInt("freefilter_randomybands0", "Random bands", 2, 128, 16)); // 38

  166. 	addParameter(new AudioParameterInt("freefilter_randomyrate0", "Random rate", 1, 32, 2)); // 39

  167. 	addParameter(new AudioParameterFloat("freefilter_randomyamount0", "Random amount", 0.0, 1.0, 0.0)); // 40

  168. 	for (int i = 0; i < 9; ++i) // 41-49

  169. 	{

  170. 		addParameter(m_sm_enab_pars[i]);

  171. 		m_sm_enab_pars[i]->addListener(this);

  172. 	}

  173. 

  174. 	addParameter(make_floatpar("octavemix_extra0_0", "Ratio mix 7 level", 0.0f, 1.0f, 0.0f, 0.001, 1.0)); // 50

  175. 	addParameter(make_floatpar("octavemix_extra1_0", "Ratio mix 8 level", 0.0f, 1.0f, 0.0f, 0.001, 1.0)); // 51

  176. 

  177. 	std::array<double,8> initialratios{ 0.25,0.5,1.0,2.0,3.0,4.0,1.5,1.0 / 1.5 };

  178. 	// 52-59

  179. 	for (int i = 0; i < 8; ++i)

  180. 	{

  181. 		addParameter(make_floatpar("ratiomix_ratio_"+String(i)+"_0", "Ratio mix ratio "+String(i+1), 0.125f, 8.0f, 

  182. 			initialratios[i], 

  183. 			0.001, 

  184. 			1.0)); 

  185. 	}

  186. 

  187. 	addParameter(new AudioParameterBool("loop_enabled0", "Loop", true)); // 60

  188. 	addParameter(new AudioParameterBool("rewind0", "Rewind", false)); // 61

  189. 	auto dprate_convertFrom0To1Func = [](float rangemin, float rangemax, float value)

  190. 	{

  191. 		if (value < 0.5f)

  192. 			return jmap<float>(value, 0.0f, 0.5f, 0.1f, 1.0f);

  193. 		return jmap<float>(value, 0.5f, 1.0f, 1.0f, 8.0f);

  194. 	};

  195. 	auto dprate_convertTo0To1Func = [](float rangemin, float rangemax, float value)

  196. 	{

  197. 		if (value < 1.0f)

  198. 			return jmap<float>(value, 0.1f, 1.0f, 0.0f, 0.5f);

  199. 		return jmap<float>(value, 1.0f, 8.0f, 0.5f, 1.0f);

  200. 	};

  201. 	addParameter(new AudioParameterFloat("dryplayrate0", "Dry playrate",

  202. 		NormalisableRange<float>(0.1f, 8.0f,

  203. 			dprate_convertFrom0To1Func, dprate_convertTo0To1Func), 1.0f)); // 62

  204. 	

  205. 	auto& pars = getParameters();

  206. 	for (const auto& p : pars)

  207. 		m_reset_pars.push_back(p->getValue());

  208. 	setPreBufferAmount(2);

  209.     startTimer(1, 50);

  210. 	m_show_technical_info = m_propsfile->m_props_file->getBoolValue("showtechnicalinfo", false);

  211. 	

  212. }

  213. 

  214. PaulstretchpluginAudioProcessor::~PaulstretchpluginAudioProcessor()

  215. {

  216. 	//Logger::writeToLog("PaulX AudioProcessor destroyed");

  217. 	m_thumb->removeAllChangeListeners();

  218. 	m_thumb = nullptr;

  219. 	m_bufferingthread.stopThread(1000);

  220. }

  221. 

  222. void PaulstretchpluginAudioProcessor::resetParameters()

  223. {

  224. 	ScopedLock locker(m_cs);

  225. 	for (int i = 0; i < m_reset_pars.size(); ++i)

  226. 	{

  227. 		if (i!=cpi_main_volume && i!=cpi_passthrough)

  228. 			setParameter(i, m_reset_pars[i]);

  229. 	}

  230. }

  231. 

  232. void PaulstretchpluginAudioProcessor::setPreBufferAmount(int x)

  233. {

  234. 	int temp = jlimit(0, 5, x);

  235. 	if (temp != m_prebuffer_amount || m_use_backgroundbuffering == false)

  236. 	{

  237.         m_use_backgroundbuffering = true;

  238.         m_prebuffer_amount = temp;

  239. 		m_recreate_buffering_source = true;

  240.         ScopedLock locker(m_cs);

  241.         m_prebuffering_inited = false;

  242.         m_cur_num_out_chans = *m_outchansparam;

  243.         //Logger::writeToLog("Switching to use " + String(m_cur_num_out_chans) + " out channels");

  244.         String err;

  245.         startplay({ *getFloatParameter(cpi_soundstart),*getFloatParameter(cpi_soundend) },

  246.                   m_cur_num_out_chans, m_curmaxblocksize, err);

  247.         

  248. 		m_prebuffering_inited = true;

  249. 	}

  250. }

  251. 

  252. int PaulstretchpluginAudioProcessor::getPreBufferAmount()

  253. {

  254. 	if (m_use_backgroundbuffering == false)

  255. 		return -1;

  256. 	return m_prebuffer_amount;

  257. }

  258. 

  259. ValueTree PaulstretchpluginAudioProcessor::getStateTree(bool ignoreoptions, bool ignorefile)

  260. {

  261. 	ValueTree paramtree("paulstretch3pluginstate");

  262. 	storeToTreeProperties(paramtree, nullptr, getParameters());

  263.     if (m_current_file != File() && ignorefile == false)

  264. 	{

  265. 		paramtree.setProperty("importedfile", m_current_file.getFullPathName(), nullptr);

  266. 	}

  267. 	auto specorder = m_stretch_source->getSpectrumProcessOrder();

  268. 	paramtree.setProperty("numspectralstagesb", (int)specorder.size(), nullptr);

  269. 	for (int i = 0; i < specorder.size(); ++i)

  270. 	{

  271. 		paramtree.setProperty("specorderb" + String(i), specorder[i].m_index, nullptr);

  272. 	}

  273. 	if (ignoreoptions == false)

  274. 	{

  275. 		if (m_use_backgroundbuffering)

  276. 			paramtree.setProperty("prebufamount", m_prebuffer_amount, nullptr);

  277. 		else

  278. 			paramtree.setProperty("prebufamount", -1, nullptr);

  279. 		paramtree.setProperty("loadfilewithstate", m_load_file_with_state, nullptr);

  280. 		storeToTreeProperties(paramtree, nullptr, "playwhenhostrunning", m_play_when_host_plays, 

  281. 			"capturewhenhostrunning", m_capture_when_host_plays,"savecapturedaudio",m_save_captured_audio,

  282. 			"mutewhilecapturing",m_mute_while_capturing);

  283. 	}

  284. 	storeToTreeProperties(paramtree, nullptr, "tabaindex", m_cur_tab_index);

  285. 	storeToTreeProperties(paramtree, nullptr, "waveviewrange", m_wave_view_range);

  286.     ValueTree freefilterstate = m_free_filter_envelope->saveState(Identifier("freefilter_envelope"));

  287.     paramtree.addChild(freefilterstate, -1, nullptr);

  288.     return paramtree;

  289. }

  290. 

  291. void PaulstretchpluginAudioProcessor::setStateFromTree(ValueTree tree)

  292. {

  293. 	if (tree.isValid())

  294. 	{

  295. 		{

  296. 			ScopedLock locker(m_cs);

  297.             ValueTree freefilterstate = tree.getChildWithName("freefilter_envelope");

  298.             m_free_filter_envelope->restoreState(freefilterstate);

  299.             m_load_file_with_state = tree.getProperty("loadfilewithstate", true);

  300. 			getFromTreeProperties(tree, "playwhenhostrunning", m_play_when_host_plays, 

  301. 				"capturewhenhostrunning", m_capture_when_host_plays,"mutewhilecapturing",m_mute_while_capturing,

  302. 				"savecapturedaudio",m_save_captured_audio);

  303. 			getFromTreeProperties(tree, "tabaindex", m_cur_tab_index);

  304. 			if (tree.hasProperty("numspectralstagesb"))

  305. 			{

  306. 				std::vector<SpectrumProcess> old_order = m_stretch_source->getSpectrumProcessOrder();

  307. 				std::vector<SpectrumProcess> new_order;

  308. 				int ordersize = tree.getProperty("numspectralstagesb");

  309. 				if (ordersize == old_order.size())

  310. 				{

  311. 					for (int i = 0; i < ordersize; ++i)

  312. 					{

  313. 						int index = tree.getProperty("specorderb" + String(i));

  314. 						new_order.push_back({ (SpectrumProcessType)index, old_order[index].m_enabled });

  315. 					}

  316. 					m_stretch_source->setSpectrumProcessOrder(new_order);

  317. 				}

  318. 			}

  319. 			getFromTreeProperties(tree, "waveviewrange", m_wave_view_range);

  320. 			getFromTreeProperties(tree, getParameters());

  321. 			

  322.         }

  323. 		int prebufamt = tree.getProperty("prebufamount", 2);

  324. 		if (prebufamt == -1)

  325. 			m_use_backgroundbuffering = false;

  326. 		else

  327. 			setPreBufferAmount(prebufamt);

  328. 		if (m_load_file_with_state == true)

  329. 		{

  330. 			String fn = tree.getProperty("importedfile");

  331. 			if (fn.isEmpty() == false)

  332. 			{

  333. 				setAudioFile(File(fn));

  334. 			}

  335. 		}

  336. 		m_state_dirty = true;

  337. 	}

  338. }

  339. 

  340. //==============================================================================

  341. const String PaulstretchpluginAudioProcessor::getName() const

  342. {

  343.     return JucePlugin_Name;

  344. }

  345. 

  346. bool PaulstretchpluginAudioProcessor::acceptsMidi() const

  347. {

  348.    #if JucePlugin_WantsMidiInput

  349.     return true;

  350.    #else

  351.     return false;

  352.    #endif

  353. }

  354. 

  355. bool PaulstretchpluginAudioProcessor::producesMidi() const

  356. {

  357.    #if JucePlugin_ProducesMidiOutput

  358.     return true;

  359.    #else

  360.     return false;

  361.    #endif

  362. }

  363. 

  364. bool PaulstretchpluginAudioProcessor::isMidiEffect() const

  365. {

  366.    #if JucePlugin_IsMidiEffect

  367.     return true;

  368.    #else

  369.     return false;

  370.    #endif

  371. }

  372. 

  373. double PaulstretchpluginAudioProcessor::getTailLengthSeconds() const

  374. {

  375. 	return 0.0;

  376. 	//return (double)m_bufamounts[m_prebuffer_amount]/getSampleRate();

  377. }

  378. 

  379. int PaulstretchpluginAudioProcessor::getNumPrograms()

  380. {

  381. 	return 1;

  382. }

  383. 

  384. int PaulstretchpluginAudioProcessor::getCurrentProgram()

  385. {

  386.     return 0;

  387. }

  388. 

  389. void PaulstretchpluginAudioProcessor::setCurrentProgram (int index)

  390. {

  391. 	

  392. }

  393. 

  394. const String PaulstretchpluginAudioProcessor::getProgramName (int index)

  395. {

  396. 	return String();

  397. }

  398. 

  399. void PaulstretchpluginAudioProcessor::changeProgramName (int index, const String& newName)

  400. {

  401. }

  402. 

  403. void PaulstretchpluginAudioProcessor::parameterValueChanged(int parameterIndex, float newValue)

  404. {

  405. 	if (parameterIndex >= cpi_enable_spec_module0 && parameterIndex <= cpi_enable_spec_module8)

  406. 	{

  407. 		m_stretch_source->setSpectralModuleEnabled(parameterIndex - cpi_enable_spec_module0, newValue >= 0.5);

  408. 	}

  409. }

  410. 

  411. void PaulstretchpluginAudioProcessor::parameterGestureChanged(int parameterIndex, bool gestureIsStarting)

  412. {

  413. }

  414. 

  415. void PaulstretchpluginAudioProcessor::setFFTSize(double size)

  416. {

  417. 	if (m_prebuffer_amount == 5)

  418. 		m_fft_size_to_use = pow(2, 7.0 + size * 14.5);

  419. 	else m_fft_size_to_use = pow(2, 7.0 + size * 10.0); // chicken out from allowing huge FFT sizes if not enough prebuffering

  420. 	int optim = optimizebufsize(m_fft_size_to_use);

  421. 	m_fft_size_to_use = optim;

  422. 	m_stretch_source->setFFTSize(optim);

  423. 	//Logger::writeToLog(String(m_fft_size_to_use));

  424. }

  425. 

  426. void PaulstretchpluginAudioProcessor::startplay(Range<double> playrange, int numoutchans, int maxBlockSize, String& err)

  427. {

  428. 	m_stretch_source->setPlayRange(playrange);

  429. 	m_stretch_source->setFreeFilterEnvelope(m_free_filter_envelope);

  430. 	int bufamt = m_bufamounts[m_prebuffer_amount];

  431. 

  432. 	if (m_buffering_source != nullptr && numoutchans != m_buffering_source->getNumberOfChannels())

  433. 		m_recreate_buffering_source = true;

  434. 	if (m_recreate_buffering_source == true)

  435. 	{

  436. 		m_buffering_source = std::make_unique<MyBufferingAudioSource>(m_stretch_source.get(),

  437. 			m_bufferingthread, false, bufamt, numoutchans, false);

  438. 		m_recreate_buffering_source = false;

  439. 	}

  440. 	if (m_bufferingthread.isThreadRunning() == false)

  441. 		m_bufferingthread.startThread();

  442. 	m_stretch_source->setNumOutChannels(numoutchans);

  443. 	m_stretch_source->setFFTSize(m_fft_size_to_use);

  444. 	m_stretch_source->setProcessParameters(&m_ppar);

  445. 	m_stretch_source->m_prebuffersize = bufamt;

  446. 	m_last_outpos_pos = 0.0;

  447. 	m_last_in_pos = playrange.getStart()*m_stretch_source->getInfileLengthSeconds();

  448. 	m_buffering_source->prepareToPlay(maxBlockSize, getSampleRateChecked());

  449. }

  450. 

  451. void PaulstretchpluginAudioProcessor::setParameters(const std::vector<double>& pars)

  452. {

  453. 	ScopedLock locker(m_cs);

  454. 	for (int i = 0; i < getNumParameters(); ++i)

  455. 	{

  456. 		if (i<pars.size())

  457. 			setParameter(i, pars[i]);

  458. 	}

  459. }

  460. 

  461. void PaulstretchpluginAudioProcessor::updateStretchParametersFromPluginParameters(ProcessParameters & pars)

  462. {

  463. 	pars.pitch_shift.cents = *getFloatParameter(cpi_pitchshift) * 100.0;

  464. 	pars.freq_shift.Hz = *getFloatParameter(cpi_frequencyshift);

  465. 

  466. 	pars.spread.bandwidth = *getFloatParameter(cpi_spreadamount);

  467. 

  468. 	pars.compressor.power = *getFloatParameter(cpi_compress);

  469. 

  470. 	pars.harmonics.nharmonics = *getIntParameter(cpi_numharmonics);

  471. 	pars.harmonics.freq = *getFloatParameter(cpi_harmonicsfreq);

  472. 	pars.harmonics.bandwidth = *getFloatParameter(cpi_harmonicsbw);

  473. 	pars.harmonics.gauss = getParameter(cpi_harmonicsgauss);

  474. 

  475. 	pars.octave.om2 = *getFloatParameter(cpi_octavesm2);

  476. 	pars.octave.om1 = *getFloatParameter(cpi_octavesm1);

  477. 	pars.octave.o0 = *getFloatParameter(cpi_octaves0);

  478. 	pars.octave.o1 = *getFloatParameter(cpi_octaves1);

  479. 	pars.octave.o15 = *getFloatParameter(cpi_octaves15);

  480. 	pars.octave.o2 = *getFloatParameter(cpi_octaves2);

  481. 

  482. 	pars.ratiomix.ratiolevels[0]= *getFloatParameter(cpi_octavesm2);

  483. 	pars.ratiomix.ratiolevels[1] = *getFloatParameter(cpi_octavesm1);

  484. 	pars.ratiomix.ratiolevels[2] = *getFloatParameter(cpi_octaves0);

  485. 	pars.ratiomix.ratiolevels[3] = *getFloatParameter(cpi_octaves1);

  486. 	pars.ratiomix.ratiolevels[4] = *getFloatParameter(cpi_octaves15);

  487. 	pars.ratiomix.ratiolevels[5] = *getFloatParameter(cpi_octaves2);

  488. 	pars.ratiomix.ratiolevels[6] = *getFloatParameter(cpi_octaves_extra1);

  489. 	pars.ratiomix.ratiolevels[7] = *getFloatParameter(cpi_octaves_extra2);

  490. 

  491. 	for (int i = 0; i < 8; ++i)

  492. 		pars.ratiomix.ratios[i] = *getFloatParameter((int)cpi_octaves_ratio0 + i);

  493. 

  494. 	pars.filter.low = *getFloatParameter(cpi_filter_low);

  495. 	pars.filter.high = *getFloatParameter(cpi_filter_high);

  496. 

  497. 	pars.tonal_vs_noise.bandwidth = *getFloatParameter(cpi_tonalvsnoisebw);

  498. 	pars.tonal_vs_noise.preserve = *getFloatParameter(cpi_tonalvsnoisepreserve);

  499. }

  500. 

  501. void PaulstretchpluginAudioProcessor::saveCaptureBuffer()

  502. {

  503. 	auto task = [this]()

  504. 	{

  505. 		int inchans = *getIntParameter(cpi_num_inchans);

  506. 		if (inchans < 1)

  507. 			return;

  508. 		Uuid uid;

  509. 		WavAudioFormat wavformat;

  510. 		String propsdir = m_propsfile->m_props_file->getFile().getParentDirectory().getFullPathName();

  511. 		String outfn;

  512. 		if (m_capture_location.isEmpty())

  513. 			outfn = propsdir + "/paulxstretchaudiocaptures/" + uid.toString() + ".wav";

  514. 		else

  515. 			outfn = m_capture_location + "/pxscapture_" + uid.toString() + ".wav";

  516. 		File outfile(outfn);

  517. 		outfile.create();

  518. 		if (outfile.existsAsFile())

  519. 		{

  520. 			m_capture_save_state = 1;

  521. 			auto outstream = outfile.createOutputStream();

  522. 			auto writer = unique_from_raw(wavformat.createWriterFor(outstream, getSampleRateChecked(),

  523. 				inchans, 32, {}, 0));

  524. 			if (writer != nullptr)

  525. 			{

  526. 				auto sourcebuffer = getStretchSource()->getSourceAudioBuffer();

  527. 				jassert(sourcebuffer->getNumChannels() == inchans);

  528. 				jassert(sourcebuffer->getNumSamples() > 0);

  529. 				

  530. 				writer->writeFromAudioSampleBuffer(*sourcebuffer, 0, sourcebuffer->getNumSamples());

  531. 				m_current_file = outfile;

  532. 			}

  533. 			else

  534. 			{

  535. 				Logger::writeToLog("Could not create wav writer");

  536. 				delete outstream;

  537. 			}

  538. 		}

  539. 		else

  540. 			Logger::writeToLog("Could not create output file");

  541. 		m_capture_save_state = 0;

  542. 	};

  543. 	m_threadpool->addJob(task);

  544. }

  545. 

  546. String PaulstretchpluginAudioProcessor::offlineRender(OfflineRenderParams renderpars)

  547. {

  548. 	File outputfiletouse = renderpars.outputfile.getNonexistentSibling();

  549. 	ValueTree state{ getStateTree(false, false) };

  550. 	auto processor = std::make_shared<PaulstretchpluginAudioProcessor>();

  551. 	

  552. 	processor->setStateFromTree(state);

  553. 	double outsr{ renderpars.outsr };

  554. 	if (outsr < 10.0)

  555. 		outsr = processor->getStretchSource()->getInfileSamplerate();

  556. 	Logger::writeToLog(outputfiletouse.getFullPathName() + " " + String(outsr) + " " + String(renderpars.outputformat));

  557. 	int blocksize{ 1024 };

  558. 	int numoutchans = *processor->getIntParameter(cpi_num_outchans);

  559. 	processor->setPlayConfigDetails(0, numoutchans, outsr, blocksize);

  560. 	processor->prepareToPlay(renderpars.outsr, blocksize);

  561. 	

  562. 	double t0 = *processor->getFloatParameter(cpi_soundstart);

  563. 	double t1 = *processor->getFloatParameter(cpi_soundend);

  564. 	sanitizeTimeRange(t0, t1);

  565. 	

  566. 	

  567. 	auto rendertask = [processor,outputfiletouse, renderpars,blocksize,numoutchans, outsr, this]()

  568. 	{

  569. 		WavAudioFormat wavformat;

  570. 		FileOutputStream* outstream = outputfiletouse.createOutputStream();

  571. 		if (outstream == nullptr)

  572. 		{

  573. 			jassert(false);

  574. 		}

  575. 		int oformattouse{ 16 };

  576. 		bool clipoutput{ false };

  577. 		if (renderpars.outputformat == 1)

  578. 			oformattouse = 24;

  579. 		if (renderpars.outputformat == 2)

  580. 			oformattouse = 32;

  581. 		if (renderpars.outputformat == 3)

  582. 		{

  583. 			oformattouse = 32;

  584. 			clipoutput = true;

  585. 		}

  586. 		auto writer{ unique_from_raw(wavformat.createWriterFor(outstream, getSampleRateChecked(), numoutchans,

  587. 			oformattouse, StringPairArray(), 0)) };

  588. 		if (writer == nullptr)

  589. 		{

  590. 			delete outstream;

  591. 			jassert(false);

  592. 		}

  593. 		AudioBuffer<float> renderbuffer{ numoutchans, blocksize };

  594. 		MidiBuffer dummymidi;

  595. 		auto sc = processor->getStretchSource();

  596. 		double outlensecs = sc->getInfileLengthSeconds()*sc->getRate();

  597. 		int64_t outlen = outlensecs * outsr;

  598. 		int64_t outcounter{ 0 };

  599. 		m_offline_render_state = 0;

  600. 		m_offline_render_cancel_requested = false;

  601. 		processor->setNonRealtime(true);

  602. 		while (outcounter < outlen)

  603. 		{

  604. 			if (m_offline_render_cancel_requested == true)

  605. 				break;

  606. 			processor->processBlock(renderbuffer, dummymidi);

  607. 			writer->writeFromAudioSampleBuffer(renderbuffer, 0, blocksize);

  608. 			outcounter += blocksize;

  609. 			m_offline_render_state = 100.0 / outlen * outcounter;

  610. 		}

  611. 		m_offline_render_state = 200;

  612. 		Logger::writeToLog("Rendered ok!");

  613. 	};

  614. 	std::thread th(rendertask);

  615. 	th.detach();

  616. 	return "Rendered OK";

  617. }

  618. 

  619. double PaulstretchpluginAudioProcessor::getSampleRateChecked()

  620. {

  621. 	if (m_cur_sr < 1.0 || m_cur_sr>1000000.0)

  622. 		return 44100.0;

  623. 	return m_cur_sr;

  624. }

  625. 

  626. void PaulstretchpluginAudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)

  627. {

  628.     ++m_prepare_count;

  629.     ScopedLock locker(m_cs);

  630. 	m_adsr.setSampleRate(sampleRate);

  631. 	m_cur_sr = sampleRate;

  632. 	m_curmaxblocksize = samplesPerBlock;

  633. 	m_input_buffer.setSize(getMainBusNumInputChannels(), samplesPerBlock);

  634. 	*getBoolParameter(cpi_rewind) = false;

  635. 	m_lastrewind = false;

  636. 	int numoutchans = *m_outchansparam;

  637. 	if (numoutchans != m_cur_num_out_chans)

  638. 		m_prebuffering_inited = false;

  639. 	if (m_using_memory_buffer == true)

  640. 	{

  641. 		int len = jlimit(100,m_recbuffer.getNumSamples(), 

  642. 			int(getSampleRateChecked()*(*getFloatParameter(cpi_max_capture_len))));

  643. 		m_stretch_source->setAudioBufferAsInputSource(&m_recbuffer, 

  644. 			getSampleRateChecked(), 

  645. 			len);

  646. 		//m_thumb->reset(m_recbuffer.getNumChannels(), sampleRate, len);

  647. 	}

  648. 	if (m_prebuffering_inited == false)

  649. 	{

  650. 		setFFTSize(*getFloatParameter(cpi_fftsize));

  651. 		m_stretch_source->setProcessParameters(&m_ppar);

  652. 		m_stretch_source->setFFTWindowingType(1);

  653. 		String err;

  654. 		startplay({ *getFloatParameter(cpi_soundstart),*getFloatParameter(cpi_soundend) },

  655. 		numoutchans, samplesPerBlock, err);

  656. 		m_cur_num_out_chans = numoutchans;

  657. 		m_prebuffering_inited = true;

  658. 	}

  659. 	else

  660. 	{

  661. 		m_buffering_source->prepareToPlay(samplesPerBlock, getSampleRateChecked());

  662. 	}

  663. }

  664. 

  665. void PaulstretchpluginAudioProcessor::releaseResources()

  666. {

  667. 	//m_control->stopplay();

  668. 	//m_ready_to_play = false;

  669. }

  670. 

  671. #ifndef JucePlugin_PreferredChannelConfigurations

  672. bool PaulstretchpluginAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const

  673. {

  674.   #if JucePlugin_IsMidiEffect

  675.     ignoreUnused (layouts);

  676.     return true;

  677.   #else

  678.     // This is the place where you check if the layout is supported.

  679.     // In this template code we only support mono or stereo.

  680.     if (layouts.getMainOutputChannelSet() != AudioChannelSet::mono()

  681.      && layouts.getMainOutputChannelSet() != AudioChannelSet::stereo())

  682.         return false;

  683. 

  684.     // This checks if the input layout matches the output layout

  685.    #if ! JucePlugin_IsSynth

  686.     if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())

  687.         return false;

  688.    #endif

  689. 

  690.     return true;

  691.   #endif

  692. }

  693. #endif

  694. 

  695. void copyAudioBufferWrappingPosition(const AudioBuffer<float>& src, AudioBuffer<float>& dest, int destbufpos, int maxdestpos)

  696. {

  697. 	for (int i = 0; i < dest.getNumChannels(); ++i)

  698. 	{

  699. 		int channel_to_copy = i % src.getNumChannels();

  700. 		if (destbufpos + src.getNumSamples() > maxdestpos)

  701. 		{

  702. 			int wrappos = (destbufpos + src.getNumSamples()) % maxdestpos;

  703. 			int partial_len = src.getNumSamples() - wrappos;

  704. 			dest.copyFrom(channel_to_copy, destbufpos, src, channel_to_copy, 0, partial_len);

  705. 			dest.copyFrom(channel_to_copy, partial_len, src, channel_to_copy, 0, wrappos);

  706. 		}

  707. 		else

  708. 		{

  709. 			dest.copyFrom(channel_to_copy, destbufpos, src, channel_to_copy, 0, src.getNumSamples());

  710. 		}

  711. 	}

  712. }

  713. 

  714. /*

  715. void PaulstretchpluginAudioProcessor::processBlock (AudioBuffer<double>& buffer, MidiBuffer&)

  716. {

  717.     jassert(false);

  718. }

  719. */

  720. 

  721. void PaulstretchpluginAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)

  722. {

  723. 	ScopedLock locker(m_cs);

  724. 	const int totalNumInputChannels = getTotalNumInputChannels();

  725. 	const int totalNumOutputChannels = getTotalNumOutputChannels();

  726. 	AudioPlayHead* phead = getPlayHead();

  727. 	if (phead != nullptr)

  728. 	{

  729. 		phead->getCurrentPosition(m_playposinfo);

  730. 	}

  731. 	else

  732. 		m_playposinfo.isPlaying = false;

  733. 	ScopedNoDenormals noDenormals;

  734. 	double srtemp = getSampleRate();

  735. 	if (srtemp != m_cur_sr)

  736. 		m_cur_sr = srtemp;

  737. 	m_prebufsmoother.setSlope(0.9, srtemp / buffer.getNumSamples());

  738. 	m_smoothed_prebuffer_ready = m_prebufsmoother.process(m_buffering_source->getPercentReady());

  739. 	

  740. 	for (int i = 0; i < totalNumInputChannels; ++i)

  741. 		m_input_buffer.copyFrom(i, 0, buffer, i, 0, buffer.getNumSamples());

  742.     for (int i = totalNumInputChannels; i < totalNumOutputChannels; ++i)

  743.         buffer.clear (i, 0, buffer.getNumSamples());

  744. 	if (m_previewcomponent != nullptr)

  745. 	{

  746. 		m_previewcomponent->processBlock(getSampleRate(), buffer);

  747. 		return;

  748. 	}

  749. 	if (m_prebuffering_inited == false)

  750. 		return;

  751. 	if (m_is_recording == true)

  752. 	{

  753. 		if (m_playposinfo.isPlaying == false && m_capture_when_host_plays == true)

  754. 			return;

  755. 		int recbuflenframes = m_max_reclen * getSampleRate();

  756. 		copyAudioBufferWrappingPosition(buffer, m_recbuffer, m_rec_pos, recbuflenframes);

  757. 		m_thumb->addBlock(m_rec_pos, buffer, 0, buffer.getNumSamples());

  758. 		m_rec_pos = (m_rec_pos + buffer.getNumSamples()) % recbuflenframes;

  759. 		m_rec_count += buffer.getNumSamples();

  760. 		if (m_rec_count<recbuflenframes)

  761. 			m_recorded_range = { 0, m_rec_count };

  762. 		if (m_mute_while_capturing == true)

  763. 			buffer.clear();

  764. 		return;

  765. 	}

  766. 	jassert(m_buffering_source != nullptr);

  767. 	jassert(m_bufferingthread.isThreadRunning());

  768. 	double t0 = *getFloatParameter(cpi_soundstart);

  769. 	double t1 = *getFloatParameter(cpi_soundend);

  770. 	sanitizeTimeRange(t0, t1);

  771. 	m_stretch_source->setPlayRange({ t0,t1 });

  772. 	if (m_last_host_playing == false && m_playposinfo.isPlaying)

  773. 	{

  774. 		m_stretch_source->seekPercent(*getFloatParameter(cpi_soundstart));

  775. 		m_last_host_playing = true;

  776. 	}

  777. 	else if (m_last_host_playing == true && m_playposinfo.isPlaying == false)

  778. 	{

  779. 		m_last_host_playing = false;

  780. 	}

  781. 	if (m_play_when_host_plays == true && m_playposinfo.isPlaying == false)

  782. 		return;

  783. 	m_free_filter_envelope->m_transform_x_shift = *getFloatParameter(cpi_freefilter_shiftx);

  784. 	m_free_filter_envelope->m_transform_y_shift = *getFloatParameter(cpi_freefilter_shifty);

  785. 	m_free_filter_envelope->m_transform_y_scale = *getFloatParameter(cpi_freefilter_scaley);

  786. 	m_free_filter_envelope->m_transform_y_tilt = *getFloatParameter(cpi_freefilter_tilty);

  787. 	m_free_filter_envelope->m_transform_y_random_bands = *getIntParameter(cpi_freefilter_randomy_numbands);

  788. 	m_free_filter_envelope->m_transform_y_random_rate = *getIntParameter(cpi_freefilter_randomy_rate);

  789. 	m_free_filter_envelope->m_transform_y_random_amount = *getFloatParameter(cpi_freefilter_randomy_amount);

  790. 

  791. 	

  792. 

  793. 	//m_stretch_source->setSpectralModulesEnabled(m_sm_enab_pars);

  794. 

  795. 	if (m_stretch_source->isLoopEnabled() != *getBoolParameter(cpi_looping_enabled))

  796. 		m_stretch_source->setLoopingEnabled(*getBoolParameter(cpi_looping_enabled));

  797. 	bool rew = *getBoolParameter(cpi_rewind);

  798. 	if (rew != m_lastrewind)

  799. 	{

  800. 		if (rew == true)

  801. 		{

  802. 			*getBoolParameter(cpi_rewind) = false;

  803. 			m_stretch_source->seekPercent(m_stretch_source->getPlayRange().getStart());

  804. 		}

  805. 		m_lastrewind = rew;

  806. 	}

  807. 

  808. 	m_stretch_source->setMainVolume(*getFloatParameter(cpi_main_volume));

  809. 	m_stretch_source->setRate(*getFloatParameter(cpi_stretchamount));

  810. 	m_stretch_source->setPreviewDry(*getBoolParameter(cpi_bypass_stretch));

  811. 	m_stretch_source->setDryPlayrate(*getFloatParameter(cpi_dryplayrate));

  812. 	setFFTSize(*getFloatParameter(cpi_fftsize));

  813. 	

  814. 	updateStretchParametersFromPluginParameters(m_ppar);

  815. 

  816. 	m_stretch_source->setOnsetDetection(*getFloatParameter(cpi_onsetdetection));

  817. 	m_stretch_source->setLoopXFadeLength(*getFloatParameter(cpi_loopxfadelen));

  818. 	

  819. 	

  820. 	

  821. 	m_stretch_source->setFreezing(getParameter(cpi_freeze));

  822. 	m_stretch_source->setPaused(getParameter(cpi_pause_enabled));

  823. 	if (m_midinote_control == true)

  824. 	{

  825. 		MidiBuffer::Iterator midi_it(midiMessages);

  826. 		MidiMessage midi_msg;

  827. 		int midi_msg_pos;

  828. 		while (true)

  829. 		{

  830. 			if (midi_it.getNextEvent(midi_msg, midi_msg_pos) == false)

  831. 				break;

  832. 			if (midi_msg.isNoteOff() && midi_msg.getNoteNumber() == m_midinote_to_use)

  833. 			{

  834. 				m_adsr.noteOff();

  835. 				break;

  836. 			}

  837. 			if (midi_msg.isNoteOn())

  838. 			{

  839. 				m_midinote_to_use = midi_msg.getNoteNumber();

  840. 				m_adsr.setParameters({ 1.0,0.5,0.5,1.0 });

  841. 				m_adsr.noteOn();

  842. 				break;

  843. 			}

  844. 

  845. 		}

  846. 	}

  847. 	if (m_midinote_control == true && m_midinote_to_use >= 0)

  848. 	{

  849. 		int note_offset = m_midinote_to_use - 60;

  850. 		m_ppar.pitch_shift.cents += 100.0*note_offset;

  851. 	}

  852. 	

  853. 	m_stretch_source->setProcessParameters(&m_ppar);

  854. 	AudioSourceChannelInfo aif(buffer);

  855. 	if (isNonRealtime() || m_use_backgroundbuffering == false)

  856. 	{

  857. 		m_stretch_source->getNextAudioBlock(aif);

  858. 	}

  859. 	else

  860. 	{

  861. 		m_buffering_source->getNextAudioBlock(aif);

  862. 	}

  863. 	if (m_is_recording == false && getParameter(cpi_passthrough) > 0.5f)

  864. 	{

  865. 		for (int i = 0; i < totalNumInputChannels; ++i)

  866. 		{

  867. 			buffer.addFrom(i, 0, m_input_buffer, i, 0, buffer.getNumSamples());

  868. 		}

  869. 	}

  870. 	bool abnordetected = false;

  871. 	for (int i = 0; i < buffer.getNumChannels(); ++i)

  872. 	{

  873. 		for (int j = 0; j < buffer.getNumSamples(); ++j)

  874. 		{

  875. 			float sample = buffer.getSample(i,j);

  876. 			if (std::isnan(sample) || std::isinf(sample))

  877. 			{

  878. 				++m_abnormal_output_samples;

  879. 				abnordetected = true;

  880. 			}

  881. 		}

  882. 	}

  883. 	if (abnordetected)

  884. 	{

  885. 		buffer.clear();

  886. 	}

  887. 	else

  888. 	{

  889. 		if (m_midinote_control == true)

  890. 		{

  891. 			m_adsr.applyEnvelopeToBuffer(buffer, 0, buffer.getNumSamples());

  892. 		}

  893. 	}

  894. 	auto ed = dynamic_cast<PaulstretchpluginAudioProcessorEditor*>(getActiveEditor());

  895. 	if (ed != nullptr)

  896. 	{

  897. 		ed->m_sonogram.addAudioBlock(buffer);

  898. 	}

  899. }

  900. 

  901. //==============================================================================

  902. bool PaulstretchpluginAudioProcessor::hasEditor() const

  903. {

  904.     return true; // (change this to false if you choose to not supply an editor)

  905. }

  906. 

  907. AudioProcessorEditor* PaulstretchpluginAudioProcessor::createEditor()

  908. {

  909. 	return new PaulstretchpluginAudioProcessorEditor (*this);

  910. }

  911. 

  912. //==============================================================================

  913. void PaulstretchpluginAudioProcessor::getStateInformation (MemoryBlock& destData)

  914. {

  915. 	ValueTree paramtree = getStateTree(false,false);

  916. 	MemoryOutputStream stream(destData,true);

  917. 	paramtree.writeToStream(stream);

  918. }

  919. 

  920. void PaulstretchpluginAudioProcessor::setStateInformation (const void* data, int sizeInBytes)

  921. {

  922. 	ValueTree tree = ValueTree::readFromData(data, sizeInBytes);

  923. 	setStateFromTree(tree);

  924. }

  925. 

  926. void PaulstretchpluginAudioProcessor::setDirty()

  927. {

  928. 	toggleBool(getBoolParameter(cpi_markdirty));

  929. }

  930. 

  931. void PaulstretchpluginAudioProcessor::setRecordingEnabled(bool b)

  932. {

  933. 	ScopedLock locker(m_cs);

  934. 	int lenbufframes = getSampleRateChecked()*m_max_reclen;

  935. 	if (b == true)

  936. 	{

  937. 		m_using_memory_buffer = true;

  938. 		m_current_file = File();

  939. 		int numchans = *m_inchansparam;

  940. 		m_recbuffer.setSize(numchans, m_max_reclen*getSampleRateChecked()+4096,false,false,true);

  941. 		m_recbuffer.clear();

  942. 		m_rec_pos = 0;

  943. 		m_thumb->reset(m_recbuffer.getNumChannels(), getSampleRateChecked(), lenbufframes);

  944. 		m_is_recording = true;

  945. 		m_recorded_range = Range<int>();

  946. 		m_rec_count = 0;

  947. 	}

  948. 	else

  949. 	{

  950. 		if (m_is_recording == true)

  951. 		{

  952. 			finishRecording(lenbufframes);

  953. 		}

  954. 	}

  955. }

  956. 

  957. double PaulstretchpluginAudioProcessor::getRecordingPositionPercent()

  958. {

  959. 	if (m_is_recording==false)

  960. 		return 0.0;

  961. 	return 1.0 / m_recbuffer.getNumSamples()*m_rec_pos;

  962. }

  963. 

  964. String PaulstretchpluginAudioProcessor::setAudioFile(File f)

  965. {

  966.     auto ai = unique_from_raw(m_afm->createReaderFor(f));

  967. 	if (ai != nullptr)

  968. 	{

  969. 		if (ai->numChannels > 8)

  970. 		{

  971. 			return "Too many channels in file "+f.getFullPathName();

  972. 		}

  973. 		if (ai->bitsPerSample>32)

  974. 		{

  975. 			return "Too high bit depth in file " + f.getFullPathName();

  976. 		}

  977. 		m_thumb->setSource(new FileInputSource(f));

  978. 		ScopedLock locker(m_cs);

  979. 		m_stretch_source->setAudioFile(f);

  980. 		//Range<double> currange{ *getFloatParameter(cpi_soundstart),*getFloatParameter(cpi_soundend) };

  981. 		//if (currange.contains(m_stretch_source->getInfilePositionPercent())==false)

  982. 			m_stretch_source->seekPercent(*getFloatParameter(cpi_soundstart));

  983. 		m_current_file = f;

  984.         m_current_file_date = m_current_file.getLastModificationTime();

  985. 		m_using_memory_buffer = false;

  986. 		setDirty();

  987. 		return String();

  988. 	}

  989. 	return "Could not open file " + f.getFullPathName();

  990. }

  991. 

  992. Range<double> PaulstretchpluginAudioProcessor::getTimeSelection()

  993. {

  994. 	return { *getFloatParameter(cpi_soundstart),*getFloatParameter(cpi_soundend) };

  995. }

  996. 

  997. double PaulstretchpluginAudioProcessor::getPreBufferingPercent()

  998. {

  999. 	if (m_buffering_source==nullptr)

  1000. 		return 0.0;

  1001. 	return m_smoothed_prebuffer_ready;

  1002. }

  1003. 

  1004. void PaulstretchpluginAudioProcessor::timerCallback(int id)

  1005. {

  1006. 	if (id == 1)

  1007. 	{

  1008. 		bool capture = *getBoolParameter(cpi_capture_trigger);

  1009. 		if (capture == false && m_max_reclen != *getFloatParameter(cpi_max_capture_len))

  1010. 		{

  1011. 			m_max_reclen = *getFloatParameter(cpi_max_capture_len);

  1012. 			//Logger::writeToLog("Changing max capture len to " + String(m_max_reclen));

  1013. 		}

  1014. 		if (capture == true && m_is_recording == false)

  1015. 		{

  1016. 			setRecordingEnabled(true);

  1017. 			*getBoolParameter(cpi_capture_trigger)=false;

  1018. 			return;

  1019. 		}

  1020. 		if (capture == true && m_is_recording == true)

  1021. 		{

  1022. 			setRecordingEnabled(false);

  1023. 			*getBoolParameter(cpi_capture_trigger) = false;

  1024. 			return;

  1025. 		}

  1026. 		if (m_cur_num_out_chans != *m_outchansparam)

  1027. 		{

  1028. 			jassert(m_curmaxblocksize > 0);

  1029. 			ScopedLock locker(m_cs);

  1030. 			m_prebuffering_inited = false;

  1031. 			m_cur_num_out_chans = *m_outchansparam;

  1032. 			//Logger::writeToLog("Switching to use " + String(m_cur_num_out_chans) + " out channels");

  1033. 			String err;

  1034. 			startplay({ *getFloatParameter(cpi_soundstart),*getFloatParameter(cpi_soundend) },

  1035. 				m_cur_num_out_chans, m_curmaxblocksize, err);

  1036. 			m_prebuffering_inited = true;

  1037. 		}

  1038. 	}

  1039. }

  1040. 

  1041. void PaulstretchpluginAudioProcessor::setAudioPreview(AudioFilePreviewComponent * afpc)

  1042. {

  1043. 	ScopedLock locker(m_cs);

  1044. 	m_previewcomponent = afpc;

  1045. }

  1046. 

  1047. pointer_sized_int PaulstretchpluginAudioProcessor::handleVstPluginCanDo(int32 index, pointer_sized_int value, void * ptr, float opt)

  1048. {

  1049. 	if (strcmp((char*)ptr, "xenakios") == 0)

  1050. 	{

  1051. 		if (index == 0 && (void*)value!=nullptr)

  1052. 		{

  1053. 			double t0 = *getFloatParameter(cpi_soundstart);

  1054. 			double t1 = *getFloatParameter(cpi_soundend);

  1055. 			double outlen = (t1-t0)*m_stretch_source->getInfileLengthSeconds()*(*getFloatParameter(cpi_stretchamount));

  1056. 			//std::cout << "host requested output length, result " << outlen << "\n";

  1057. 			*((double*)value) = outlen;

  1058. 		}

  1059. 		if (index == 1 && (void*)value!=nullptr)

  1060. 		{

  1061. 			String fn(CharPointer_UTF8((char*)value));

  1062. 			//std::cout << "host requested to set audio file " << fn << "\n";

  1063. 			auto err = setAudioFile(File(fn));

  1064. 			if (err.isEmpty()==false)

  1065. 				std::cout << err << "\n";

  1066. 		}

  1067. 		return 1;

  1068. 	}

  1069. 	

  1070. 	return pointer_sized_int();

  1071. }

  1072. 

  1073. pointer_sized_int PaulstretchpluginAudioProcessor::handleVstManufacturerSpecific(int32 index, pointer_sized_int value, void * ptr, float opt)

  1074. {

  1075. 	return pointer_sized_int();

  1076. }

  1077. 

  1078. void PaulstretchpluginAudioProcessor::finishRecording(int lenrecording)

  1079. {

  1080. 	m_is_recording = false;

  1081. 	m_current_file = File();

  1082. 	m_stretch_source->setAudioBufferAsInputSource(&m_recbuffer, getSampleRateChecked(), lenrecording);

  1083. 	*getFloatParameter(cpi_soundstart) = 0.0f;

  1084. 	*getFloatParameter(cpi_soundend) = jlimit<double>(0.01, 1.0, 1.0 / lenrecording * m_rec_count);

  1085. 	if (m_save_captured_audio == true)

  1086. 	{

  1087. 		saveCaptureBuffer();

  1088. 	}

  1089. }

  1090. 

  1091. AudioProcessor* JUCE_CALLTYPE createPluginFilter()

  1092. {

  1093.     return new PaulstretchpluginAudioProcessor();

  1094. }