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

571 lines
19KB
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, 128.0f, 0.01f, 0.5),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. 	addParameter(new AudioParameterFloat("filter_low_0", "Filter low",

  116.                                          NormalisableRange<float>(20.0f, 10000.0f, 1.0f, 0.3), 20.0f)); // 23

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

  118.                                          NormalisableRange<float>(100.0f, 20000.0f, 1.0f, 0.3), 20000.0f));; // 24

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

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

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

  122. 	addParameter(m_outchansparam); // 27

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

  124. 	startTimer(1, 50);

  125. }

  126. 

  127. PaulstretchpluginAudioProcessor::~PaulstretchpluginAudioProcessor()

  128. {

  129. 	g_activeprocessors.erase(this);

  130. 	m_bufferingthread.stopThread(1000);

  131. }

  132. 

  133. void PaulstretchpluginAudioProcessor::setPreBufferAmount(int x)

  134. {

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

  136. 	if (temp != m_prebuffer_amount)

  137. 	{

  138. 		m_prebuffer_amount = temp;

  139. 		m_recreate_buffering_source = true;

  140. 	}

  141. }

  142. 

  143. //==============================================================================

  144. const String PaulstretchpluginAudioProcessor::getName() const

  145. {

  146.     return JucePlugin_Name;

  147. }

  148. 

  149. bool PaulstretchpluginAudioProcessor::acceptsMidi() const

  150. {

  151.    #if JucePlugin_WantsMidiInput

  152.     return true;

  153.    #else

  154.     return false;

  155.    #endif

  156. }

  157. 

  158. bool PaulstretchpluginAudioProcessor::producesMidi() const

  159. {

  160.    #if JucePlugin_ProducesMidiOutput

  161.     return true;

  162.    #else

  163.     return false;

  164.    #endif

  165. }

  166. 

  167. bool PaulstretchpluginAudioProcessor::isMidiEffect() const

  168. {

  169.    #if JucePlugin_IsMidiEffect

  170.     return true;

  171.    #else

  172.     return false;

  173.    #endif

  174. }

  175. 

  176. double PaulstretchpluginAudioProcessor::getTailLengthSeconds() const

  177. {

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

  179. }

  180. 

  181. int PaulstretchpluginAudioProcessor::getNumPrograms()

  182. {

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

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

  185. }

  186. 

  187. int PaulstretchpluginAudioProcessor::getCurrentProgram()

  188. {

  189.     return 0;

  190. }

  191. 

  192. void PaulstretchpluginAudioProcessor::setCurrentProgram (int index)

  193. {

  194. }

  195. 

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

  197. {

  198.     return {};

  199. }

  200. 

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

  202. {

  203. }

  204. 

  205. void PaulstretchpluginAudioProcessor::setFFTSize(double size)

  206. {

  207. 	if (m_prebuffer_amount == 5)

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

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

  210. 	int optim = optimizebufsize(m_fft_size_to_use);

  211. 	m_fft_size_to_use = optim;

  212. 	m_stretch_source->setFFTSize(optim);

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

  214. }

  215. 

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

  217. {

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

  219. 

  220. 	int bufamt = m_bufamounts[m_prebuffer_amount];

  221. 

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

  223. 		m_recreate_buffering_source = true;

  224. 	if (m_recreate_buffering_source == true)

  225. 	{

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

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

  228. 		m_recreate_buffering_source = false;

  229. 	}

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

  231. 		m_bufferingthread.startThread();

  232. 	m_stretch_source->setNumOutChannels(numoutchans);

  233. 	m_stretch_source->setFFTSize(m_fft_size_to_use);

  234. 	m_stretch_source->setProcessParameters(&m_ppar);

  235. 	m_last_outpos_pos = 0.0;

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

  237. 	m_buffering_source->prepareToPlay(maxBlockSize, getSampleRate());

  238. };

  239. 

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

  241. {

  242. 	ScopedLock locker(m_cs);

  243. 	m_curmaxblocksize = samplesPerBlock;

  244. 	int numoutchans = *m_outchansparam;

  245. 	if (numoutchans != m_cur_num_out_chans)

  246. 		m_ready_to_play = false;

  247. 	if (m_using_memory_buffer == true)

  248. 	{

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

  250. 		m_stretch_source->setAudioBufferAsInputSource(&m_recbuffer, 

  251. 			getSampleRate(), 

  252. 			len);

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

  254. 	}

  255. 	if (m_ready_to_play == false)

  256. 	{

  257. 		setFFTSize(*getFloatParameter(cpi_fftsize));

  258. 		m_stretch_source->setProcessParameters(&m_ppar);

  259. 		m_stretch_source->setFFTWindowingType(1);

  260. 		String err;

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

  262. 		numoutchans, samplesPerBlock, err);

  263. 		m_cur_num_out_chans = numoutchans;

  264. 		m_ready_to_play = true;

  265. 	}

  266. }

  267. 

  268. void PaulstretchpluginAudioProcessor::releaseResources()

  269. {

  270. 	//m_control->stopplay();

  271. 	//m_ready_to_play = false;

  272. }

  273. 

  274. #ifndef JucePlugin_PreferredChannelConfigurations

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

  276. {

  277.   #if JucePlugin_IsMidiEffect

  278.     ignoreUnused (layouts);

  279.     return true;

  280.   #else

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

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

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

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

  285.         return false;

  286. 

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

  288.    #if ! JucePlugin_IsSynth

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

  290.         return false;

  291.    #endif

  292. 

  293.     return true;

  294.   #endif

  295. }

  296. #endif

  297. 

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

  299. {

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

  301. 	{

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

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

  304. 		{

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

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

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

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

  309. 		}

  310. 		else

  311. 		{

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

  313. 		}

  314. 	}

  315. }

  316. 

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

  318. {

  319. 	ScopedLock locker(m_cs);

  320. 	ScopedNoDenormals noDenormals;

  321.     const int totalNumInputChannels  = getTotalNumInputChannels();

  322.     const int totalNumOutputChannels = getTotalNumOutputChannels();

  323. 

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

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

  326. 	if (m_ready_to_play == false)

  327. 		return;

  328. 	if (m_is_recording == true)

  329. 	{

  330. 		int recbuflenframes = m_max_reclen * getSampleRate();

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

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

  333. 		{

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

  335. 		}, false);

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

  337. 		return;

  338. 	}

  339. 	jassert(m_buffering_source != nullptr);

  340. 	jassert(m_bufferingthread.isThreadRunning());

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

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

  343. 

  344. 	setFFTSize(*getFloatParameter(cpi_fftsize));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  362. 	m_ppar.octave.enabled = true;

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

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

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

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

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

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

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

  370. 	double t0 = *getFloatParameter(cpi_soundstart);

  371. 	double t1 = *getFloatParameter(cpi_soundend);

  372. 	if (t0 > t1)

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

  374. 	if (t1 - t0 < 0.001)

  375. 		t1 = t0 + 0.001;

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

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

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

  379. 	m_stretch_source->setProcessParameters(&m_ppar);

  380. 	

  381. 	AudioSourceChannelInfo aif(buffer);

  382. 	m_buffering_source->getNextAudioBlock(aif);

  383. }

  384. 

  385. //==============================================================================

  386. bool PaulstretchpluginAudioProcessor::hasEditor() const

  387. {

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

  389. }

  390. 

  391. AudioProcessorEditor* PaulstretchpluginAudioProcessor::createEditor()

  392. {

  393. 	return new PaulstretchpluginAudioProcessorEditor (*this);

  394. }

  395. 

  396. //==============================================================================

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

  398. {

  399. 	ValueTree paramtree("paulstretch3pluginstate");

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

  401. 	{

  402. 		auto par = getFloatParameter(i);

  403. 		if (par != nullptr)

  404. 		{

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

  406. 		}

  407. 	}

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

  409. 	if (m_current_file != File())

  410. 	{

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

  412. 	}

  413. 	MemoryOutputStream stream(destData,true);

  414. 	paramtree.writeToStream(stream);

  415. }

  416. 

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

  418. {

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

  420. 	if (tree.isValid())

  421. 	{

  422. 		{

  423. 			ScopedLock locker(m_cs);

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

  425. 			{

  426. 				auto par = getFloatParameter(i);

  427. 				if (par != nullptr)

  428. 				{

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

  430. 					*par = parval;

  431. 				}

  432. 			}

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

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

  435. 

  436. 		}

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

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

  439. 		{

  440. 			File f(fn);

  441. 			setAudioFile(f);

  442. 		}

  443. 	}

  444. }

  445. 

  446. void PaulstretchpluginAudioProcessor::setRecordingEnabled(bool b)

  447. {

  448. 	ScopedLock locker(m_cs);

  449. 	int lenbufframes = getSampleRate()*m_max_reclen;

  450. 	if (b == true)

  451. 	{

  452. 		m_using_memory_buffer = true;

  453. 		m_current_file = File();

  454. 		m_recbuffer.setSize(2, m_max_reclen*getSampleRate()+4096,false,false,true);

  455. 		m_recbuffer.clear();

  456. 		m_rec_pos = 0;

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

  458. 		{

  459. 			ed->beginAddingAudioBlocks(2, getSampleRate(), lenbufframes);

  460. 		},false);

  461. 		m_is_recording = true;

  462. 	}

  463. 	else

  464. 	{

  465. 		if (m_is_recording == true)

  466. 		{

  467. 			finishRecording(lenbufframes);

  468. 		}

  469. 	}

  470. }

  471. 

  472. double PaulstretchpluginAudioProcessor::getRecordingPositionPercent()

  473. {

  474. 	if (m_is_recording==false)

  475. 		return 0.0;

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

  477. }

  478. 

  479. String PaulstretchpluginAudioProcessor::setAudioFile(File f)

  480. {

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

  482.     //    return String();

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

  484.     //    return String();

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

  486. 	if (ai != nullptr)

  487. 	{

  488. 		if (ai->numChannels > 32)

  489. 		{

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

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

  492. 		}

  493. 		if (ai->bitsPerSample>32)

  494. 		{

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

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

  497. 		}

  498. 		ScopedLock locker(m_cs);

  499. 		m_stretch_source->setAudioFile(f);

  500. 		m_current_file = f;

  501.         m_current_file_date = m_current_file.getLastModificationTime();

  502. 		m_using_memory_buffer = false;

  503. 		return String();

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

  505. 

  506. 	}

  507. 	

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

  509. }

  510. 

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

  512. {

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

  514. }

  515. 

  516. double PaulstretchpluginAudioProcessor::getPreBufferingPercent()

  517. {

  518. 	if (m_buffering_source==nullptr)

  519. 		return 0.0;

  520. 	return m_buffering_source->getPercentReady();

  521. }

  522. 

  523. void PaulstretchpluginAudioProcessor::timerCallback(int id)

  524. {

  525. 	if (id == 1)

  526. 	{

  527. 		bool capture = getParameter(cpi_capture_enabled);

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

  529. 		{

  530. 			setRecordingEnabled(true);

  531. 			return;

  532. 		}

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

  534. 		{

  535. 			setRecordingEnabled(false);

  536. 			return;

  537. 		}

  538. 		if (m_cur_num_out_chans != *m_outchansparam)

  539. 		{

  540. 			jassert(m_curmaxblocksize > 0);

  541. 			ScopedLock locker(m_cs);

  542. 			m_ready_to_play = false;

  543. 			m_cur_num_out_chans = *m_outchansparam;

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

  545. 			String err;

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

  547. 				m_cur_num_out_chans, m_curmaxblocksize, err);

  548. 			m_ready_to_play = true;

  549. 		}

  550. 	}

  551. }

  552. 

  553. void PaulstretchpluginAudioProcessor::finishRecording(int lenrecording)

  554. {

  555. 	m_is_recording = false;

  556. 	m_stretch_source->setAudioBufferAsInputSource(&m_recbuffer, getSampleRate(), lenrecording);

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

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

  559. 	if (ed)

  560. 	{

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

  562. 	}

  563. }

  564. 

  565. //==============================================================================

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

  567. AudioProcessor* JUCE_CALLTYPE createPluginFilter()

  568. {

  569.     return new PaulstretchpluginAudioProcessor();

  570. }