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

612 lines
21KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.     This file was auto-generated!

  5. 

  6.     It contains the basic framework code for a JUCE plugin processor.

  7. 

  8.   ==============================================================================

  9. */

  10. 

  11. #include "PluginProcessor.h"

  12. #include "PluginEditor.h"

  13. #include <set>

  14. 

  15. #ifdef WIN32

  16. #undef min

  17. #undef max

  18. #endif

  19. 

  20. std::set<PaulstretchpluginAudioProcessor*> g_activeprocessors;

  21. 

  22. template<typename F>

  23. void callGUI(AudioProcessor* ap, F&& f, bool async)

  24. {

  25.     auto ed = dynamic_cast<PaulstretchpluginAudioProcessorEditor*>(ap->getActiveEditor());

  26.     if (ed)

  27.     {

  28.         if (async == false)

  29.             f(ed);

  30.         else

  31.             MessageManager::callAsync([ed,f]() { f(ed); });

  32.     }

  33. }

  34. 

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

  36. 	int orig_n = n;

  37. 	while (true) {

  38. 		n = orig_n;

  39. 

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

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

  42. 

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

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

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

  46. 		if (n<2) break;

  47. 		if (up) orig_n++;

  48. 		else orig_n--;

  49. 		if (orig_n<4) return 4;

  50. 	};

  51. 	return orig_n;

  52. };

  53. 

  54. int optimizebufsize(int n) {

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

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

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

  58. 	else return n2;

  59. };

  60. 

  61. //==============================================================================

  62. PaulstretchpluginAudioProcessor::PaulstretchpluginAudioProcessor()

  63. 	: m_bufferingthread("pspluginprebufferthread")

  64. #ifndef JucePlugin_PreferredChannelConfigurations

  65.      : AudioProcessor (BusesProperties()

  66.                      #if ! JucePlugin_IsMidiEffect

  67.                       #if ! JucePlugin_IsSynth

  68.                        .withInput  ("Input",  AudioChannelSet::stereo(), true)

  69.                       #endif

  70.                        .withOutput ("Output", AudioChannelSet::stereo(), true)

  71.                      #endif

  72.                        )

  73. #endif

  74. {

  75. 	g_activeprocessors.insert(this);

  76. 	m_recbuffer.setSize(2, 44100);

  77. 	m_recbuffer.clear();

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

  79. 		m_afm->registerBasicFormats();

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

  81. 	

  82. 	setPreBufferAmount(2);

  83. 	m_ppar.pitch_shift.enabled = true;

  84. 	m_ppar.freq_shift.enabled = true;

  85. 	m_ppar.filter.enabled = true;

  86.     m_ppar.compressor.enabled = true;

  87. 	m_stretch_source->setOnsetDetection(0.0);

  88. 	m_stretch_source->setLoopingEnabled(true);

  89. 	m_stretch_source->setFFTWindowingType(1);

  90. 	addParameter(new AudioParameterFloat("mainvolume0", "Main volume", -24.0f, 12.0f, -3.0f)); // 0

  91. 	addParameter(new AudioParameterFloat("stretchamount0", "Stretch amount", 

  92. 		NormalisableRange<float>(0.1f, 1024.0f, 0.01f, 0.25),1.0f)); // 1

  93. 	addParameter(new AudioParameterFloat("fftsize0", "FFT size", 0.0f, 1.0f, 0.7f)); // 2

  94. 	addParameter(new AudioParameterFloat("pitchshift0", "Pitch shift", -24.0f, 24.0f, 0.0f)); // 3

  95. 	addParameter(new AudioParameterFloat("freqshift0", "Frequency shift", -1000.0f, 1000.0f, 0.0f)); // 4

  96. 	addParameter(new AudioParameterFloat("playrange_start0", "Sound start", 0.0f, 1.0f, 0.0f)); // 5

  97. 	addParameter(new AudioParameterFloat("playrange_end0", "Sound end", 0.0f, 1.0f, 1.0f)); // 6

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

  99. 	addParameter(new AudioParameterFloat("spread0", "Frequency spread", 0.0f, 1.0f, 0.0f)); // 8

  100. 	addParameter(new AudioParameterFloat("compress0", "Compress", 0.0f, 1.0f, 0.0f)); // 9

  101. 	addParameter(new AudioParameterFloat("loopxfadelen0", "Loop xfade length", 0.0f, 1.0f, 0.0f)); // 10

  102. 	addParameter(new AudioParameterFloat("numharmonics0", "Num harmonics", 0.0f, 100.0f, 0.0f)); // 11

  103. 	addParameter(new AudioParameterFloat("harmonicsfreq0", "Harmonics base freq", 

  104. 		NormalisableRange<float>(1.0f, 5000.0f, 1.00f, 0.5), 128.0f)); // 12

  105. 	addParameter(new AudioParameterFloat("harmonicsbw0", "Harmonics bandwidth", 0.1f, 200.0f, 25.0f)); // 13

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

  107. 	addParameter(new AudioParameterFloat("octavemixm2_0", "2 octaves down level", 0.0f, 1.0f, 0.0f)); // 15

  108. 	addParameter(new AudioParameterFloat("octavemixm1_0", "Octave down level", 0.0f, 1.0f, 0.0f)); // 16

  109. 	addParameter(new AudioParameterFloat("octavemix0_0", "Normal pitch level", 0.0f, 1.0f, 1.0f)); // 17

  110. 	addParameter(new AudioParameterFloat("octavemix1_0", "1 octave up level", 0.0f, 1.0f, 0.0f)); // 18

  111. 	addParameter(new AudioParameterFloat("octavemix15_0", "1 octave and fifth up level", 0.0f, 1.0f, 0.0f)); // 19

  112. 	addParameter(new AudioParameterFloat("octavemix2_0", "2 octaves up level", 0.0f, 1.0f, 0.0f)); // 20

  113. 	addParameter(new AudioParameterFloat("tonalvsnoisebw_0", "Tonal vs Noise BW", 0.74f, 1.0f, 0.74f)); // 21

  114. 	addParameter(new AudioParameterFloat("tonalvsnoisepreserve_0", "Tonal vs Noise preserve", -1.0f, 1.0f, 0.5f)); // 22

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

  116. 	{

  117. 		if (value < 0.5f)

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

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

  120. 	};

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

  122. 	{

  123. 		if (value < 1000.0f)

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

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

  126. 	};

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

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

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

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

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

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

  133. 	addParameter(new AudioParameterFloat("onsetdetect_0", "Onset detection", 0.0f, 1.0f, 0.0f)); // 25

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

  135. 	m_outchansparam = new AudioParameterInt("numoutchans0", "Num output channels", 2, 8, 2); // 27

  136. 	addParameter(m_outchansparam); // 27

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

  138. 	startTimer(1, 50);

  139. }

  140. 

  141. PaulstretchpluginAudioProcessor::~PaulstretchpluginAudioProcessor()

  142. {

  143. 	g_activeprocessors.erase(this);

  144. 	m_bufferingthread.stopThread(1000);

  145. }

  146. 

  147. void PaulstretchpluginAudioProcessor::setPreBufferAmount(int x)

  148. {

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

  150. 	if (temp != m_prebuffer_amount)

  151. 	{

  152. 		m_prebuffer_amount = temp;

  153. 		m_recreate_buffering_source = true;

  154. 	}

  155. }

  156. 

  157. //==============================================================================

  158. const String PaulstretchpluginAudioProcessor::getName() const

  159. {

  160.     return JucePlugin_Name;

  161. }

  162. 

  163. bool PaulstretchpluginAudioProcessor::acceptsMidi() const

  164. {

  165.    #if JucePlugin_WantsMidiInput

  166.     return true;

  167.    #else

  168.     return false;

  169.    #endif

  170. }

  171. 

  172. bool PaulstretchpluginAudioProcessor::producesMidi() const

  173. {

  174.    #if JucePlugin_ProducesMidiOutput

  175.     return true;

  176.    #else

  177.     return false;

  178.    #endif

  179. }

  180. 

  181. bool PaulstretchpluginAudioProcessor::isMidiEffect() const

  182. {

  183.    #if JucePlugin_IsMidiEffect

  184.     return true;

  185.    #else

  186.     return false;

  187.    #endif

  188. }

  189. 

  190. double PaulstretchpluginAudioProcessor::getTailLengthSeconds() const

  191. {

  192. 	return 0.0;

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

  194. }

  195. 

  196. int PaulstretchpluginAudioProcessor::getNumPrograms()

  197. {

  198.     return 1;   // NB: some hosts don't cope very well if you tell them there are 0 programs,

  199.                 // so this should be at least 1, even if you're not really implementing programs.

  200. }

  201. 

  202. int PaulstretchpluginAudioProcessor::getCurrentProgram()

  203. {

  204.     return 0;

  205. }

  206. 

  207. void PaulstretchpluginAudioProcessor::setCurrentProgram (int index)

  208. {

  209. }

  210. 

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

  212. {

  213.     return {};

  214. }

  215. 

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

  217. {

  218. }

  219. 

  220. void PaulstretchpluginAudioProcessor::setFFTSize(double size)

  221. {

  222. 	if (m_prebuffer_amount == 5)

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

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

  225. 	int optim = optimizebufsize(m_fft_size_to_use);

  226. 	m_fft_size_to_use = optim;

  227. 	m_stretch_source->setFFTSize(optim);

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

  229. }

  230. 

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

  232. {

  233. 	m_stretch_source->setPlayRange(playrange, true);

  234. 

  235. 	int bufamt = m_bufamounts[m_prebuffer_amount];

  236. 

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

  238. 		m_recreate_buffering_source = true;

  239. 	if (m_recreate_buffering_source == true)

  240. 	{

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

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

  243. 		m_recreate_buffering_source = false;

  244. 	}

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

  246. 		m_bufferingthread.startThread();

  247. 	m_stretch_source->setNumOutChannels(numoutchans);

  248. 	m_stretch_source->setFFTSize(m_fft_size_to_use);

  249. 	m_stretch_source->setProcessParameters(&m_ppar);

  250. 	m_last_outpos_pos = 0.0;

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

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

  253. }

  254. double PaulstretchpluginAudioProcessor::getSampleRateChecked()

  255. {

  256. 	if (m_cur_sr < 1.0)

  257. 		return 44100.0;

  258. 	return m_cur_sr;

  259. }

  260. 

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

  262. {

  263. 	ScopedLock locker(m_cs);

  264. 	m_cur_sr = sampleRate;

  265. 	m_curmaxblocksize = samplesPerBlock;

  266. 	int numoutchans = *m_outchansparam;

  267. 	if (numoutchans != m_cur_num_out_chans)

  268. 		m_ready_to_play = false;

  269. 	if (m_using_memory_buffer == true)

  270. 	{

  271. 		int len = jlimit(100,m_recbuffer.getNumSamples(), m_rec_pos);

  272. 		m_stretch_source->setAudioBufferAsInputSource(&m_recbuffer, 

  273. 			getSampleRateChecked(), 

  274. 			len);

  275. 		callGUI(this,[this,len](auto ed) { ed->setAudioBuffer(&m_recbuffer, getSampleRateChecked(), len); },false);

  276. 	}

  277. 	if (m_ready_to_play == false)

  278. 	{

  279. 		setFFTSize(*getFloatParameter(cpi_fftsize));

  280. 		m_stretch_source->setProcessParameters(&m_ppar);

  281. 		m_stretch_source->setFFTWindowingType(1);

  282. 		String err;

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

  284. 		numoutchans, samplesPerBlock, err);

  285. 		m_cur_num_out_chans = numoutchans;

  286. 		m_ready_to_play = true;

  287. 	}

  288. }

  289. 

  290. void PaulstretchpluginAudioProcessor::releaseResources()

  291. {

  292. 	//m_control->stopplay();

  293. 	//m_ready_to_play = false;

  294. }

  295. 

  296. #ifndef JucePlugin_PreferredChannelConfigurations

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

  298. {

  299.   #if JucePlugin_IsMidiEffect

  300.     ignoreUnused (layouts);

  301.     return true;

  302.   #else

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

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

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

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

  307.         return false;

  308. 

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

  310.    #if ! JucePlugin_IsSynth

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

  312.         return false;

  313.    #endif

  314. 

  315.     return true;

  316.   #endif

  317. }

  318. #endif

  319. 

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

  321. {

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

  323. 	{

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

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

  326. 		{

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

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

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

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

  331. 		}

  332. 		else

  333. 		{

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

  335. 		}

  336. 	}

  337. }

  338. 

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

  340. {

  341. 	ScopedLock locker(m_cs);

  342. 	ScopedNoDenormals noDenormals;

  343. 	double srtemp = getSampleRate();

  344. 	if (srtemp != m_cur_sr)

  345. 		m_cur_sr = srtemp;

  346.     const int totalNumInputChannels  = getTotalNumInputChannels();

  347.     const int totalNumOutputChannels = getTotalNumOutputChannels();

  348. 

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

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

  351. 	if (m_ready_to_play == false)

  352. 		return;

  353. 	if (m_is_recording == true)

  354. 	{

  355. 		int recbuflenframes = m_max_reclen * getSampleRate();

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

  357. 		callGUI(this,[this, &buffer](PaulstretchpluginAudioProcessorEditor*ed) 

  358. 		{

  359. 			ed->addAudioBlock(buffer, getSampleRate(), m_rec_pos);

  360. 		}, false);

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

  362. 		return;

  363. 	}

  364. 	jassert(m_buffering_source != nullptr);

  365. 	jassert(m_bufferingthread.isThreadRunning());

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

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

  368. 

  369. 	setFFTSize(*getFloatParameter(cpi_fftsize));

  370. 	m_ppar.pitch_shift.cents = *getFloatParameter(cpi_pitchshift) * 100.0;

  371. 	m_ppar.freq_shift.Hz = *getFloatParameter(cpi_frequencyshift);

  372. 	m_ppar.spread.enabled = *getFloatParameter(cpi_spreadamount) > 0.0f;

  373. 	m_ppar.spread.bandwidth = *getFloatParameter(cpi_spreadamount);

  374.     m_ppar.compressor.enabled = *getFloatParameter(cpi_compress)>0.0f;

  375.     m_ppar.compressor.power = *getFloatParameter(cpi_compress);

  376. 	m_ppar.harmonics.enabled = *getFloatParameter(cpi_numharmonics)>=1.0;

  377. 	m_ppar.harmonics.nharmonics = *getFloatParameter(cpi_numharmonics);

  378. 	m_ppar.harmonics.freq = *getFloatParameter(cpi_harmonicsfreq);

  379.     m_ppar.harmonics.bandwidth = *getFloatParameter(cpi_harmonicsbw);

  380.     m_ppar.harmonics.gauss = getParameter(cpi_harmonicsgauss);

  381. 	m_ppar.octave.om2 = *getFloatParameter(cpi_octavesm2);

  382. 	m_ppar.octave.om1 = *getFloatParameter(cpi_octavesm1);

  383. 	m_ppar.octave.o0 = *getFloatParameter(cpi_octaves0);

  384. 	m_ppar.octave.o1 = *getFloatParameter(cpi_octaves1);

  385. 	m_ppar.octave.o15 = *getFloatParameter(cpi_octaves15);

  386. 	m_ppar.octave.o2 = *getFloatParameter(cpi_octaves2);

  387. 	m_ppar.octave.enabled = true;

  388. 	m_ppar.filter.low = *getFloatParameter(cpi_filter_low);

  389. 	m_ppar.filter.high = *getFloatParameter(cpi_filter_high);

  390. 	m_ppar.tonal_vs_noise.enabled = (*getFloatParameter(cpi_tonalvsnoisebw)) > 0.75;

  391. 	m_ppar.tonal_vs_noise.bandwidth = *getFloatParameter(cpi_tonalvsnoisebw);

  392. 	m_ppar.tonal_vs_noise.preserve = *getFloatParameter(cpi_tonalvsnoisepreserve);

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

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

  395. 	double t0 = *getFloatParameter(cpi_soundstart);

  396. 	double t1 = *getFloatParameter(cpi_soundend);

  397. 	if (t0 > t1)

  398. 		std::swap(t0, t1);

  399. 	if (t1 - t0 < 0.001)

  400. 		t1 = t0 + 0.001;

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

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

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

  404. 	m_stretch_source->setProcessParameters(&m_ppar);

  405. 	

  406. 	AudioSourceChannelInfo aif(buffer);

  407. 	m_buffering_source->getNextAudioBlock(aif);

  408. }

  409. 

  410. //==============================================================================

  411. bool PaulstretchpluginAudioProcessor::hasEditor() const

  412. {

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

  414. }

  415. 

  416. AudioProcessorEditor* PaulstretchpluginAudioProcessor::createEditor()

  417. {

  418. 	return new PaulstretchpluginAudioProcessorEditor (*this);

  419. }

  420. 

  421. //==============================================================================

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

  423. {

  424. 	ValueTree paramtree("paulstretch3pluginstate");

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

  426. 	{

  427. 		auto par = getFloatParameter(i);

  428. 		if (par != nullptr)

  429. 		{

  430. 			paramtree.setProperty(par->paramID, (double)*par, nullptr);

  431. 		}

  432. 	}

  433. 	paramtree.setProperty(m_outchansparam->paramID, (int)*m_outchansparam, nullptr);

  434. 	if (m_current_file != File())

  435. 	{

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

  437. 	}

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

  439. 	paramtree.setProperty("numspectralstages", (int)specorder.size(), nullptr);

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

  441. 	{

  442. 		paramtree.setProperty("specorder" + String(i), specorder[i], nullptr);

  443. 	}

  444. 	MemoryOutputStream stream(destData,true);

  445. 	paramtree.writeToStream(stream);

  446. }

  447. 

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

  449. {

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

  451. 	if (tree.isValid())

  452. 	{

  453. 		{

  454. 			ScopedLock locker(m_cs);

  455. 			if (tree.hasProperty("numspectralstages"))

  456. 			{

  457. 				std::vector<int> order;

  458. 				int ordersize = tree.getProperty("numspectralstages");

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

  460. 				{

  461. 					order.push_back((int)tree.getProperty("specorder" + String(i)));

  462. 				}

  463. 				m_stretch_source->setSpectrumProcessOrder(order);

  464. 			}

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

  466. 			{

  467. 				auto par = getFloatParameter(i);

  468. 				if (par != nullptr)

  469. 				{

  470. 					double parval = tree.getProperty(par->paramID, (double)*par);

  471. 					*par = parval;

  472. 				}

  473. 			}

  474. 			if (tree.hasProperty(m_outchansparam->paramID))

  475. 				*m_outchansparam = tree.getProperty(m_outchansparam->paramID, 2);

  476. 

  477. 		}

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

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

  480. 		{

  481. 			File f(fn);

  482. 			setAudioFile(f);

  483. 		}

  484. 	}

  485. }

  486. 

  487. void PaulstretchpluginAudioProcessor::setRecordingEnabled(bool b)

  488. {

  489. 	ScopedLock locker(m_cs);

  490. 	int lenbufframes = getSampleRateChecked()*m_max_reclen;

  491. 	if (b == true)

  492. 	{

  493. 		m_using_memory_buffer = true;

  494. 		m_current_file = File();

  495. 		m_recbuffer.setSize(2, m_max_reclen*getSampleRateChecked()+4096,false,false,true);

  496. 		m_recbuffer.clear();

  497. 		m_rec_pos = 0;

  498. 		callGUI(this,[this,lenbufframes](PaulstretchpluginAudioProcessorEditor* ed)

  499. 		{

  500. 			ed->beginAddingAudioBlocks(2, getSampleRateChecked(), lenbufframes);

  501. 		},false);

  502. 		m_is_recording = true;

  503. 	}

  504. 	else

  505. 	{

  506. 		if (m_is_recording == true)

  507. 		{

  508. 			finishRecording(lenbufframes);

  509. 		}

  510. 	}

  511. }

  512. 

  513. double PaulstretchpluginAudioProcessor::getRecordingPositionPercent()

  514. {

  515. 	if (m_is_recording==false)

  516. 		return 0.0;

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

  518. }

  519. 

  520. String PaulstretchpluginAudioProcessor::setAudioFile(File f)

  521. {

  522.     //if (f==File())

  523.     //    return String();

  524.     //if (f==m_current_file && f.getLastModificationTime()==m_current_file_date)

  525.     //    return String();

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

  527. 	if (ai != nullptr)

  528. 	{

  529. 		if (ai->numChannels > 32)

  530. 		{

  531. 			//MessageManager::callAsync([cb, file]() { cb("Too many channels in file " + file.getFullPathName()); });

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

  533. 		}

  534. 		if (ai->bitsPerSample>32)

  535. 		{

  536. 			//MessageManager::callAsync([cb, file]() { cb("Too high bit depth in file " + file.getFullPathName()); });

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

  538. 		}

  539. 		ScopedLock locker(m_cs);

  540. 		m_stretch_source->setAudioFile(f);

  541. 		m_current_file = f;

  542.         m_current_file_date = m_current_file.getLastModificationTime();

  543. 		m_using_memory_buffer = false;

  544. 		return String();

  545. 		//MessageManager::callAsync([cb, file]() { cb(String()); });

  546. 

  547. 	}

  548. 	

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

  550. }

  551. 

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

  553. {

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

  555. }

  556. 

  557. double PaulstretchpluginAudioProcessor::getPreBufferingPercent()

  558. {

  559. 	if (m_buffering_source==nullptr)

  560. 		return 0.0;

  561. 	return m_buffering_source->getPercentReady();

  562. }

  563. 

  564. void PaulstretchpluginAudioProcessor::timerCallback(int id)

  565. {

  566. 	if (id == 1)

  567. 	{

  568. 		bool capture = getParameter(cpi_capture_enabled);

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

  570. 		{

  571. 			setRecordingEnabled(true);

  572. 			return;

  573. 		}

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

  575. 		{

  576. 			setRecordingEnabled(false);

  577. 			return;

  578. 		}

  579. 		if (m_cur_num_out_chans != *m_outchansparam)

  580. 		{

  581. 			jassert(m_curmaxblocksize > 0);

  582. 			ScopedLock locker(m_cs);

  583. 			m_ready_to_play = false;

  584. 			m_cur_num_out_chans = *m_outchansparam;

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

  586. 			String err;

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

  588. 				m_cur_num_out_chans, m_curmaxblocksize, err);

  589. 			m_ready_to_play = true;

  590. 		}

  591. 	}

  592. }

  593. 

  594. void PaulstretchpluginAudioProcessor::finishRecording(int lenrecording)

  595. {

  596. 	m_is_recording = false;

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

  598. 	m_stretch_source->setPlayRange({ *getFloatParameter(cpi_soundstart),*getFloatParameter(cpi_soundend) }, true);

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

  600. 	if (ed)

  601. 	{

  602. 		//ed->setAudioBuffer(&m_recbuffer, getSampleRate(), lenrecording);

  603. 	}

  604. }

  605. 

  606. //==============================================================================

  607. // This creates new instances of the plugin..

  608. AudioProcessor* JUCE_CALLTYPE createPluginFilter()

  609. {

  610.     return new PaulstretchpluginAudioProcessor();

  611. }