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

680 lines
23KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2006-2011 Nasca Octavian Paul

  3. Author: Nasca Octavian Paul

  4. 

  5. Copyright (C) 2017 Xenakios

  6. 

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

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

  9. as published by the Free Software Foundation.

  10. 

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

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

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

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

  15. 

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

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

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

  19. */

  20. 

  21. #include "PluginProcessor.h"

  22. #include "PluginEditor.h"

  23. #include <set>

  24. 

  25. #ifdef WIN32

  26. #undef min

  27. #undef max

  28. #endif

  29. 

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

  31. 

  32. template<typename F>

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

  34. {

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

  36.     if (ed)

  37.     {

  38.         if (async == false)

  39.             f(ed);

  40.         else

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

  42.     }

  43. }

  44. 

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

  46. 	int orig_n = n;

  47. 	while (true) {

  48. 		n = orig_n;

  49. 

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

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

  52. 

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

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

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

  56. 		if (n<2) break;

  57. 		if (up) orig_n++;

  58. 		else orig_n--;

  59. 		if (orig_n<4) return 4;

  60. 	};

  61. 	return orig_n;

  62. };

  63. 

  64. int optimizebufsize(int n) {

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

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

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

  68. 	else return n2;

  69. };

  70. 

  71. //==============================================================================

  72. PaulstretchpluginAudioProcessor::PaulstretchpluginAudioProcessor()

  73. 	: m_bufferingthread("pspluginprebufferthread")

  74. #ifndef JucePlugin_PreferredChannelConfigurations

  75.      : AudioProcessor (BusesProperties()

  76.                      #if ! JucePlugin_IsMidiEffect

  77.                       #if ! JucePlugin_IsSynth

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

  79.                       #endif

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

  81.                      #endif

  82.                        )

  83. #endif

  84. {

  85. 	

  86.     g_activeprocessors.insert(this);

  87. 	m_recbuffer.setSize(2, 44100);

  88. 	m_recbuffer.clear();

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

  90. 		m_afm->registerBasicFormats();

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

  92. 	

  93. 	

  94. 	m_ppar.pitch_shift.enabled = true;

  95. 	m_ppar.freq_shift.enabled = true;

  96. 	m_ppar.filter.enabled = true;

  97.     m_ppar.compressor.enabled = true;

  98. 	m_stretch_source->setOnsetDetection(0.0);

  99. 	m_stretch_source->setLoopingEnabled(true);

  100. 	m_stretch_source->setFFTWindowingType(1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  127. 	{

  128. 		if (value < 0.5f)

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

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

  131. 	};

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

  133. 	{

  134. 		if (value < 1000.0f)

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

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

  137. 	};

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

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

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

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

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

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

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

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

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

  147. 	addParameter(m_outchansparam); // 27

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

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

  150. 	setPreBufferAmount(2);

  151.     startTimer(1, 50);

  152. }

  153. 

  154. PaulstretchpluginAudioProcessor::~PaulstretchpluginAudioProcessor()

  155. {

  156. 	g_activeprocessors.erase(this);

  157. 	m_bufferingthread.stopThread(1000);

  158. }

  159. 

  160. void PaulstretchpluginAudioProcessor::setPreBufferAmount(int x)

  161. {

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

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

  164. 	{

  165.         m_use_backgroundbuffering = true;

  166.         m_prebuffer_amount = temp;

  167. 		m_recreate_buffering_source = true;

  168.         ScopedLock locker(m_cs);

  169.         m_ready_to_play = false;

  170.         m_cur_num_out_chans = *m_outchansparam;

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

  172.         String err;

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

  174.                   m_cur_num_out_chans, m_curmaxblocksize, err);

  175.         m_ready_to_play = true;

  176. 	}

  177. }

  178. 

  179. //==============================================================================

  180. const String PaulstretchpluginAudioProcessor::getName() const

  181. {

  182.     return JucePlugin_Name;

  183. }

  184. 

  185. bool PaulstretchpluginAudioProcessor::acceptsMidi() const

  186. {

  187.    #if JucePlugin_WantsMidiInput

  188.     return true;

  189.    #else

  190.     return false;

  191.    #endif

  192. }

  193. 

  194. bool PaulstretchpluginAudioProcessor::producesMidi() const

  195. {

  196.    #if JucePlugin_ProducesMidiOutput

  197.     return true;

  198.    #else

  199.     return false;

  200.    #endif

  201. }

  202. 

  203. bool PaulstretchpluginAudioProcessor::isMidiEffect() const

  204. {

  205.    #if JucePlugin_IsMidiEffect

  206.     return true;

  207.    #else

  208.     return false;

  209.    #endif

  210. }

  211. 

  212. double PaulstretchpluginAudioProcessor::getTailLengthSeconds() const

  213. {

  214. 	return 0.0;

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

  216. }

  217. 

  218. int PaulstretchpluginAudioProcessor::getNumPrograms()

  219. {

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

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

  222. }

  223. 

  224. int PaulstretchpluginAudioProcessor::getCurrentProgram()

  225. {

  226.     return 0;

  227. }

  228. 

  229. void PaulstretchpluginAudioProcessor::setCurrentProgram (int index)

  230. {

  231. }

  232. 

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

  234. {

  235.     return {};

  236. }

  237. 

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

  239. {

  240. }

  241. 

  242. void PaulstretchpluginAudioProcessor::setFFTSize(double size)

  243. {

  244. 	if (m_prebuffer_amount == 5)

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

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

  247. 	int optim = optimizebufsize(m_fft_size_to_use);

  248. 	m_fft_size_to_use = optim;

  249. 	m_stretch_source->setFFTSize(optim);

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

  251. }

  252. 

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

  254. {

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

  256. 

  257. 	int bufamt = m_bufamounts[m_prebuffer_amount];

  258. 

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

  260. 		m_recreate_buffering_source = true;

  261. 	if (m_recreate_buffering_source == true)

  262. 	{

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

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

  265. 		m_recreate_buffering_source = false;

  266. 	}

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

  268. 		m_bufferingthread.startThread();

  269. 	m_stretch_source->setNumOutChannels(numoutchans);

  270. 	m_stretch_source->setFFTSize(m_fft_size_to_use);

  271. 	m_stretch_source->setProcessParameters(&m_ppar);

  272. 	m_last_outpos_pos = 0.0;

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

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

  275. }

  276. double PaulstretchpluginAudioProcessor::getSampleRateChecked()

  277. {

  278. 	if (m_cur_sr < 1.0)

  279. 		return 44100.0;

  280. 	return m_cur_sr;

  281. }

  282. 

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

  284. {

  285. 	ScopedLock locker(m_cs);

  286. 	m_cur_sr = sampleRate;

  287. 	m_curmaxblocksize = samplesPerBlock;

  288. 	int numoutchans = *m_outchansparam;

  289. 	if (numoutchans != m_cur_num_out_chans)

  290. 		m_ready_to_play = false;

  291. 	if (m_using_memory_buffer == true)

  292. 	{

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

  294. 		m_stretch_source->setAudioBufferAsInputSource(&m_recbuffer, 

  295. 			getSampleRateChecked(), 

  296. 			len);

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

  298. 	}

  299. 	if (m_ready_to_play == false)

  300. 	{

  301. 		setFFTSize(*getFloatParameter(cpi_fftsize));

  302. 		m_stretch_source->setProcessParameters(&m_ppar);

  303. 		m_stretch_source->setFFTWindowingType(1);

  304. 		String err;

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

  306. 		numoutchans, samplesPerBlock, err);

  307. 		m_cur_num_out_chans = numoutchans;

  308. 		m_ready_to_play = true;

  309. 	}

  310. 	

  311. }

  312. 

  313. void PaulstretchpluginAudioProcessor::releaseResources()

  314. {

  315. 	//m_control->stopplay();

  316. 	//m_ready_to_play = false;

  317. }

  318. 

  319. #ifndef JucePlugin_PreferredChannelConfigurations

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

  321. {

  322.   #if JucePlugin_IsMidiEffect

  323.     ignoreUnused (layouts);

  324.     return true;

  325.   #else

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

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

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

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

  330.         return false;

  331. 

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

  333.    #if ! JucePlugin_IsSynth

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

  335.         return false;

  336.    #endif

  337. 

  338.     return true;

  339.   #endif

  340. }

  341. #endif

  342. 

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

  344. {

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

  346. 	{

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

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

  349. 		{

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

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

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

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

  354. 		}

  355. 		else

  356. 		{

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

  358. 		}

  359. 	}

  360. }

  361. 

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

  363. {

  364. 	ScopedLock locker(m_cs);

  365. 	AudioPlayHead* phead = getPlayHead();

  366. 	if (phead != nullptr)

  367. 	{

  368. 		phead->getCurrentPosition(m_playposinfo);

  369. 	}

  370. 	ScopedNoDenormals noDenormals;

  371. 	double srtemp = getSampleRate();

  372. 	if (srtemp != m_cur_sr)

  373. 		m_cur_sr = srtemp;

  374.     const int totalNumInputChannels  = getTotalNumInputChannels();

  375.     const int totalNumOutputChannels = getTotalNumOutputChannels();

  376. 

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

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

  379. 	if (m_ready_to_play == false)

  380. 		return;

  381. 	if (m_is_recording == true)

  382. 	{

  383. 		int recbuflenframes = m_max_reclen * getSampleRate();

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

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

  386. 		{

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

  388. 		}, false);

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

  390. 		return;

  391. 	}

  392. 	jassert(m_buffering_source != nullptr);

  393. 	jassert(m_bufferingthread.isThreadRunning());

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

  395. 	{

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

  397. 		m_last_host_playing = true;

  398. 	}

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

  400. 	{

  401. 		m_last_host_playing = false;

  402. 	}

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

  404. 		return;

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

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

  407. 

  408. 	setFFTSize(*getFloatParameter(cpi_fftsize));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  426. 	m_ppar.octave.enabled = true;

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

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

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

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

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

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

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

  434. 	double t0 = *getFloatParameter(cpi_soundstart);

  435. 	double t1 = *getFloatParameter(cpi_soundend);

  436. 	if (t0 > t1)

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

  438. 	if (t1 - t0 < 0.001)

  439. 		t1 = t0 + 0.001;

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

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

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

  443. 	m_stretch_source->setProcessParameters(&m_ppar);

  444. 	AudioSourceChannelInfo aif(buffer);

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

  446. 	{

  447. 		m_stretch_source->getNextAudioBlock(aif);

  448. 	}

  449. 	else

  450. 	{

  451. 		m_buffering_source->getNextAudioBlock(aif);

  452. 	}

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

  454. 	{

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

  456. 		{

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

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

  459. 				++m_abnormal_output_samples;

  460. 		}

  461. 	}

  462. }

  463. 

  464. //==============================================================================

  465. bool PaulstretchpluginAudioProcessor::hasEditor() const

  466. {

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

  468. }

  469. 

  470. AudioProcessorEditor* PaulstretchpluginAudioProcessor::createEditor()

  471. {

  472. 	return new PaulstretchpluginAudioProcessorEditor (*this);

  473. }

  474. 

  475. //==============================================================================

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

  477. {

  478. 	ValueTree paramtree("paulstretch3pluginstate");

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

  480. 	{

  481. 		auto par = getFloatParameter(i);

  482. 		if (par != nullptr)

  483. 		{

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

  485. 		}

  486. 	}

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

  488. 	if (m_current_file != File())

  489. 	{

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

  491. 	}

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

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

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

  495. 	{

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

  497. 	}

  498.     if (m_use_backgroundbuffering)

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

  500. 	else

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

  502.     MemoryOutputStream stream(destData,true);

  503. 	paramtree.writeToStream(stream);

  504. }

  505. 

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

  507. {

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

  509. 	if (tree.isValid())

  510. 	{

  511. 		{

  512. 			ScopedLock locker(m_cs);

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

  514. 			{

  515. 				std::vector<int> order;

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

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

  518. 				{

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

  520. 				}

  521. 				m_stretch_source->setSpectrumProcessOrder(order);

  522. 			}

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

  524. 			{

  525. 				auto par = getFloatParameter(i);

  526. 				if (par != nullptr)

  527. 				{

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

  529. 					*par = parval;

  530. 				}

  531. 			}

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

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

  534. 

  535. 		}

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

  537.         if (prebufamt==-1)

  538.             m_use_backgroundbuffering = false;

  539.         else

  540.             setPreBufferAmount(prebufamt);

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

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

  543. 		{

  544. 			File f(fn);

  545. 			setAudioFile(f);

  546. 		}

  547. 	}

  548. }

  549. 

  550. void PaulstretchpluginAudioProcessor::setRecordingEnabled(bool b)

  551. {

  552. 	ScopedLock locker(m_cs);

  553. 	int lenbufframes = getSampleRateChecked()*m_max_reclen;

  554. 	if (b == true)

  555. 	{

  556. 		m_using_memory_buffer = true;

  557. 		m_current_file = File();

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

  559. 		m_recbuffer.clear();

  560. 		m_rec_pos = 0;

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

  562. 		{

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

  564. 		},false);

  565. 		m_is_recording = true;

  566. 	}

  567. 	else

  568. 	{

  569. 		if (m_is_recording == true)

  570. 		{

  571. 			finishRecording(lenbufframes);

  572. 		}

  573. 	}

  574. }

  575. 

  576. double PaulstretchpluginAudioProcessor::getRecordingPositionPercent()

  577. {

  578. 	if (m_is_recording==false)

  579. 		return 0.0;

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

  581. }

  582. 

  583. String PaulstretchpluginAudioProcessor::setAudioFile(File f)

  584. {

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

  586.     //    return String();

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

  588.     //    return String();

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

  590. 	if (ai != nullptr)

  591. 	{

  592. 		if (ai->numChannels > 32)

  593. 		{

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

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

  596. 		}

  597. 		if (ai->bitsPerSample>32)

  598. 		{

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

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

  601. 		}

  602. 		ScopedLock locker(m_cs);

  603. 		m_stretch_source->setAudioFile(f);

  604. 		m_current_file = f;

  605.         m_current_file_date = m_current_file.getLastModificationTime();

  606. 		m_using_memory_buffer = false;

  607. 		return String();

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

  609. 

  610. 	}

  611. 	

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

  613. }

  614. 

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

  616. {

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

  618. }

  619. 

  620. double PaulstretchpluginAudioProcessor::getPreBufferingPercent()

  621. {

  622. 	if (m_buffering_source==nullptr)

  623. 		return 0.0;

  624. 	return m_buffering_source->getPercentReady();

  625. }

  626. 

  627. void PaulstretchpluginAudioProcessor::timerCallback(int id)

  628. {

  629. 	if (id == 1)

  630. 	{

  631. 		bool capture = getParameter(cpi_capture_enabled);

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

  633. 		{

  634. 			m_max_reclen = *getFloatParameter(cpi_max_capture_len);

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

  636. 		}

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

  638. 		{

  639. 			setRecordingEnabled(true);

  640. 			return;

  641. 		}

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

  643. 		{

  644. 			setRecordingEnabled(false);

  645. 			return;

  646. 		}

  647. 		if (m_cur_num_out_chans != *m_outchansparam)

  648. 		{

  649. 			jassert(m_curmaxblocksize > 0);

  650. 			ScopedLock locker(m_cs);

  651. 			m_ready_to_play = false;

  652. 			m_cur_num_out_chans = *m_outchansparam;

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

  654. 			String err;

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

  656. 				m_cur_num_out_chans, m_curmaxblocksize, err);

  657. 			m_ready_to_play = true;

  658. 		}

  659. 	}

  660. }

  661. 

  662. void PaulstretchpluginAudioProcessor::finishRecording(int lenrecording)

  663. {

  664. 	m_is_recording = false;

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

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

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

  668. 	if (ed)

  669. 	{

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

  671. 	}

  672. }

  673. 

  674. //==============================================================================

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

  676. AudioProcessor* JUCE_CALLTYPE createPluginFilter()

  677. {

  678.     return new PaulstretchpluginAudioProcessor();

  679. }