Context Navigation

hydrogen.cpp @ 762

Visit:

Revision 762, 77.0 KB (checked in by wolke, 4 years ago)
merge rev 756:761 from trunk

Line
1	/*
2	* Hydrogen
3	* Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
4	*
5	* http://www.hydrogen-music.org
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY, without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20	*
21	*/
22
23	#include "config.h"
24
25	#ifdef WIN32
26	# include "hydrogen/timeHelper.h"
27	#else
28	# include <unistd.h>
29	# include <sys/time.h>
30	#endif
31
32	#include <pthread.h>
33	#include <cassert>
34	#include <cstdio>
35	#include <deque>
36	#include <queue>
37	#include <iostream>
38	#include <ctime>
39	#include <cmath>
40	#include <algorithm>
41
42	#include <hydrogen/LocalFileMng.h>
43	#include <hydrogen/event_queue.h>
44	#include <hydrogen/adsr.h>
45	#include <hydrogen/SoundLibrary.h>
46	#include <hydrogen/h2_exception.h>
47	#include <hydrogen/audio_engine.h>
48	#include <hydrogen/instrument.h>
49	#include <hydrogen/sample.h>
50	#include <hydrogen/hydrogen.h>
51	#include <hydrogen/Pattern.h>
52	#include <hydrogen/note.h>
53	#include <hydrogen/fx/LadspaFX.h>
54	#include <hydrogen/fx/Effects.h>
55	#include <hydrogen/IO/AudioOutput.h>
56	#include <hydrogen/IO/JackOutput.h>
57	#include <hydrogen/IO/NullDriver.h>
58	#include <hydrogen/IO/MidiInput.h>
59	#include <hydrogen/IO/CoreMidiDriver.h>
60	#include <hydrogen/IO/TransportInfo.h>
61	#include <hydrogen/Preferences.h>
62	#include <hydrogen/data_path.h>
63	#include <hydrogen/sampler/Sampler.h>
64
65	#include "IO/OssDriver.h"
66	#include "IO/FakeDriver.h"
67	#include "IO/AlsaAudioDriver.h"
68	#include "IO/PortAudioDriver.h"
69	#include "IO/DiskWriterDriver.h"
70	#include "IO/AlsaMidiDriver.h"
71	#include "IO/PortMidiDriver.h"
72	#include "IO/CoreAudioDriver.h"
73
74
75	namespace H2Core
76	{
77
78	// GLOBALS
79
80	// info
81	float m_fMasterPeak_L = 0.0f; ///< Master peak (left channel)
82	float m_fMasterPeak_R = 0.0f; ///< Master peak (right channel)
83	float m_fProcessTime = 0.0f; ///< time used in process function
84	float m_fMaxProcessTime = 0.0f; ///< max ms usable in process with no xrun
85	//~ info
86
87
88	// beatcounter
89
90	//100,000 ms in 1 second.
91	#define US_DIVIDER .000001
92
93	float m_ntaktoMeterCompute = 1; ///< beatcounter note lenght
94	int m_nbeatsToCount = 4; ///< beatcounter beats to count
95	int eventCount = 1; ///< beatcounter event
96	int tempochangecounter = 0; ///< count tempochanges for timeArray
97	int beatCount = 1; ///< beatcounter beat to count
98	double beatDiffs[16]; ///< beat diff
99	timeval currentTime, lastTime; ///< timeval
100	double lastBeatTime, currentBeatTime, beatDiff; ///< timediff
101	float beatCountBpm; ///< bpm
102	int m_nCoutOffset = 0; ///ms default 0
103	int m_nStartOffset = 0; ///ms default 0
104	//~ beatcounter
105
106	//jack time master
107	float m_nNewBpmJTM = 120;
108	unsigned long m_nHumantimeFrames = 0;
109	//~ jack time master
110
111	AudioOutput *m_pAudioDriver = NULL; ///< Audio output
112	MidiInput *m_pMidiDriver = NULL; ///< MIDI input
113
114	// overload the the > operator of Note objects for priority_queue
115	bool operator> (const Note& pNote1, const Note &pNote2) {
116	return (pNote1.m_nHumanizeDelay
117	+ pNote1.get_position() * m_pAudioDriver->m_transport.m_nTickSize)
118	>
119	(pNote2.m_nHumanizeDelay
120	+ pNote2.get_position() * m_pAudioDriver->m_transport.m_nTickSize);
121	}
122
123	/// Song Note FIFO
124	std::priority_queue<Note, std::deque<Note>, std::greater<Note> > m_songNoteQueue;
125	std::deque<Note*> m_midiNoteQueue; ///< Midi Note FIFO
126
127	Song *m_pSong; ///< Current song
128	PatternList* m_pNextPatterns; ///< Next pattern (used only in Pattern mode)
129	bool m_bAppendNextPattern; ///< Add the next pattern to the list instead
130	/// of replace.
131	bool m_bDeleteNextPattern; ///< Delete the next pattern from the list.
132
133
134	PatternList* m_pPlayingPatterns;
135	int m_nSongPos; ///< Is the position inside the song
136
137	int m_nSelectedPatternNumber;
138	int m_nSelectedInstrumentNumber;
139
140	Instrument *m_pMetronomeInstrument = NULL; ///< Metronome instrument
141
142
143	// Buffers used in the process function
144	unsigned m_nBufferSize = 0;
145	float *m_pMainBuffer_L = NULL;
146	float *m_pMainBuffer_R = NULL;
147
148
149	Hydrogen* hydrogenInstance = NULL; ///< Hydrogen class instance (used for log)
150
151
152	int m_audioEngineState = STATE_UNINITIALIZED; ///< Audio engine state
153
154
155
156	#ifdef LADSPA_SUPPORT
157	float m_fFXPeak_L[MAX_FX];
158	float m_fFXPeak_R[MAX_FX];
159	#endif
160
161
162	int m_nPatternStartTick = -1;
163	int m_nPatternTickPosition = 0;
164	int m_nLookaheadFrames = 0;
165
166	// used in findPatternInTick
167	int m_nSongSizeInTicks = 0;
168
169	struct timeval m_currentTickTime;
170
171	unsigned long m_nRealtimeFrames = 0;
172	unsigned int m_naddrealtimenotetickposition = 0;
173
174
175
176
177	// PROTOTYPES
178	void audioEngine_init();
179	void audioEngine_destroy();
180	int audioEngine_start( bool bLockEngine = false, unsigned nTotalFrames = 0 );
181	void audioEngine_stop( bool bLockEngine = false );
182	void audioEngine_setSong( Song *newSong );
183	void audioEngine_removeSong();
184	static void audioEngine_noteOn( Note *note );
185	static void audioEngine_noteOff( Note *note );
186	int audioEngine_process( uint32_t nframes, void *arg );
187	inline void audioEngine_clearNoteQueue();
188	inline void audioEngine_process_checkBPMChanged();
189	inline void audioEngine_process_playNotes( unsigned long nframes );
190	inline void audioEngine_process_transport();
191
192	inline unsigned audioEngine_renderNote( Note* pNote, const unsigned& nBufferSize );
193	inline int audioEngine_updateNoteQueue( unsigned nFrames );
194	inline void audioEngine_prepNoteQueue();
195
196	inline int findPatternInTick( int tick, bool loopMode, int *patternStartTick );
197
198	void audioEngine_seek( long long nFrames, bool bLoopMode = false );
199
200	void audioEngine_restartAudioDrivers();
201	void audioEngine_startAudioDrivers();
202	void audioEngine_stopAudioDrivers();
203
204
205	inline timeval currentTime2()
206	{
207	struct timeval now;
208	gettimeofday( &now, NULL );
209	return now;
210	}
211
212
213
214	inline int randomValue( int max )
215	{
216	return rand() % max;
217	}
218
219
220	inline float getGaussian( float z )
221	{
222	// gaussian distribution -- dimss
223	float x1, x2, w;
224	do {
225	x1 = 2.0 * ( ( ( float ) rand() ) / RAND_MAX ) - 1.0;
226	x2 = 2.0 * ( ( ( float ) rand() ) / RAND_MAX ) - 1.0;
227	w = x1 * x1 + x2 * x2;
228	} while ( w >= 1.0 );
229
230	w = sqrtf( ( -2.0 * logf( w ) ) / w );
231	return x1 * w * z + 0.0; // tunable
232	}
233
234
235
236	void audioEngine_raiseError( unsigned nErrorCode )
237	{
238	EventQueue::get_instance()->push_event( EVENT_ERROR, nErrorCode );
239	}
240
241
242
243	void updateTickSize()
244	{
245	float sampleRate = ( float )m_pAudioDriver->getSampleRate();
246	m_pAudioDriver->m_transport.m_nTickSize =
247	( sampleRate * 60.0 / m_pSong->__bpm / m_pSong->__resolution );
248	}
249
250
251
252	void audioEngine_init()
253	{
254	_INFOLOG( "* Hydrogen audio engine init *" );
255
256	// check current state
257	if ( m_audioEngineState != STATE_UNINITIALIZED ) {
258	_ERRORLOG( "Error the audio engine is not in UNINITIALIZED state" );
259	AudioEngine::get_instance()->unlock();
260	return;
261	}
262
263	m_pSong = NULL;
264	m_pPlayingPatterns = new PatternList();
265	m_pNextPatterns = new PatternList();
266	m_nSongPos = -1;
267	m_nSelectedPatternNumber = 0;
268	m_nSelectedInstrumentNumber = 0;
269	m_nPatternTickPosition = 0;
270	m_pMetronomeInstrument = NULL;
271	m_pAudioDriver = NULL;
272
273	m_pMainBuffer_L = NULL;
274	m_pMainBuffer_R = NULL;
275
276	srand( time( NULL ) );
277
278	// Create metronome instrument
279	QString sMetronomeFilename = QString( "%1/click.wav" )
280	.arg( DataPath::get_data_path() );
281	m_pMetronomeInstrument =
282	new Instrument( sMetronomeFilename, "metronome", new ADSR() );
283	m_pMetronomeInstrument->set_layer(
284	new InstrumentLayer( Sample::load( sMetronomeFilename ) ),
285	0
286	);
287
288	// Change the current audio engine state
289	m_audioEngineState = STATE_INITIALIZED;
290
291	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_INITIALIZED );
292	}
293
294
295
296	void audioEngine_destroy()
297	{
298	// check current state
299	if ( m_audioEngineState != STATE_INITIALIZED ) {
300	_ERRORLOG( "Error the audio engine is not in INITIALIZED state" );
301	return;
302	}
303	AudioEngine::get_instance()->get_sampler()->stop_playing_notes();
304
305	AudioEngine::get_instance()->lock( "audioEngine_destroy" );
306	_INFOLOG( "* Hydrogen audio engine shutdown *" );
307
308	// delete all copied notes in the song notes queue
309	while ( !m_songNoteQueue.empty() ) {
310	m_songNoteQueue.top()->get_instrument()->dequeue();
311	delete m_songNoteQueue.top();
312	m_songNoteQueue.pop();
313	}
314	// delete all copied notes in the midi notes queue
315	for ( unsigned i = 0; i < m_midiNoteQueue.size(); ++i ) {
316	Note *note = m_midiNoteQueue[i];
317	delete note;
318	note = NULL;
319	}
320	m_midiNoteQueue.clear();
321
322	// change the current audio engine state
323	m_audioEngineState = STATE_UNINITIALIZED;
324
325	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_UNINITIALIZED );
326
327	delete m_pPlayingPatterns;
328	m_pPlayingPatterns = NULL;
329
330	delete m_pNextPatterns;
331	m_pNextPatterns = NULL;
332
333	delete m_pMetronomeInstrument;
334	m_pMetronomeInstrument = NULL;
335
336	AudioEngine::get_instance()->unlock();
337	}
338
339
340
341
342
343	/// Start playing
344	/// return 0 = OK
345	/// return -1 = NULL Audio Driver
346	/// return -2 = Driver connect() error
347	int audioEngine_start( bool bLockEngine, unsigned nTotalFrames )
348	{
349	if ( bLockEngine ) {
350	AudioEngine::get_instance()->lock( "audioEngine_start" );
351	}
352
353	_INFOLOG( "[audioEngine_start]" );
354
355	// check current state
356	if ( m_audioEngineState != STATE_READY ) {
357	_ERRORLOG( "Error the audio engine is not in READY state" );
358	if ( bLockEngine ) {
359	AudioEngine::get_instance()->unlock();
360	}
361	return 0; // FIXME!!
362	}
363
364	m_fMasterPeak_L = 0.0f;
365	m_fMasterPeak_R = 0.0f;
366	m_pAudioDriver->m_transport.m_nFrames = nTotalFrames; // reset total frames
367	m_nSongPos = -1;
368	m_nPatternStartTick = -1;
369	m_nPatternTickPosition = 0;
370
371	// prepare the tickSize for this song
372	updateTickSize();
373
374	// change the current audio engine state
375	m_audioEngineState = STATE_PLAYING;
376	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_PLAYING );
377
378	if ( bLockEngine ) {
379	AudioEngine::get_instance()->unlock();
380	}
381	return 0; // per ora restituisco sempre OK
382	}
383
384
385
386	/// Stop the audio engine
387	void audioEngine_stop( bool bLockEngine )
388	{
389	if ( bLockEngine ) {
390	AudioEngine::get_instance()->lock( "audioEngine_stop" );
391	}
392	_INFOLOG( "[audioEngine_stop]" );
393
394	// check current state
395	if ( m_audioEngineState != STATE_PLAYING ) {
396	_ERRORLOG( "Error the audio engine is not in PLAYING state" );
397	if ( bLockEngine ) {
398	AudioEngine::get_instance()->unlock();
399	}
400	return;
401	}
402
403	// change the current audio engine state
404	m_audioEngineState = STATE_READY;
405	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_READY );
406
407	m_fMasterPeak_L = 0.0f;
408	m_fMasterPeak_R = 0.0f;
409	// m_nPatternTickPosition = 0;
410	m_nPatternStartTick = -1;
411
412	// delete all copied notes in the song notes queue
413	while(!m_songNoteQueue.empty()){
414	m_songNoteQueue.top()->get_instrument()->dequeue();
415	delete m_songNoteQueue.top();
416	m_songNoteQueue.pop();
417	}
418	/* // delete all copied notes in the playing notes queue
419	for (unsigned i = 0; i < m_playingNotesQueue.size(); ++i) {
420	Note *note = m_playingNotesQueue[i];
421	delete note;
422	}
423	m_playingNotesQueue.clear();
424	*/
425
426	// delete all copied notes in the midi notes queue
427	for ( unsigned i = 0; i < m_midiNoteQueue.size(); ++i ) {
428	Note *note = m_midiNoteQueue[i];
429	delete note;
430	}
431	m_midiNoteQueue.clear();
432
433	if ( bLockEngine ) {
434	AudioEngine::get_instance()->unlock();
435	}
436	}
437
438	//
439	/// Update Tick size and frame position in the audio driver from Song->__bpm
440	//
441	inline void audioEngine_process_checkBPMChanged()
442	{
443
444	if ( ( m_audioEngineState == STATE_READY ) \|\| ( m_audioEngineState == STATE_PLAYING ) ) {
445
446	float fNewTickSize =
447	m_pAudioDriver->getSampleRate() * 60.0
448	/ m_pSong->__bpm
449	/ m_pSong->__resolution;
450
451	if ( fNewTickSize != m_pAudioDriver->m_transport.m_nTickSize ) {
452	// cerco di convertire ...
453	float fTickNumber =
454	( float )m_pAudioDriver->m_transport.m_nFrames
455	/ ( float )m_pAudioDriver->m_transport.m_nTickSize;
456
457	m_pAudioDriver->m_transport.m_nTickSize = fNewTickSize;
458
459	if ( m_pAudioDriver->m_transport.m_nTickSize == 0 ) {
460	return;
461	}
462
463	_WARNINGLOG( "Tempo change: Recomputing ticksize and frame position" );
464	long long nNewFrames = ( long long )( fTickNumber * fNewTickSize );
465	// update frame position
466	m_pAudioDriver->m_transport.m_nFrames = nNewFrames;
467	#ifdef JACK_SUPPORT
468	if ( "JackOutput" == m_pAudioDriver->get_class_name()
469	&& m_audioEngineState == STATE_PLAYING ) {
470	static_cast< JackOutput* >( m_pAudioDriver )
471	->calculateFrameOffset();
472	}
473	#endif
474	}
475	}
476	}
477
478	inline void audioEngine_process_playNotes( unsigned long nframes )
479	{
480	unsigned int framepos;
481
482	if ( m_audioEngineState == STATE_PLAYING ) {
483	framepos = m_pAudioDriver->m_transport.m_nFrames;
484	} else {
485	// use this to support realtime events when not playing
486	framepos = m_nRealtimeFrames;
487	}
488
489	// reading from m_songNoteQueue
490	while ( !m_songNoteQueue.empty() ) {
491	Note *pNote = m_songNoteQueue.top();
492
493	// verifico se la nota rientra in questo ciclo
494	unsigned int noteStartInFrames =
495	(int)( pNote->get_position() * m_pAudioDriver->m_transport.m_nTickSize );
496
497	// if there is a negative Humanize delay, take into account so
498	// we don't miss the time slice. ignore positive delay, or we
499	// might end the queue processing prematurely based on NoteQueue
500	// placement. the sampler handles positive delay.
501	if (pNote->m_nHumanizeDelay < 0) {
502	noteStartInFrames += pNote->m_nHumanizeDelay;
503	}
504
505	// m_nTotalFrames <= NotePos < m_nTotalFrames + bufferSize
506	bool isNoteStart = ( ( noteStartInFrames >= framepos )
507	&& ( noteStartInFrames < ( framepos + nframes ) ) );
508	bool isOldNote = noteStartInFrames < framepos;
509	if ( isNoteStart \|\| isOldNote ) {
510
511	// Humanize - Velocity parameter
512	if ( m_pSong->get_humanize_velocity_value() != 0 ) {
513	float random = m_pSong->get_humanize_velocity_value()
514	* getGaussian( 0.2 );
515	pNote->set_velocity(
516	pNote->get_velocity()
517	+ ( random
518	- ( m_pSong->get_humanize_velocity_value() / 2.0 ) )
519	);
520	if ( pNote->get_velocity() > 1.0 ) {
521	pNote->set_velocity( 1.0 );
522	} else if ( pNote->get_velocity() < 0.0 ) {
523	pNote->set_velocity( 0.0 );
524	}
525	}
526
527	// Random Pitch ;)
528	const float fMaxPitchDeviation = 2.0;
529	pNote->set_pitch( pNote->get_pitch()
530	+ ( fMaxPitchDeviation * getGaussian( 0.2 )
531	- fMaxPitchDeviation / 2.0 )
532	* pNote->get_instrument()->get_random_pitch_factor() );
533
534	Instrument * noteInstrument = pNote->get_instrument();
535	if ( noteInstrument->is_stop_notes() ){
536	Note *pOffNote = new Note( noteInstrument,
537	0.0,
538	0.0,
539	0.0,
540	0.0,
541	-1,
542	0 );
543	pOffNote->set_noteoff( true );
544	AudioEngine::get_instance()->get_sampler()->note_on( pOffNote );
545	}
546
547	AudioEngine::get_instance()->get_sampler()->note_on( pNote );
548
549	m_songNoteQueue.pop(); // rimuovo la nota dalla lista di note
550	pNote->get_instrument()->dequeue();
551	// raise noteOn event
552	int nInstrument = m_pSong->get_instrument_list()
553	->get_pos( pNote->get_instrument() );
554	EventQueue::get_instance()->push_event( EVENT_NOTEON, nInstrument );
555	continue;
556	} else {
557	// this note will not be played
558	break;
559	}
560	}
561	}
562
563
564	void audioEngine_seek( long long nFrames, bool bLoopMode )
565	{
566	if ( m_pAudioDriver->m_transport.m_nFrames == nFrames ) {
567	return;
568	}
569
570	if ( nFrames < 0 ) {
571	_ERRORLOG( "nFrames < 0" );
572	}
573
574	char tmp[200];
575	sprintf( tmp, "seek in %lld (old pos = %d)",
576	nFrames,
577	( int )m_pAudioDriver->m_transport.m_nFrames );
578	_INFOLOG( tmp );
579
580	m_pAudioDriver->m_transport.m_nFrames = nFrames;
581
582	int tickNumber_start = ( unsigned )(
583	m_pAudioDriver->m_transport.m_nFrames
584	/ m_pAudioDriver->m_transport.m_nTickSize );
585	// sprintf(tmp, "[audioEngine_seek()] tickNumber_start = %d", tickNumber_start);
586	// hydrogenInstance->infoLog(tmp);
587
588	bool loop = m_pSong->is_loop_enabled();
589
590	if ( bLoopMode ) {
591	loop = true;
592	}
593
594	m_nSongPos = findPatternInTick( tickNumber_start, loop, &m_nPatternStartTick );
595	// sprintf(tmp, "[audioEngine_seek()] m_nSongPos = %d", m_nSongPos);
596	// hydrogenInstance->infoLog(tmp);
597
598	audioEngine_clearNoteQueue();
599	}
600
601
602
603	inline void audioEngine_process_transport()
604	{
605	if ( ( m_audioEngineState == STATE_READY )
606	\|\| ( m_audioEngineState == STATE_PLAYING ) ) {
607	m_pAudioDriver->updateTransportInfo();
608	unsigned long nNewFrames = m_pAudioDriver->m_transport.m_nFrames;
609
610	// ??? audioEngine_seek returns IMMEDIATELY
611	// when nNewFrames == m_pAudioDriver->m_transport.m_nFrames ???
612	// audioEngine_seek( nNewFrames, true );
613
614	switch ( m_pAudioDriver->m_transport.m_status ) {
615	case TransportInfo::ROLLING:
616
617	if ( m_audioEngineState == STATE_READY ) {
618	audioEngine_start( false, nNewFrames ); // no engine lock
619	}
620
621	if ( m_pSong->__bpm != m_pAudioDriver->m_transport.m_nBPM ) {
622	_INFOLOG(
623	QString( "song bpm: (%1) gets transport bpm: (%2)" )
624	.arg( m_pSong->__bpm )
625	.arg( m_pAudioDriver->m_transport.m_nBPM ) );
626
627	m_pSong->__bpm = m_pAudioDriver->m_transport.m_nBPM;
628	}
629
630	m_nRealtimeFrames = m_pAudioDriver->m_transport.m_nFrames;
631	break;
632
633
634	case TransportInfo::STOPPED:
635
636	if ( m_audioEngineState == STATE_PLAYING ) {
637	audioEngine_stop( false ); // no engine lock
638	}
639
640	if ( m_pSong->__bpm != m_pAudioDriver->m_transport.m_nBPM ) {
641	m_pSong->__bpm = m_pAudioDriver->m_transport.m_nBPM;
642	}
643
644	// go ahead and increment the realtimeframes by buffersize
645	// to support our realtime keyboard and midi event timing
646	m_nRealtimeFrames += m_nBufferSize;
647	break;
648	}
649	}
650	}
651
652
653
654	void audioEngine_clearNoteQueue()
655	{
656	//_INFOLOG( "clear notes...");
657
658	// delete all copied notes in the song notes queue
659	while (!m_songNoteQueue.empty()) {
660	m_songNoteQueue.top()->get_instrument()->dequeue();
661	delete m_songNoteQueue.top();
662	m_songNoteQueue.pop();
663	}
664
665	AudioEngine::get_instance()->get_sampler()->stop_playing_notes();
666
667	// delete all copied notes in the midi notes queue
668	for ( unsigned i = 0; i < m_midiNoteQueue.size(); ++i ) {
669	delete m_midiNoteQueue[i];
670	}
671	m_midiNoteQueue.clear();
672
673	}
674
675
676
677	/// Clear all audio buffers
678	inline void audioEngine_process_clearAudioBuffers( uint32_t nFrames )
679	{
680	// clear main out Left and Right
681	if ( m_pMainBuffer_L ) {
682	memset( m_pMainBuffer_L, 0, nFrames * sizeof( float ) );
683	}
684	if ( m_pMainBuffer_R ) {
685	memset( m_pMainBuffer_R, 0, nFrames * sizeof( float ) );
686	}
687
688	if ( ( m_audioEngineState == STATE_READY )
689	\|\| ( m_audioEngineState == STATE_PLAYING ) ) {
690	#ifdef LADSPA_SUPPORT
691	Effects* pEffects = Effects::getInstance();
692	for ( unsigned i = 0; i < MAX_FX; ++i ) { // clear FX buffers
693	LadspaFX* pFX = pEffects->getLadspaFX( i );
694	if ( pFX ) {
695	assert( pFX->m_pBuffer_L );
696	assert( pFX->m_pBuffer_R );
697	memset( pFX->m_pBuffer_L, 0, nFrames * sizeof( float ) );
698	memset( pFX->m_pBuffer_R, 0, nFrames * sizeof( float ) );
699	}
700	}
701	#endif
702	}
703	}
704
705	/// Main audio processing function. Called by audio drivers.
706	int audioEngine_process( uint32_t nframes, void* /arg/ )
707	{
708	if ( AudioEngine::get_instance()->try_lock( "audioEngine_process" ) == false ) {
709	return 0;
710	}
711
712	timeval startTimeval = currentTime2();
713
714	if ( m_nBufferSize != nframes ) {
715	_INFOLOG(
716	QString( "Buffer size changed. Old size = %1, new size = %2" )
717	.arg( m_nBufferSize )
718	.arg( nframes )
719	);
720	m_nBufferSize = nframes;
721	}
722
723	// m_pAudioDriver->bpm updates Song->__bpm. (!!(Calls audioEngine_seek))
724	audioEngine_process_transport();
725	audioEngine_process_clearAudioBuffers( nframes );
726	audioEngine_process_checkBPMChanged(); // m_pSong->__bpm decides tick size
727
728	bool sendPatternChange = false;
729	// always update note queue.. could come from pattern or realtime input
730	// (midi, keyboard)
731	int res2 = audioEngine_updateNoteQueue( nframes );
732	if ( res2 == -1 ) { // end of song
733	_INFOLOG( "End of song received, calling engine_stop()" );
734	AudioEngine::get_instance()->unlock();
735	m_pAudioDriver->stop();
736	m_pAudioDriver->locate( 0 ); // locate 0, reposition from start of the song
737
738	if ( ( m_pAudioDriver->get_class_name() == "DiskWriterDriver" )
739	\|\| ( m_pAudioDriver->get_class_name() == "FakeDriver" ) ) {
740	_INFOLOG( "End of song." );
741	return 1; // kill the audio AudioDriver thread
742	}
743	#ifdef JACK_SUPPORT
744	else if ( m_pAudioDriver->get_class_name() == "JackOutput" ) {
745	// Do something clever :-s ... Jakob Lund
746	// Mainly to keep sync with Ardour.
747	static_cast<JackOutput*>(m_pAudioDriver)->locateInNCycles( 0 );
748	}
749	#endif
750	return 0;
751	} else if ( res2 == 2 ) { // send pattern change
752	sendPatternChange = true;
753	}
754
755	// play all notes
756	audioEngine_process_playNotes( nframes );
757
758	timeval renderTime_start = currentTime2();
759
760	// SAMPLER
761	AudioEngine::get_instance()->get_sampler()->process( nframes, m_pSong );
762	float* out_L = AudioEngine::get_instance()->get_sampler()->__main_out_L;
763	float* out_R = AudioEngine::get_instance()->get_sampler()->__main_out_R;
764	for ( unsigned i = 0; i < nframes; ++i ) {
765	m_pMainBuffer_L[ i ] += out_L[ i ];
766	m_pMainBuffer_R[ i ] += out_R[ i ];
767	}
768
769	// SYNTH
770	AudioEngine::get_instance()->get_synth()->process( nframes );
771	out_L = AudioEngine::get_instance()->get_synth()->m_pOut_L;
772	out_R = AudioEngine::get_instance()->get_synth()->m_pOut_R;
773	for ( unsigned i = 0; i < nframes; ++i ) {
774	m_pMainBuffer_L[ i ] += out_L[ i ];
775	m_pMainBuffer_R[ i ] += out_R[ i ];
776	}
777
778
779	timeval renderTime_end = currentTime2();
780
781
782
783	timeval ladspaTime_start = renderTime_end;
784	#ifdef LADSPA_SUPPORT
785	// Process LADSPA FX
786	if ( ( m_audioEngineState == STATE_READY )
787	\|\| ( m_audioEngineState == STATE_PLAYING ) ) {
788	for ( unsigned nFX = 0; nFX < MAX_FX; ++nFX ) {
789	LadspaFX *pFX = Effects::getInstance()->getLadspaFX( nFX );
790	if ( ( pFX ) && ( pFX->isEnabled() ) ) {
791	pFX->processFX( nframes );
792	float *buf_L = NULL;
793	float *buf_R = NULL;
794	if ( pFX->getPluginType() == LadspaFX::STEREO_FX ) {
795	buf_L = pFX->m_pBuffer_L;
796	buf_R = pFX->m_pBuffer_R;
797	} else { // MONO FX
798	buf_L = pFX->m_pBuffer_L;
799	buf_R = buf_L;
800	}
801	for ( unsigned i = 0; i < nframes; ++i ) {
802	m_pMainBuffer_L[ i ] += buf_L[ i ];
803	m_pMainBuffer_R[ i ] += buf_R[ i ];
804	if ( buf_L[ i ] > m_fFXPeak_L[nFX] )
805	m_fFXPeak_L[nFX] = buf_L[ i ];
806	if ( buf_R[ i ] > m_fFXPeak_R[nFX] )
807	m_fFXPeak_R[nFX] = buf_R[ i ];
808	}
809	}
810	}
811	}
812	#endif
813	timeval ladspaTime_end = currentTime2();
814
815	// update master peaks
816	float val_L;
817	float val_R;
818	if ( m_audioEngineState == STATE_PLAYING
819	\|\| m_audioEngineState == STATE_READY ) {
820	for ( unsigned i = 0; i < nframes; ++i ) {
821	val_L = m_pMainBuffer_L[i];
822	val_R = m_pMainBuffer_R[i];
823	if ( val_L > m_fMasterPeak_L ) {
824	m_fMasterPeak_L = val_L;
825	}
826	if ( val_R > m_fMasterPeak_R ) {
827	m_fMasterPeak_R = val_R;
828	}
829	}
830	}
831
832	// update total frames number
833	if ( m_audioEngineState == STATE_PLAYING ) {
834	m_pAudioDriver->m_transport.m_nFrames += nframes;
835	}
836
837	// float fRenderTime = (renderTime_end.tv_sec - renderTime_start.tv_sec) * 1000.0 + (renderTime_end.tv_usec - renderTime_start.tv_usec) / 1000.0;
838	float fLadspaTime =
839	( ladspaTime_end.tv_sec - ladspaTime_start.tv_sec ) * 1000.0
840	+ ( ladspaTime_end.tv_usec - ladspaTime_start.tv_usec ) / 1000.0;
841
842	timeval finishTimeval = currentTime2();
843	m_fProcessTime =
844	( finishTimeval.tv_sec - startTimeval.tv_sec ) * 1000.0
845	+ ( finishTimeval.tv_usec - startTimeval.tv_usec ) / 1000.0;
846
847	float sampleRate = ( float )m_pAudioDriver->getSampleRate();
848	m_fMaxProcessTime = 1000.0 / ( sampleRate / nframes );
849
850	#ifdef CONFIG_DEBUG
851	if ( m_fProcessTime > m_fMaxProcessTime ) {
852	_WARNINGLOG( "" );
853	_WARNINGLOG( "----XRUN----" );
854	_WARNINGLOG( QString( "XRUN of %1 msec (%2 > %3)" )
855	.arg( ( m_fProcessTime - m_fMaxProcessTime ) )
856	.arg( m_fProcessTime ).arg( m_fMaxProcessTime ) );
857	_WARNINGLOG( QString( "Ladspa process time = %1" ).arg( fLadspaTime ) );
858	_WARNINGLOG( "------------" );
859	_WARNINGLOG( "" );
860	// raise xRun event
861	EventQueue::get_instance()->push_event( EVENT_XRUN, -1 );
862	}
863	#endif
864
865	AudioEngine::get_instance()->unlock();
866
867	if ( sendPatternChange ) {
868	EventQueue::get_instance()->push_event( EVENT_PATTERN_CHANGED, -1 );
869	}
870
871	return 0;
872	}
873
874
875
876
877
878	void audioEngine_setupLadspaFX( unsigned nBufferSize )
879	{
880	//_INFOLOG( "buffersize=" + to_string(nBufferSize) );
881
882	if ( m_pSong == NULL ) {
883	//_INFOLOG( "m_pSong=NULL" );
884	return;
885	}
886	if ( nBufferSize == 0 ) {
887	_ERRORLOG( "nBufferSize=0" );
888	return;
889	}
890
891	#ifdef LADSPA_SUPPORT
892	for ( unsigned nFX = 0; nFX < MAX_FX; ++nFX ) {
893	LadspaFX *pFX = Effects::getInstance()->getLadspaFX( nFX );
894	if ( pFX == NULL ) {
895	return;
896	}
897
898	pFX->deactivate();
899
900	// delete[] pFX->m_pBuffer_L;
901	// pFX->m_pBuffer_L = NULL;
902	// delete[] pFX->m_pBuffer_R;
903	// pFX->m_pBuffer_R = NULL;
904	// if ( nBufferSize != 0 ) {
905	//pFX->m_nBufferSize = nBufferSize;
906	//pFX->m_pBuffer_L = new float[ nBufferSize ];
907	//pFX->m_pBuffer_R = new float[ nBufferSize ];
908	// }
909
910	Effects::getInstance()->getLadspaFX( nFX )->connectAudioPorts(
911	pFX->m_pBuffer_L,
912	pFX->m_pBuffer_R,
913	pFX->m_pBuffer_L,
914	pFX->m_pBuffer_R
915	);
916	pFX->activate();
917	}
918	#endif
919	}
920
921
922
923	void audioEngine_renameJackPorts()
924	{
925	#ifdef JACK_SUPPORT
926	// renames jack ports
927	if ( m_pSong == NULL ) {
928	return;
929	}
930	if ( m_pAudioDriver->get_class_name() == "JackOutput" ) {
931	static_cast< JackOutput* >( m_pAudioDriver )->makeTrackOutputs( m_pSong );
932	}
933
934	AudioEngine::get_instance()->get_sampler()->makeTrackOutputQueues();
935
936	#endif
937	}
938
939
940
941	void audioEngine_setSong( Song *newSong )
942	{
943	_WARNINGLOG( QString( "Set song: %1" ).arg( newSong->__name ) );
944
945	AudioEngine::get_instance()->lock( "audioEngine_setSong" );
946
947	if ( m_audioEngineState == STATE_PLAYING ) {
948	m_pAudioDriver->stop();
949	audioEngine_stop( false );
950	}
951
952	// check current state
953	if ( m_audioEngineState != STATE_PREPARED ) {
954	_ERRORLOG( "Error the audio engine is not in PREPARED state" );
955	}
956
957	m_pPlayingPatterns->clear();
958	m_pNextPatterns->clear();
959
960	EventQueue::get_instance()->push_event( EVENT_SELECTED_PATTERN_CHANGED, -1 );
961	EventQueue::get_instance()->push_event( EVENT_PATTERN_CHANGED, -1 );
962	EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
963
964	//sleep( 1 );
965
966	audioEngine_clearNoteQueue();
967
968	assert( m_pSong == NULL );
969	m_pSong = newSong;
970
971	// setup LADSPA FX
972	audioEngine_setupLadspaFX( m_pAudioDriver->getBufferSize() );
973
974	// update ticksize
975	audioEngine_process_checkBPMChanged();
976
977	// find the first pattern and set as current
978	if ( m_pSong->get_pattern_list()->get_size() > 0 ) {
979	m_pPlayingPatterns->add( m_pSong->get_pattern_list()->get( 0 ) );
980	}
981
982
983	audioEngine_renameJackPorts();
984
985	m_pAudioDriver->setBpm( m_pSong->__bpm );
986
987	// change the current audio engine state
988	m_audioEngineState = STATE_READY;
989
990	m_pAudioDriver->locate( 0 );
991
992	AudioEngine::get_instance()->unlock();
993
994	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_READY );
995	}
996
997
998
999	void audioEngine_removeSong()
1000	{
1001	AudioEngine::get_instance()->lock( "audioEngine_removeSong" );
1002
1003	if ( m_audioEngineState == STATE_PLAYING ) {
1004	m_pAudioDriver->stop();
1005	audioEngine_stop( false );
1006	}
1007
1008	// check current state
1009	if ( m_audioEngineState != STATE_READY ) {
1010	_ERRORLOG( "Error the audio engine is not in READY state" );
1011	AudioEngine::get_instance()->unlock();
1012	return;
1013	}
1014
1015	m_pSong = NULL;
1016	m_pPlayingPatterns->clear();
1017	m_pNextPatterns->clear();
1018
1019	audioEngine_clearNoteQueue();
1020
1021	// change the current audio engine state
1022	m_audioEngineState = STATE_PREPARED;
1023	AudioEngine::get_instance()->unlock();
1024
1025	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_PREPARED );
1026	}
1027
1028
1029
1030	// return -1 = end of song
1031	// return 2 = send pattern changed event!!
1032	inline int audioEngine_updateNoteQueue( unsigned nFrames )
1033	{
1034	static int nLastTick = -1;
1035	bool bSendPatternChange = false;
1036	int nMaxTimeHumanize = 2000;
1037	int nLeadLagFactor = m_pAudioDriver->m_transport.m_nTickSize * 5; // 5 ticks
1038
1039	unsigned int framepos;
1040	if ( m_audioEngineState == STATE_PLAYING ) {
1041	framepos = m_pAudioDriver->m_transport.m_nFrames;
1042	} else {
1043	// use this to support realtime events when not playing
1044	framepos = m_nRealtimeFrames;
1045	}
1046
1047	int tickNumber_start = 0;
1048
1049	// We need to look ahead in the song for notes with negative offsets
1050	// from LeadLag or Humanize. When starting from the beginning, we prime
1051	// the note queue with notes between 0 and nFrames plus
1052	// lookahead. lookahead should be equal or greater than the
1053	// nLeadLagFactor + nMaxTimeHumanize.
1054	int lookahead = nLeadLagFactor + nMaxTimeHumanize + 1;
1055	m_nLookaheadFrames = lookahead;
1056	if ( framepos == 0
1057	\|\| ( m_audioEngineState == STATE_PLAYING
1058	&& m_pSong->get_mode() == Song::SONG_MODE
1059	&& m_nSongPos == -1 ) ) {
1060	tickNumber_start = (int)( framepos
1061	/ m_pAudioDriver->m_transport.m_nTickSize );
1062	}
1063	else {
1064	tickNumber_start = (int)( (framepos + lookahead)
1065	/ m_pAudioDriver->m_transport.m_nTickSize );
1066	}
1067	int tickNumber_end = (int)( (framepos + nFrames + lookahead)
1068	/ m_pAudioDriver->m_transport.m_nTickSize );
1069
1070	int tick = tickNumber_start;
1071
1072	// _WARNINGLOG( "Lookahead: " + to_string( lookahead
1073	// / m_pAudioDriver->m_transport.m_nTickSize ) );
1074	// get initial timestamp for first tick
1075	gettimeofday( &m_currentTickTime, NULL );
1076
1077
1078	while ( tick <= tickNumber_end ) {
1079	if ( tick == nLastTick ) {
1080	++tick;
1081	continue;
1082	} else {
1083	nLastTick = tick;
1084	}
1085
1086
1087	// midi events now get put into the m_songNoteQueue as well,
1088	// based on their timestamp
1089	while ( m_midiNoteQueue.size() > 0 ) {
1090	Note *note = m_midiNoteQueue[0];
1091
1092	if ( ( int )note->get_position() <= tick ) {
1093	// printf ("tick=%d pos=%d\n", tick, note->getPosition());
1094	m_midiNoteQueue.pop_front();
1095	note->get_instrument()->enqueue();
1096	m_songNoteQueue.push( note );
1097	} else {
1098	break;
1099	}
1100	}
1101
1102	if ( m_audioEngineState != STATE_PLAYING ) {
1103	// only keep going if we're playing
1104	continue;
1105	}
1106
1107	// if ( m_nPatternStartTick == -1 ) { // for debugging pattern mode :s
1108	// _WARNINGLOG( "m_nPatternStartTick == -1; tick = "
1109	// + to_string( tick ) );
1110	// }
1111
1112
1113	// SONG MODE
1114	if ( m_pSong->get_mode() == Song::SONG_MODE ) {
1115	if ( m_pSong->get_pattern_group_vector()->size() == 0 ) {
1116	// there's no song!!
1117	_ERRORLOG( "no patterns in song." );
1118	m_pAudioDriver->stop();
1119	return -1;
1120	}
1121
1122	m_nSongPos = findPatternInTick( tick,
1123	m_pSong->is_loop_enabled(),
1124	&m_nPatternStartTick );
1125	if ( m_nSongSizeInTicks != 0 ) {
1126	m_nPatternTickPosition = ( tick - m_nPatternStartTick )
1127	% m_nSongSizeInTicks;
1128	} else {
1129	m_nPatternTickPosition = tick - m_nPatternStartTick;
1130	}
1131
1132	if ( m_nPatternTickPosition == 0 ) {
1133	bSendPatternChange = true;
1134	}
1135
1136	// PatternList *pPatternList =
1137	// (*(m_pSong->getPatternGroupVector()))[m_nSongPos];
1138	if ( m_nSongPos == -1 ) {
1139	_INFOLOG( "song pos = -1" );
1140	if ( m_pSong->is_loop_enabled() == true ) {
1141	m_nSongPos = findPatternInTick( 0,
1142	true,
1143	&m_nPatternStartTick );
1144	} else {
1145	_INFOLOG( "End of Song" );
1146	return -1;
1147	}
1148	}
1149	PatternList *pPatternList =
1150	( *( m_pSong->get_pattern_group_vector() ) )[m_nSongPos];
1151	// copio tutti i pattern
1152	m_pPlayingPatterns->clear();
1153	if ( pPatternList ) {
1154	for ( unsigned i = 0; i < pPatternList->get_size(); ++i ) {
1155	m_pPlayingPatterns->add( pPatternList->get( i ) );
1156	}
1157	}
1158	}
1159
1160	// PATTERN MODE
1161	else if ( m_pSong->get_mode() == Song::PATTERN_MODE ) {
1162	// per ora considero solo il primo pattern, se ce ne
1163	// saranno piu' di uno bisognera' prendere quello piu'
1164	// piccolo
1165
1166	//m_nPatternTickPosition = tick % m_pCurrentPattern->getSize();
1167	int nPatternSize = MAX_NOTES;
1168
1169
1170	if ( Preferences::getInstance()->patternModePlaysSelected() )
1171	{
1172	m_pPlayingPatterns->clear();
1173	Pattern * pSelectedPattern =
1174	m_pSong->get_pattern_list()
1175	->get(m_nSelectedPatternNumber);
1176	m_pPlayingPatterns->add( pSelectedPattern );
1177	}
1178
1179
1180	if ( m_pPlayingPatterns->get_size() != 0 ) {
1181	Pattern *pFirstPattern = m_pPlayingPatterns->get( 0 );
1182	nPatternSize = pFirstPattern->get_lenght();
1183	}
1184
1185	if ( nPatternSize == 0 ) {
1186	_ERRORLOG( "nPatternSize == 0" );
1187	}
1188
1189	if ( ( tick == m_nPatternStartTick + nPatternSize )
1190	\|\| ( m_nPatternStartTick == -1 ) ) {
1191	if ( m_pNextPatterns->get_size() > 0 ) {
1192	Pattern * p;
1193	for ( uint i = 0;
1194	i < m_pNextPatterns->get_size();
1195	i++ ) {
1196	p = m_pNextPatterns->get( i );
1197	// _WARNINGLOG( QString( "Got pattern # %1" )
1198	// .arg( i + 1 ) );
1199	// if the pattern isn't playing
1200	// already, start it now.
1201	if ( ( m_pPlayingPatterns->del( p ) ) == NULL ) {
1202	m_pPlayingPatterns->add( p );
1203	}
1204	}
1205	m_pNextPatterns->clear();
1206	bSendPatternChange = true;
1207	}
1208	if ( m_nPatternStartTick == -1 ) {
1209	m_nPatternStartTick = tick - (tick % nPatternSize);
1210	// _WARNINGLOG( "set Pattern Start Tick to "
1211	// + to_string( m_nPatternStartTick ) );
1212	} else {
1213	m_nPatternStartTick = tick;
1214	}
1215	}
1216	m_nPatternTickPosition = tick - m_nPatternStartTick;
1217	if ( m_nPatternTickPosition > nPatternSize ) {
1218	m_nPatternTickPosition = tick % nPatternSize;
1219	}
1220	}
1221
1222	// metronome
1223	// if ( ( m_nPatternStartTick == tick )
1224	// \|\| ( ( tick - m_nPatternStartTick ) % 48 == 0 ) ) {
1225	if ( m_nPatternTickPosition % 48 == 0 ) {
1226	float fPitch;
1227	float fVelocity;
1228	// _INFOLOG( "Beat: " + to_string(m_nPatternTickPosition / 48 + 1)
1229	// + "@ " + to_string( tick ) );
1230	if ( m_nPatternTickPosition == 0 ) {
1231	fPitch = 3;
1232	fVelocity = 1.0;
1233	EventQueue::get_instance()->push_event( EVENT_METRONOME, 1 );
1234	} else {
1235	fPitch = 0;
1236	fVelocity = 0.8;
1237	EventQueue::get_instance()->push_event( EVENT_METRONOME, 0 );
1238	}
1239	if ( Preferences::getInstance()->m_bUseMetronome ) {
1240	m_pMetronomeInstrument->set_volume(
1241	Preferences::getInstance()->m_fMetronomeVolume
1242	);
1243	Note *pMetronomeNote = new Note( m_pMetronomeInstrument,
1244	tick,
1245	fVelocity,
1246	0.5,
1247	0.5,
1248	-1,
1249	fPitch
1250	);
1251	m_pMetronomeInstrument->enqueue();
1252	m_songNoteQueue.push( pMetronomeNote );
1253	}
1254	}
1255
1256	// update the notes queue
1257	if ( m_pPlayingPatterns->get_size() != 0 ) {
1258	for ( unsigned nPat = 0 ;
1259	nPat < m_pPlayingPatterns->get_size() ;
1260	++nPat ) {
1261	Pattern *pPattern = m_pPlayingPatterns->get( nPat );
1262	assert( pPattern != NULL );
1263
1264	std::multimap <int, Note*>::iterator pos;
1265	for ( pos = pPattern->note_map.lower_bound( m_nPatternTickPosition ) ;
1266	pos != pPattern->note_map.upper_bound( m_nPatternTickPosition ) ;
1267	++pos ) {
1268	Note *pNote = pos->second;
1269	if ( pNote ) {
1270	int nOffset = 0;
1271
1272	// Swing
1273	float fSwingFactor = m_pSong->get_swing_factor();
1274
1275	if ( ( ( m_nPatternTickPosition % 12 ) == 0 )
1276	&& ( ( m_nPatternTickPosition % 24 ) != 0 ) ) {
1277	// da l'accento al tick 4, 12, 20, 36...
1278	nOffset += ( int )(
1279	6.0
1280	* m_pAudioDriver->m_transport.m_nTickSize
1281	* fSwingFactor
1282	);
1283	}
1284
1285	// Humanize - Time parameter
1286	if ( m_pSong->get_humanize_time_value() != 0 ) {
1287	nOffset += ( int )(
1288	getGaussian( 0.3 )
1289	* m_pSong->get_humanize_time_value()
1290	* nMaxTimeHumanize
1291	);
1292	}
1293	//~
1294	// Lead or Lag - timing parameter
1295	nOffset += (int) ( pNote->get_leadlag()
1296	* nLeadLagFactor);
1297	//~
1298
1299	if((tick == 0) && (nOffset < 0)) {
1300	nOffset = 0;
1301	}
1302	Note *pCopiedNote = new Note( pNote );
1303	pCopiedNote->set_position( tick );
1304
1305	// humanize time
1306	pCopiedNote->m_nHumanizeDelay = nOffset;
1307	pNote->get_instrument()->enqueue();
1308	m_songNoteQueue.push( pCopiedNote );
1309	//pCopiedNote->dumpInfo();
1310	}
1311	}
1312	}
1313	}
1314	++tick;
1315	}
1316
1317
1318	// audioEngine_process must send the pattern change event after mutex unlock
1319	if ( bSendPatternChange ) {
1320	return 2;
1321	}
1322	return 0;
1323	}
1324
1325
1326
1327	/// restituisce l'indice relativo al patternGroup in base al tick
1328	inline int findPatternInTick( int nTick, bool bLoopMode, int *pPatternStartTick )
1329	{
1330	assert( m_pSong );
1331
1332	int nTotalTick = 0;
1333	m_nSongSizeInTicks = 0;
1334
1335	std::vector<PatternList> pPatternColumns = m_pSong->get_pattern_group_vector();
1336	int nColumns = pPatternColumns->size();
1337
1338	int nPatternSize;
1339	for ( int i = 0; i < nColumns; ++i ) {
1340	PatternList pColumn = ( pPatternColumns )[ i ];
1341	if ( pColumn->get_size() != 0 ) {
1342	// tengo in considerazione solo il primo pattern. I
1343	// pattern nel gruppo devono avere la stessa lunghezza.
1344	nPatternSize = pColumn->get( 0 )->get_lenght();
1345	} else {
1346	nPatternSize = MAX_NOTES;
1347	}
1348
1349	if ( ( nTick >= nTotalTick ) && ( nTick < nTotalTick + nPatternSize ) ) {
1350	( *pPatternStartTick ) = nTotalTick;
1351	return i;
1352	}
1353	nTotalTick += nPatternSize;
1354	}
1355
1356	if ( bLoopMode ) {
1357	m_nSongSizeInTicks = nTotalTick;
1358	int nLoopTick = 0;
1359	if ( m_nSongSizeInTicks != 0 ) {
1360	nLoopTick = nTick % m_nSongSizeInTicks;
1361	}
1362	nTotalTick = 0;
1363	for ( int i = 0; i < nColumns; ++i ) {
1364	PatternList pColumn = ( pPatternColumns )[ i ];
1365	if ( pColumn->get_size() != 0 ) {
1366	// tengo in considerazione solo il primo
1367	// pattern. I pattern nel gruppo devono avere la
1368	// stessa lunghezza.
1369	nPatternSize = pColumn->get( 0 )->get_lenght();
1370	} else {
1371	nPatternSize = MAX_NOTES;
1372	}
1373
1374	if ( ( nLoopTick >= nTotalTick )
1375	&& ( nLoopTick < nTotalTick + nPatternSize ) ) {
1376	( *pPatternStartTick ) = nTotalTick;
1377	return i;
1378	}
1379	nTotalTick += nPatternSize;
1380	}
1381	}
1382
1383	char tmp[200];
1384	sprintf( tmp, "[findPatternInTick] tick = %d. No pattern found", nTick );
1385	_ERRORLOG( tmp );
1386	return -1;
1387	}
1388
1389
1390
1391	void audioEngine_noteOn( Note *note )
1392	{
1393	// check current state
1394	if ( ( m_audioEngineState != STATE_READY )
1395	&& ( m_audioEngineState != STATE_PLAYING ) ) {
1396	_ERRORLOG( "Error the audio engine is not in READY state" );
1397	delete note;
1398	return;
1399	}
1400
1401	m_midiNoteQueue.push_back( note );
1402	}
1403
1404
1405
1406	void audioEngine_noteOff( Note *note )
1407	{
1408	/*
1409	if ( note == NULL ) {
1410	_ERRORLOG( "Error, note == NULL" );
1411	}
1412
1413	AudioEngine::get_instance()->lock( "audioEngine_noteOff" );
1414
1415	// check current state
1416	if ( ( m_audioEngineState != STATE_READY )
1417	&& ( m_audioEngineState != STATE_PLAYING ) ) {
1418	_ERRORLOG( "Error the audio engine is not in READY state" );
1419	delete note;
1420	AudioEngine::get_instance()->unlock();
1421	return;
1422	}
1423
1424	// AudioEngine::get_instance()->get_sampler()->note_off( note );
1425	AudioEngine::get_instance()->unlock();
1426	delete note;
1427	*/
1428	}
1429
1430
1431
1432	// unsigned long audioEngine_getTickPosition()
1433	// {
1434	// return m_nPatternTickPosition;
1435	// }
1436
1437
1438	AudioOutput* createDriver( const QString& sDriver )
1439	{
1440	_INFOLOG( QString( "Driver: '%1'" ).arg( sDriver ) );
1441	Preferences *pPref = Preferences::getInstance();
1442	AudioOutput *pDriver = NULL;
1443
1444	if ( sDriver == "Oss" ) {
1445	pDriver = new OssDriver( audioEngine_process );
1446	if ( pDriver->get_class_name() == "NullDriver" ) {
1447	delete pDriver;
1448	pDriver = NULL;
1449	}
1450	} else if ( sDriver == "Jack" ) {
1451	pDriver = new JackOutput( audioEngine_process );
1452	if ( pDriver->get_class_name() == "NullDriver" ) {
1453	delete pDriver;
1454	pDriver = NULL;
1455	} else {
1456	#ifdef JACK_SUPPORT
1457	static_cast<JackOutput*>(pDriver)->setConnectDefaults(
1458	Preferences::getInstance()->m_bJackConnectDefaults
1459	);
1460	#endif
1461	}
1462	} else if ( sDriver == "Alsa" ) {
1463	pDriver = new AlsaAudioDriver( audioEngine_process );
1464	if ( pDriver->get_class_name() == "NullDriver" ) {
1465	delete pDriver;
1466	pDriver = NULL;
1467	}
1468	} else if ( sDriver == "PortAudio" ) {
1469	pDriver = new PortAudioDriver( audioEngine_process );
1470	if ( pDriver->get_class_name() == "NullDriver" ) {
1471	delete pDriver;
1472	pDriver = NULL;
1473	}
1474	}
1475	//#ifdef Q_OS_MACX
1476	else if ( sDriver == "CoreAudio" ) {
1477	_INFOLOG( "Creating CoreAudioDriver" );
1478	pDriver = new CoreAudioDriver( audioEngine_process );
1479	if ( pDriver->get_class_name() == "NullDriver" ) {
1480	delete pDriver;
1481	pDriver = NULL;
1482	}
1483	}
1484	//#endif
1485	else if ( sDriver == "Fake" ) {
1486	_WARNINGLOG( "* Using FAKE audio driver *" );
1487	pDriver = new FakeDriver( audioEngine_process );
1488	} else {
1489	_ERRORLOG( "Unknown driver " + sDriver );
1490	audioEngine_raiseError( Hydrogen::UNKNOWN_DRIVER );
1491	}
1492
1493	if ( pDriver ) {
1494	// initialize the audio driver
1495	int res = pDriver->init( pPref->m_nBufferSize );
1496	if ( res != 0 ) {
1497	_ERRORLOG( "Error starting audio driver [audioDriver::init()]" );
1498	delete pDriver;
1499	pDriver = NULL;
1500	}
1501	}
1502
1503	return pDriver;
1504	}
1505
1506
1507	/// Start all audio drivers
1508	void audioEngine_startAudioDrivers()
1509	{
1510	Preferences *preferencesMng = Preferences::getInstance();
1511
1512	AudioEngine::get_instance()->lock( "audioEngine_startAudioDrivers" );
1513
1514	_INFOLOG( "[audioEngine_startAudioDrivers]" );
1515
1516	// check current state
1517	if ( m_audioEngineState != STATE_INITIALIZED ) {
1518	_ERRORLOG( QString( "Error the audio engine is not in INITIALIZED"
1519	" state. state=%1" )
1520	.arg( m_audioEngineState ) );
1521	AudioEngine::get_instance()->unlock();
1522	return;
1523	}
1524	if ( m_pAudioDriver ) { // check if the audio m_pAudioDriver is still alive
1525	_ERRORLOG( "The audio driver is still alive" );
1526	}
1527	if ( m_pMidiDriver ) { // check if midi driver is still alive
1528	_ERRORLOG( "The MIDI driver is still active" );
1529	}
1530
1531
1532	QString sAudioDriver = preferencesMng->m_sAudioDriver;
1533	// sAudioDriver = "Auto";
1534	if ( sAudioDriver == "Auto" ) {
1535	if ( ( m_pAudioDriver = createDriver( "Jack" ) ) == NULL ) {
1536	if ( ( m_pAudioDriver = createDriver( "Alsa" ) ) == NULL ) {
1537	if ( ( m_pAudioDriver = createDriver( "CoreAudio" ) ) == NULL ) {
1538	if ( ( m_pAudioDriver = createDriver( "PortAudio" ) ) == NULL ) {
1539	if ( ( m_pAudioDriver = createDriver( "Oss" ) ) == NULL ) {
1540	audioEngine_raiseError( Hydrogen::ERROR_STARTING_DRIVER );
1541	_ERRORLOG( "Error starting audio driver" );
1542	_ERRORLOG( "Using the NULL output audio driver" );
1543
1544	// use the NULL output driver
1545	m_pAudioDriver = new NullDriver( audioEngine_process );
1546	m_pAudioDriver->init( 0 );
1547	}
1548	}
1549	}
1550	}
1551	}
1552	} else {
1553	m_pAudioDriver = createDriver( sAudioDriver );
1554	if ( m_pAudioDriver == NULL ) {
1555	audioEngine_raiseError( Hydrogen::ERROR_STARTING_DRIVER );
1556	_ERRORLOG( "Error starting audio driver" );
1557	_ERRORLOG( "Using the NULL output audio driver" );
1558
1559	// use the NULL output driver
1560	m_pAudioDriver = new NullDriver( audioEngine_process );
1561	m_pAudioDriver->init( 0 );
1562	}
1563	}
1564
1565	if ( preferencesMng->m_sMidiDriver == "ALSA" ) {
1566	#ifdef ALSA_SUPPORT
1567	// Create MIDI driver
1568	m_pMidiDriver = new AlsaMidiDriver();
1569	m_pMidiDriver->open();
1570	m_pMidiDriver->setActive( true );
1571	#endif
1572	} else if ( preferencesMng->m_sMidiDriver == "PortMidi" ) {
1573	#ifdef PORTMIDI_SUPPORT
1574	m_pMidiDriver = new PortMidiDriver();
1575	m_pMidiDriver->open();
1576	m_pMidiDriver->setActive( true );
1577	#endif
1578	} else if ( preferencesMng->m_sMidiDriver == "CoreMidi" ) {
1579	#ifdef COREMIDI_SUPPORT
1580	m_pMidiDriver = new CoreMidiDriver();
1581	m_pMidiDriver->open();
1582	m_pMidiDriver->setActive( true );
1583	#endif
1584	}
1585
1586	// change the current audio engine state
1587	if ( m_pSong == NULL ) {
1588	m_audioEngineState = STATE_PREPARED;
1589	} else {
1590	m_audioEngineState = STATE_READY;
1591	}
1592
1593
1594	if ( m_pSong ) {
1595	m_pAudioDriver->setBpm( m_pSong->__bpm );
1596	}
1597
1598	// update the audiodriver reference in the sampler
1599	AudioEngine::get_instance()->get_sampler()->set_audio_output( m_pAudioDriver );
1600
1601	if ( m_pAudioDriver ) {
1602	int res = m_pAudioDriver->connect();
1603	if ( res != 0 ) {
1604	audioEngine_raiseError( Hydrogen::ERROR_STARTING_DRIVER );
1605	_ERRORLOG( "Error starting audio driver [audioDriver::connect()]" );
1606	_ERRORLOG( "Using the NULL output audio driver" );
1607
1608	delete m_pAudioDriver;
1609	m_pAudioDriver = new NullDriver( audioEngine_process );
1610	m_pAudioDriver->init( 0 );
1611	m_pAudioDriver->connect();
1612	}
1613
1614	if ( ( m_pMainBuffer_L = m_pAudioDriver->getOut_L() ) == NULL ) {
1615	_ERRORLOG( "m_pMainBuffer_L == NULL" );
1616	}
1617	if ( ( m_pMainBuffer_R = m_pAudioDriver->getOut_R() ) == NULL ) {
1618	_ERRORLOG( "m_pMainBuffer_R == NULL" );
1619	}
1620
1621	#ifdef JACK_SUPPORT
1622	audioEngine_renameJackPorts();
1623	#endif
1624
1625	audioEngine_setupLadspaFX( m_pAudioDriver->getBufferSize() );
1626	}
1627
1628
1629
1630	if ( m_audioEngineState == STATE_PREPARED ) {
1631	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_PREPARED );
1632	} else if ( m_audioEngineState == STATE_READY ) {
1633	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_READY );
1634	}
1635	// Unlocking earlier might execute the jack process() callback before we
1636	// are fully initialized.
1637	AudioEngine::get_instance()->unlock();
1638	}
1639
1640
1641
1642	/// Stop all audio drivers
1643	void audioEngine_stopAudioDrivers()
1644	{
1645	_INFOLOG( "[audioEngine_stopAudioDrivers]" );
1646
1647	AudioEngine::get_instance()->lock( "audioEngine_stopAudioDrivers" );
1648
1649	// check current state
1650	if ( m_audioEngineState == STATE_PLAYING ) {
1651	audioEngine_stop();
1652	}
1653
1654	if ( ( m_audioEngineState != STATE_PREPARED )
1655	&& ( m_audioEngineState != STATE_READY ) ) {
1656	_ERRORLOG( QString( "Error: the audio engine is not in PREPARED"
1657	" or READY state. state=%1" )
1658	.arg( m_audioEngineState ) );
1659	return;
1660	}
1661
1662	// delete MIDI driver
1663	if ( m_pMidiDriver ) {
1664	m_pMidiDriver->close();
1665	delete m_pMidiDriver;
1666	m_pMidiDriver = NULL;
1667	}
1668
1669	AudioEngine::get_instance()->get_sampler()->set_audio_output( NULL );
1670
1671	// delete audio driver
1672	if ( m_pAudioDriver ) {
1673	m_pAudioDriver->disconnect();
1674	delete m_pAudioDriver;
1675	m_pAudioDriver = NULL;
1676	}
1677
1678
1679	// change the current audio engine state
1680	m_audioEngineState = STATE_INITIALIZED;
1681	EventQueue::get_instance()->push_event( EVENT_STATE, STATE_INITIALIZED );
1682	AudioEngine::get_instance()->unlock();
1683	}
1684
1685
1686
1687	/// Restart all audio and midi drivers
1688	void audioEngine_restartAudioDrivers()
1689	{
1690	audioEngine_stopAudioDrivers();
1691	audioEngine_startAudioDrivers();
1692	}
1693
1694
1695
1696
1697
1698
1699	//----------------------------------------------------------------------------
1700	//
1701	// Implementation of Hydrogen class
1702	//
1703	//----------------------------------------------------------------------------
1704
1705	/// static reference of Hydrogen class (Singleton)
1706	Hydrogen* Hydrogen::__instance = NULL;
1707
1708
1709
1710
1711	Hydrogen::Hydrogen()
1712	: Object( "Hydrogen" )
1713	{
1714	if ( __instance ) {
1715	_ERRORLOG( "Hydrogen audio engine is already running" );
1716	throw H2Exception( "Hydrogen audio engine is already running" );
1717	}
1718
1719	_INFOLOG( "[Hydrogen]" );
1720
1721	hydrogenInstance = this;
1722	// __instance = this;
1723	audioEngine_init();
1724	audioEngine_startAudioDrivers();
1725
1726	}
1727
1728
1729
1730	Hydrogen::~Hydrogen()
1731	{
1732	_INFOLOG( "[~Hydrogen]" );
1733	if ( m_audioEngineState == STATE_PLAYING ) {
1734	audioEngine_stop();
1735	}
1736	removeSong();
1737	audioEngine_stopAudioDrivers();
1738	audioEngine_destroy();
1739	__kill_instruments();
1740	__instance = NULL;
1741	}
1742
1743
1744
1745	/// Return the Hydrogen instance
1746	Hydrogen* Hydrogen::get_instance()
1747	{
1748	if ( __instance == NULL ) {
1749	__instance = new Hydrogen();
1750	}
1751	return __instance;
1752	}
1753
1754
1755
1756	/// Start the internal sequencer
1757	void Hydrogen::sequencer_play()
1758	{
1759	m_pAudioDriver->play();
1760	}
1761
1762
1763
1764	/// Stop the internal sequencer
1765	void Hydrogen::sequencer_stop()
1766	{
1767	m_pAudioDriver->stop();
1768	}
1769
1770
1771
1772	void Hydrogen::setSong( Song *pSong )
1773	{
1774	audioEngine_setSong( pSong );
1775	}
1776
1777
1778
1779	void Hydrogen::removeSong()
1780	{
1781	audioEngine_removeSong();
1782	}
1783
1784
1785
1786	Song* Hydrogen::getSong()
1787	{
1788	return m_pSong;
1789	}
1790
1791
1792
1793	void Hydrogen::midi_noteOn( Note *note )
1794	{
1795	audioEngine_noteOn( note );
1796	}
1797
1798
1799
1800	void Hydrogen::addRealtimeNote( int instrument,
1801	float velocity,
1802	float pan_L,
1803	float pan_R,
1804	float pitch,
1805	bool noteOff,
1806	bool forcePlay,
1807	int msg1 )
1808	{
1809	UNUSED( pitch );
1810
1811	Preferences *pref = Preferences::getInstance();
1812	unsigned int realcolumn = 0;
1813	unsigned res = pref->getPatternEditorGridResolution();
1814	int nBase = pref->isPatternEditorUsingTriplets() ? 3 : 4;
1815	int scalar = ( 4 * MAX_NOTES ) / ( res * nBase );
1816	bool hearnote = forcePlay;
1817
1818	AudioEngine::get_instance()->lock( "Hydrogen::addRealtimeNote" );
1819
1820
1821	Song *song = getSong();
1822	if ( !pref->__playselectedinstrument ){
1823	if ( instrument >= ( int )song->get_instrument_list()->get_size() ) {
1824	// unused instrument
1825	AudioEngine::get_instance()->unlock();
1826	return;
1827	}
1828	}
1829
1830	Pattern* currentPattern = NULL;
1831	if ( m_pSong->get_mode() == Song::PATTERN_MODE \|\|
1832	( !Preferences::getInstance()->__recordsong && m_audioEngineState != STATE_PLAYING )){
1833	PatternList *pPatternList = m_pSong->get_pattern_list();
1834	if ( ( m_nSelectedPatternNumber != -1 )
1835	&& ( m_nSelectedPatternNumber < ( int )pPatternList->get_size() ) ) {
1836	currentPattern = pPatternList->get( m_nSelectedPatternNumber );
1837	}
1838	}else
1839	{
1840	std::vector<PatternList> pColumns = m_pSong->get_pattern_group_vector();
1841	// Pattern *pPattern = NULL;
1842	int pos = getPatternPos() +1;
1843	for ( int i = 0; i < pos; ++i ) {
1844	PatternList pColumn = ( pColumns )[i];
1845	currentPattern = pColumn->get( 0 );
1846	}
1847	}
1848
1849	if( currentPattern == NULL ){
1850	AudioEngine::get_instance()->unlock(); // unlock the audio engine
1851	return;
1852	}
1853
1854	// Get current column and compensate for "lookahead"
1855	unsigned int column = getTickPosition();
1856	unsigned int lookaheadTicks = m_nLookaheadFrames
1857	/ m_pAudioDriver->m_transport.m_nTickSize;
1858	if ( column >= lookaheadTicks ) {
1859	column -= lookaheadTicks;
1860	} else {
1861	lookaheadTicks %= currentPattern->get_lenght();
1862	column = (column + currentPattern->get_lenght() - lookaheadTicks)
1863	% currentPattern->get_lenght();
1864	}
1865
1866	realcolumn = getRealtimeTickPosition();
1867
1868	// quantize it to scale
1869	int qcolumn = ( int )::round( column / ( double )scalar ) * scalar;
1870	if ( qcolumn == MAX_NOTES ) qcolumn = 0;
1871
1872	if ( pref->getQuantizeEvents() ) {
1873	column = qcolumn;
1874	}
1875
1876
1877	unsigned position = column;
1878	m_naddrealtimenotetickposition = column;
1879
1880
1881	Instrument *instrRef = 0;
1882	if ( song ) {
1883	instrRef = song->get_instrument_list()->get( instrument );
1884	}
1885
1886	if ( currentPattern && ( getState() == STATE_PLAYING ) ) {
1887	bool bNoteAlreadyExist = false;
1888	for ( unsigned nNote = 0 ;
1889	nNote < currentPattern->get_lenght() ;
1890	nNote++ ) {
1891	std::multimap <int, Note*>::iterator pos;
1892	for ( pos = currentPattern->note_map.lower_bound( nNote ) ;
1893	pos != currentPattern->note_map.upper_bound( nNote ) ;
1894	++pos ) {
1895	Note *pNote = pos->second;
1896	if ( pNote!=NULL ) {
1897	if ( pNote->get_instrument() == instrRef
1898	&& nNote==column ) {
1899	bNoteAlreadyExist = true;
1900	break;
1901	}
1902	}
1903	}
1904	}
1905
1906	if ( bNoteAlreadyExist ) {
1907	// in this case, we'll leave the note alone
1908	// hear note only if not playing too
1909	if ( pref->getHearNewNotes()
1910	&& getState() == STATE_READY ) {
1911	hearnote = true;
1912	}
1913	} else if ( !pref->getRecordEvents() ) {
1914	if ( pref->getHearNewNotes()
1915	&& ( getState() == STATE_READY
1916	\|\| getState() == STATE_PLAYING ) ) {
1917	hearnote = true;
1918	}
1919	} else {
1920	if ( !pref->__playselectedinstrument ){
1921	// create the new note
1922	Note *note = new Note( instrRef,
1923	position,
1924	velocity,
1925	pan_L,
1926	pan_R,
1927	-1,
1928	0 );
1929	currentPattern->note_map.insert(
1930	std::make_pair( column, note )
1931	);
1932
1933	// hear note if its not in the future
1934	if ( pref->getHearNewNotes()
1935	&& position <= getTickPosition() ) {
1936	hearnote = true;
1937	}
1938
1939	song->__is_modified = true;
1940
1941	EventQueue::get_instance()->push_event( EVENT_PATTERN_MODIFIED, -1 );
1942	}
1943	else if ( pref->__playselectedinstrument ){
1944
1945	Note *note = new Note( song->get_instrument_list()->get( getSelectedInstrumentNumber()),
1946	position,
1947	velocity,
1948	pan_L,
1949	pan_R,
1950	-1,
1951	0 );
1952
1953	int divider = msg1 / 12;
1954	int octave = divider -3;
1955	int notehigh = msg1 - (12 * divider);
1956	note->m_noteKey.m_nOctave = octave;
1957	note->set_midimsg1( msg1 );
1958	if ( notehigh == 0) note->m_noteKey.m_key = H2Core::NoteKey::C;
1959	else if ( notehigh == 1 ) note->m_noteKey.m_key = H2Core::NoteKey::Cs;
1960	else if ( notehigh == 2 ) note->m_noteKey.m_key = H2Core::NoteKey::D;
1961	else if ( notehigh == 3 ) note->m_noteKey.m_key = H2Core::NoteKey::Ef;
1962	else if ( notehigh == 4 ) note->m_noteKey.m_key = H2Core::NoteKey::E;
1963	else if ( notehigh == 5 ) note->m_noteKey.m_key = H2Core::NoteKey::F;
1964	else if ( notehigh == 6 ) note->m_noteKey.m_key = H2Core::NoteKey::Fs;
1965	else if ( notehigh == 7 ) note->m_noteKey.m_key = H2Core::NoteKey::G;
1966	else if ( notehigh == 8 ) note->m_noteKey.m_key = H2Core::NoteKey::Af;
1967	else if ( notehigh == 9 ) note->m_noteKey.m_key = H2Core::NoteKey::A;
1968	else if ( notehigh == 10 ) note->m_noteKey.m_key = H2Core::NoteKey::Bf;
1969	else if ( notehigh == 11 ) note->m_noteKey.m_key = H2Core::NoteKey::B;
1970
1971	currentPattern->note_map.insert(
1972	std::make_pair( column, note )
1973	);
1974
1975	// hear note if its not in the future
1976	if ( pref->getHearNewNotes()
1977	&& position <= getTickPosition() ) {
1978	hearnote = true;
1979	}
1980
1981	song->__is_modified = true;
1982
1983	EventQueue::get_instance()->push_event( EVENT_PATTERN_MODIFIED, -1 );
1984	}
1985	}
1986	} else if ( pref->getHearNewNotes() ) {
1987	hearnote = true;
1988	}
1989
1990	if ( !pref->__playselectedinstrument ){
1991	if ( hearnote && instrRef ) {
1992	Note *note2 = new Note( instrRef,
1993	realcolumn,
1994	velocity,
1995	pan_L,
1996	pan_R,
1997	-1,
1998	0 );
1999	midi_noteOn( note2 );
2000	}
2001	}else
2002	{
2003	if ( hearnote ) {
2004	Note *note2 = new Note( song->get_instrument_list()->get( getSelectedInstrumentNumber()),
2005	realcolumn,
2006	velocity,
2007	pan_L,
2008	pan_R,
2009	-1,
2010	0 );
2011
2012	int divider = msg1 / 12;
2013	int octave = divider -3;
2014	int notehigh = msg1 - (12 * divider);
2015
2016	//ERRORLOG( QString( "octave: %1, note: %2, instrument %3" ).arg( octave ).arg(notehigh).arg(instrument));
2017	note2->m_noteKey.m_nOctave = octave;
2018	if ( notehigh == 0) note2->m_noteKey.m_key = H2Core::NoteKey::C;
2019	else if ( notehigh == 1 ) note2->m_noteKey.m_key = H2Core::NoteKey::Cs;
2020	else if ( notehigh == 2 ) note2->m_noteKey.m_key = H2Core::NoteKey::D;
2021	else if ( notehigh == 3 ) note2->m_noteKey.m_key = H2Core::NoteKey::Ef;
2022	else if ( notehigh == 4 ) note2->m_noteKey.m_key = H2Core::NoteKey::E;
2023	else if ( notehigh == 5 ) note2->m_noteKey.m_key = H2Core::NoteKey::F;
2024	else if ( notehigh == 6 ) note2->m_noteKey.m_key = H2Core::NoteKey::Fs;
2025	else if ( notehigh == 7 ) note2->m_noteKey.m_key = H2Core::NoteKey::G;
2026	else if ( notehigh == 8 ) note2->m_noteKey.m_key = H2Core::NoteKey::Af;
2027	else if ( notehigh == 9 ) note2->m_noteKey.m_key = H2Core::NoteKey::A;
2028	else if ( notehigh == 10 ) note2->m_noteKey.m_key = H2Core::NoteKey::Bf;
2029	else if ( notehigh == 11 ) note2->m_noteKey.m_key = H2Core::NoteKey::B;
2030
2031	note2->set_midimsg1( msg1 );
2032	midi_noteOn( note2 );
2033	}
2034
2035	}
2036
2037
2038	AudioEngine::get_instance()->unlock(); // unlock the audio engine
2039	}
2040
2041
2042
2043	float Hydrogen::getMasterPeak_L()
2044	{
2045	return m_fMasterPeak_L;
2046	}
2047
2048
2049
2050	float Hydrogen::getMasterPeak_R()
2051	{
2052	return m_fMasterPeak_R;
2053	}
2054
2055
2056
2057	unsigned long Hydrogen::getTickPosition()
2058	{
2059	return m_nPatternTickPosition;
2060	}
2061
2062
2063
2064	unsigned long Hydrogen::getRealtimeTickPosition()
2065	{
2066	//unsigned long initTick = audioEngine_getTickPosition();
2067	unsigned int initTick = ( unsigned int )( m_nRealtimeFrames
2068	/ m_pAudioDriver->m_transport.m_nTickSize );
2069	unsigned long retTick;
2070
2071	struct timeval currtime;
2072	struct timeval deltatime;
2073
2074	double sampleRate = ( double ) m_pAudioDriver->getSampleRate();
2075	gettimeofday ( &currtime, NULL );
2076
2077	timersub( &currtime, &m_currentTickTime, &deltatime );
2078
2079	// add a buffers worth for jitter resistance
2080	double deltaSec =
2081	( double ) deltatime.tv_sec
2082	+ ( deltatime.tv_usec / 1000000.0 )
2083	+ ( m_pAudioDriver->getBufferSize() / ( double )sampleRate );
2084
2085	retTick = ( unsigned long ) ( ( sampleRate
2086	/ ( double ) m_pAudioDriver->m_transport.m_nTickSize )
2087	* deltaSec );
2088
2089	retTick = initTick + retTick;
2090
2091	return retTick;
2092	}
2093
2094
2095
2096	PatternList* Hydrogen::getCurrentPatternList()
2097	{
2098	return m_pPlayingPatterns;
2099	}
2100
2101	PatternList * Hydrogen::getNextPatterns()
2102	{
2103	return m_pNextPatterns;
2104	}
2105
2106	/// Set the next pattern (Pattern mode only)
2107	void Hydrogen::sequencer_setNextPattern( int pos, bool appendPattern, bool deletePattern )
2108	{
2109	m_bAppendNextPattern = appendPattern;
2110	m_bDeleteNextPattern = deletePattern;
2111
2112	AudioEngine::get_instance()->lock( "Hydrogen::sequencer_setNextPattern" );
2113
2114	if ( m_pSong && m_pSong->get_mode() == Song::PATTERN_MODE ) {
2115	PatternList *patternList = m_pSong->get_pattern_list();
2116	Pattern * p = patternList->get( pos );
2117	if ( ( pos >= 0 ) && ( pos < ( int )patternList->get_size() ) ) {
2118	// if p is already on the next pattern list, delete it.
2119	if ( m_pNextPatterns->del( p ) == NULL ) {
2120	// WARNINGLOG( "Adding to nextPatterns" );
2121	m_pNextPatterns->add( p );
2122	}/* else {
2123	// WARNINGLOG( "Removing " + to_string(pos) );
2124	}*/
2125	} else {
2126	_ERRORLOG( QString( "pos not in patternList range. pos=%1 "
2127	"patternListSize=%2" )
2128	.arg( pos )
2129	.arg( patternList->get_size() ) );
2130	m_pNextPatterns->clear();
2131	}
2132	} else {
2133	_ERRORLOG( "can't set next pattern in song mode" );
2134	m_pNextPatterns->clear();
2135	}
2136
2137	AudioEngine::get_instance()->unlock();
2138	}
2139
2140
2141
2142	int Hydrogen::getPatternPos()
2143	{
2144	return m_nSongPos;
2145	}
2146
2147
2148
2149	void Hydrogen::restartDrivers()
2150	{
2151	audioEngine_restartAudioDrivers();
2152	}
2153
2154
2155
2156	/// Export a song to a wav file, returns the elapsed time in mSec
2157	void Hydrogen::startExportSong( const QString& filename )
2158	{
2159	if ( getState() == STATE_PLAYING ) {
2160	sequencer_stop();
2161	}
2162	Preferences *pPref = Preferences::getInstance();
2163
2164	m_oldEngineMode = m_pSong->get_mode();
2165	m_bOldLoopEnabled = m_pSong->is_loop_enabled();
2166
2167	m_pSong->set_mode( Song::SONG_MODE );
2168	m_pSong->set_loop_enabled( false );
2169	unsigned nSamplerate = m_pAudioDriver->getSampleRate();
2170
2171	// stop all audio drivers
2172	audioEngine_stopAudioDrivers();
2173
2174	/*
2175	FIXME: Questo codice fa davvero schifo....
2176	*/
2177
2178
2179	m_pAudioDriver = new DiskWriterDriver( audioEngine_process, nSamplerate, filename );
2180
2181	AudioEngine::get_instance()->get_sampler()->stop_playing_notes();
2182	AudioEngine::get_instance()->get_sampler()->set_audio_output( m_pAudioDriver );
2183
2184	// reset
2185	m_pAudioDriver->m_transport.m_nFrames = 0; // reset total frames
2186	m_pAudioDriver->setBpm( m_pSong->__bpm );
2187	m_nSongPos = 0;
2188	m_nPatternTickPosition = 0;
2189	m_audioEngineState = STATE_PLAYING;
2190	m_nPatternStartTick = -1;
2191
2192	int res = m_pAudioDriver->init( pPref->m_nBufferSize );
2193	if ( res != 0 ) {
2194	_ERRORLOG( "Error starting disk writer driver "
2195	"[DiskWriterDriver::init()]" );
2196	}
2197
2198	m_pMainBuffer_L = m_pAudioDriver->getOut_L();
2199	m_pMainBuffer_R = m_pAudioDriver->getOut_R();
2200
2201	audioEngine_setupLadspaFX( m_pAudioDriver->getBufferSize() );
2202
2203	audioEngine_seek( 0, false );
2204
2205	res = m_pAudioDriver->connect();
2206	if ( res != 0 ) {
2207	_ERRORLOG( "Error starting disk writer driver "
2208	"[DiskWriterDriver::connect()]" );
2209	}
2210	}
2211
2212
2213
2214	void Hydrogen::stopExportSong()
2215	{
2216	if ( m_pAudioDriver->get_class_name() != "DiskWriterDriver" ) {
2217	return;
2218	}
2219
2220	// audioEngine_stopAudioDrivers();
2221	m_pAudioDriver->disconnect();
2222
2223	m_audioEngineState = STATE_INITIALIZED;
2224	delete m_pAudioDriver;
2225	m_pAudioDriver = NULL;
2226
2227	m_pMainBuffer_L = NULL;
2228	m_pMainBuffer_R = NULL;
2229
2230	m_pSong->set_mode( m_oldEngineMode );
2231	m_pSong->set_loop_enabled( m_bOldLoopEnabled );
2232
2233	m_nSongPos = -1;
2234	m_nPatternTickPosition = 0;
2235	audioEngine_startAudioDrivers();
2236
2237	if ( m_pAudioDriver ) {
2238	m_pAudioDriver->setBpm( m_pSong->__bpm );
2239	} else {
2240	_ERRORLOG( "m_pAudioDriver = NULL" );
2241	}
2242	}
2243
2244
2245
2246	/// Used to display audio driver info
2247	AudioOutput* Hydrogen::getAudioOutput()
2248	{
2249	return m_pAudioDriver;
2250	}
2251
2252
2253
2254	/// Used to display midi driver info
2255	MidiInput* Hydrogen::getMidiInput()
2256	{
2257	return m_pMidiDriver;
2258	}
2259
2260
2261
2262	void Hydrogen::setMasterPeak_L( float value )
2263	{
2264	m_fMasterPeak_L = value;
2265	}
2266
2267
2268
2269	void Hydrogen::setMasterPeak_R( float value )
2270	{
2271	m_fMasterPeak_R = value;
2272	}
2273
2274
2275
2276	int Hydrogen::getState()
2277	{
2278	return m_audioEngineState;
2279	}
2280
2281
2282
2283	void Hydrogen::setCurrentPatternList( PatternList *pPatternList )
2284	{
2285	AudioEngine::get_instance()->lock( "Hydrogen::setCurrentPatternList" );
2286	m_pPlayingPatterns = pPatternList;
2287	EventQueue::get_instance()->push_event( EVENT_PATTERN_CHANGED, -1 );
2288	AudioEngine::get_instance()->unlock();
2289	}
2290
2291
2292
2293	float Hydrogen::getProcessTime()
2294	{
2295	return m_fProcessTime;
2296	}
2297
2298
2299
2300	float Hydrogen::getMaxProcessTime()
2301	{
2302	return m_fMaxProcessTime;
2303	}
2304
2305
2306
2307	int Hydrogen::loadDrumkit( Drumkit *drumkitInfo )
2308	{
2309	INFOLOG( drumkitInfo->getName() );
2310	m_currentDrumkit = drumkitInfo->getName();
2311	LocalFileMng fileMng;
2312	QString sDrumkitPath = fileMng.getDrumkitDirectory( drumkitInfo->getName() );
2313
2314
2315	//current instrument list
2316	InstrumentList *songInstrList = m_pSong->get_instrument_list();
2317
2318	//new instrument list
2319	InstrumentList *pDrumkitInstrList = drumkitInfo->getInstrumentList();
2320
2321	/*
2322	If the old drumkit is bigger then the new drumkit,
2323	delete all instruments with a bigger pos then
2324	pDrumkitInstrList->get_size(). Otherwise the instruments
2325	from our old instrumentlist with
2326	pos > pDrumkitInstrList->get_size() stay in the
2327	new instrumentlist
2328
2329	wolke: info!
2330	this has moved to the end of this function
2331	because we get lost objects in memory
2332	now:
2333	1. the new drumkit will loaded
2334	2. all not used instruments will complete deleted
2335
2336	old funktion:
2337	while ( pDrumkitInstrList->get_size() < songInstrList->get_size() )
2338	{
2339	songInstrList->del(songInstrList->get_size() - 1);
2340	}
2341	*/
2342
2343	//needed for the new delete function
2344	int instrumentDiff = songInstrList->get_size() - pDrumkitInstrList->get_size();
2345
2346	for ( unsigned nInstr = 0; nInstr < pDrumkitInstrList->get_size(); ++nInstr ) {
2347	Instrument *pInstr = NULL;
2348	if ( nInstr < songInstrList->get_size() ) {
2349	//instrument exists already
2350	pInstr = songInstrList->get( nInstr );
2351	assert( pInstr );
2352	} else {
2353	pInstr = Instrument::create_empty();
2354	// The instrument isn't playing yet; no need for locking
2355	// :-) - Jakob Lund. AudioEngine::get_instance()->lock(
2356	// "Hydrogen::loadDrumkit" );
2357	songInstrList->add( pInstr );
2358	// AudioEngine::get_instance()->unlock();
2359	}
2360
2361	Instrument *pNewInstr = pDrumkitInstrList->get( nInstr );
2362	assert( pNewInstr );
2363	_INFOLOG( QString( "Loading instrument (%1 of %2) [%3]" )
2364	.arg( nInstr )
2365	.arg( pDrumkitInstrList->get_size() )
2366	.arg( pNewInstr->get_name() ) );
2367
2368	// creo i nuovi layer in base al nuovo strumento
2369	// Moved code from here right into the Instrument class - Jakob Lund.
2370	pInstr->load_from_placeholder( pNewInstr );
2371	}
2372
2373
2374	//wolke: new delete funktion
2375	if ( instrumentDiff >=0 ){
2376	for ( int i = 0; i < instrumentDiff ; i++ ){
2377	removeInstrument(
2378	m_pSong->get_instrument_list()->get_size() - 1,
2379	true
2380	);
2381	}
2382	}
2383
2384	#ifdef JACK_SUPPORT
2385	AudioEngine::get_instance()->lock( "Hydrogen::loadDrumkit" );
2386	renameJackPorts();
2387	AudioEngine::get_instance()->unlock();
2388	#endif
2389
2390	return 0; //ok
2391	}
2392
2393
2394	//this is also a new function and will used from the new delete function in
2395	//Hydrogen::loadDrumkit to delete the instruments by number
2396	void Hydrogen::removeInstrument( int instrumentnumber, bool conditional )
2397	{
2398	Instrument *pInstr = m_pSong->get_instrument_list()->get( instrumentnumber );
2399
2400
2401	PatternList* pPatternList = getSong()->get_pattern_list();
2402
2403	if ( conditional ) {
2404	// new! this check if a pattern has an active note if there is an note
2405	//inside the pattern the intrument would not be deleted
2406	for ( int nPattern = 0 ;
2407	nPattern < (int)pPatternList->get_size() ;
2408	++nPattern ) {
2409	if( pPatternList
2410	->get( nPattern )
2411	->references_instrument( pInstr ) ) {
2412	return;
2413	}
2414	}
2415	} else {
2416	getSong()->purge_instrument( pInstr );
2417	}
2418
2419	Song *pSong = getSong();
2420	InstrumentList* pList = pSong->get_instrument_list();
2421	if(pList->get_size()==1){
2422	AudioEngine::get_instance()->lock("HYdrogen::removeInstrument remove last instrument");
2423	Instrument* pInstr = pList->get( 0 );
2424	pInstr->set_name( (QString( "Instrument 1" )) );
2425	// remove all layers
2426	for ( int nLayer = 0; nLayer < MAX_LAYERS; nLayer++ ) {
2427	InstrumentLayer* pLayer = pInstr->get_layer( nLayer );
2428	delete pLayer;
2429	pInstr->set_layer( NULL, nLayer );
2430	}
2431	AudioEngine::get_instance()->unlock();
2432	EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
2433	INFOLOG("clear last instrument to empty instrument 1 instead delete the last instrument");
2434	return;
2435	}
2436
2437	// if the instrument was the last on the instruments list, select the
2438	// next-last
2439	if ( instrumentnumber
2440	>= (int)getSong()->get_instrument_list()->get_size() - 1 ) {
2441	Hydrogen::get_instance()
2442	->setSelectedInstrumentNumber(
2443	std::max(0, instrumentnumber - 1)
2444	);
2445	}
2446	// delete the instrument from the instruments list
2447	AudioEngine::get_instance()->lock( "Hydrogen::removeInstrument" );
2448	getSong()->get_instrument_list()->del( instrumentnumber );
2449	getSong()->__is_modified = true;
2450	AudioEngine::get_instance()->unlock();
2451
2452	// At this point the instrument has been removed from both the
2453	// instrument list and every pattern in the song. Hence there's no way
2454	// (NOTE) to play on that instrument, and once all notes have stopped
2455	// playing it will be save to delete.
2456	// the ugly name is just for debugging...
2457	QString xxx_name = QString( "XXX_%1" ) . arg( pInstr->get_name() );
2458	pInstr->set_name( xxx_name );
2459	__instrument_death_row.push_back( pInstr );
2460	__kill_instruments(); // checks if there are still notes.
2461
2462	// this will force a GUI update.
2463	EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
2464	}
2465
2466
2467	void Hydrogen::raiseError( unsigned nErrorCode )
2468	{
2469	audioEngine_raiseError( nErrorCode );
2470	}
2471
2472
2473	unsigned long Hydrogen::getTotalFrames()
2474	{
2475	return m_pAudioDriver->m_transport.m_nFrames;
2476	}
2477
2478	unsigned long Hydrogen::getRealtimeFrames()
2479	{
2480	return m_nRealtimeFrames;
2481	}
2482
2483	/**
2484	* Get the ticks for pattern at pattern pos
2485	* @a int pos -- position in song
2486	* @return -1 if pos > number of patterns in the song, tick no. > 0 otherwise
2487	* The driver should be LOCKED when calling this!!
2488	*/
2489	long Hydrogen::getTickForPosition( int pos )
2490	{
2491	int nPatternGroups = m_pSong->get_pattern_group_vector()->size();
2492	if( nPatternGroups == 0 ) return -1;
2493
2494	if ( pos >= nPatternGroups ) {
2495	if ( m_pSong->is_loop_enabled() ) {
2496	pos = pos % nPatternGroups;
2497	} else {
2498	_WARNINGLOG( QString( "patternPos > nPatternGroups. pos:"
2499	" %1, nPatternGroups: %2")
2500	.arg( pos )
2501	.arg( nPatternGroups ) );
2502	return -1;
2503	}
2504	}
2505
2506	std::vector<PatternList> pColumns = m_pSong->get_pattern_group_vector();
2507	long totalTick = 0;
2508	int nPatternSize;
2509	Pattern *pPattern = NULL;
2510	for ( int i = 0; i < pos; ++i ) {
2511	PatternList pColumn = ( pColumns )[ i ];
2512	// prendo solo il primo. I pattern nel gruppo devono avere la
2513	// stessa lunghezza
2514	pPattern = pColumn->get( 0 );
2515	if ( pPattern ) {
2516	nPatternSize = pPattern->get_lenght();
2517	} else {
2518	nPatternSize = MAX_NOTES;
2519	}
2520
2521	totalTick += nPatternSize;
2522	}
2523	return totalTick;
2524	}
2525
2526	/// Set the position in the song
2527	void Hydrogen::setPatternPos( int pos )
2528	{
2529	AudioEngine::get_instance()->lock( "Hydrogen::setPatternPos" );
2530
2531	long totalTick = getTickForPosition( pos );
2532	if ( totalTick < 0 ) {
2533	AudioEngine::get_instance()->unlock();
2534	return;
2535	}
2536
2537	if ( getState() != STATE_PLAYING ) {
2538	// find pattern immediately when not playing
2539	// int dummy;
2540	// m_nSongPos = findPatternInTick( totalTick,
2541	// m_pSong->is_loop_enabled(),
2542	// &dummy );
2543	m_nSongPos = pos;
2544	m_nPatternTickPosition = 0;
2545	}
2546	m_pAudioDriver->locate(
2547	( int ) ( totalTick * m_pAudioDriver->m_transport.m_nTickSize )
2548	);
2549
2550	AudioEngine::get_instance()->unlock();
2551	}
2552
2553
2554
2555
2556	void Hydrogen::getLadspaFXPeak( int nFX, float fL, float fR )
2557	{
2558	#ifdef LADSPA_SUPPORT
2559	( *fL ) = m_fFXPeak_L[nFX];
2560	( *fR ) = m_fFXPeak_R[nFX];
2561	#else
2562	( *fL ) = 0;
2563	( *fR ) = 0;
2564	#endif
2565	}
2566
2567
2568
2569	void Hydrogen::setLadspaFXPeak( int nFX, float fL, float fR )
2570	{
2571	#ifdef LADSPA_SUPPORT
2572	m_fFXPeak_L[nFX] = fL;
2573	m_fFXPeak_R[nFX] = fR;
2574	#endif
2575	}
2576
2577
2578	void Hydrogen::onTapTempoAccelEvent()
2579	{
2580	#ifndef WIN32
2581	INFOLOG( "tap tempo" );
2582	static timeval oldTimeVal;
2583
2584	struct timeval now;
2585	gettimeofday(&now, NULL);
2586
2587	float fInterval =
2588	(now.tv_sec - oldTimeVal.tv_sec) * 1000.0
2589	+ (now.tv_usec - oldTimeVal.tv_usec) / 1000.0;
2590
2591	oldTimeVal = now;
2592
2593	if ( fInterval < 1000.0 ) {
2594	setTapTempo( fInterval );
2595	}
2596	#endif
2597	}
2598
2599	void Hydrogen::setTapTempo( float fInterval )
2600	{
2601
2602	// infoLog( "set tap tempo" );
2603	static float fOldBpm1 = -1;
2604	static float fOldBpm2 = -1;
2605	static float fOldBpm3 = -1;
2606	static float fOldBpm4 = -1;
2607	static float fOldBpm5 = -1;
2608	static float fOldBpm6 = -1;
2609	static float fOldBpm7 = -1;
2610	static float fOldBpm8 = -1;
2611
2612	float fBPM = 60000.0 / fInterval;
2613
2614	if ( fabs( fOldBpm1 - fBPM ) > 20 ) { // troppa differenza, niente media
2615	fOldBpm1 = fBPM;
2616	fOldBpm2 = fBPM;
2617	fOldBpm3 = fBPM;
2618	fOldBpm4 = fBPM;
2619	fOldBpm5 = fBPM;
2620	fOldBpm6 = fBPM;
2621	fOldBpm7 = fBPM;
2622	fOldBpm8 = fBPM;
2623	}
2624
2625	if ( fOldBpm1 == -1 ) {
2626	fOldBpm1 = fBPM;
2627	fOldBpm2 = fBPM;
2628	fOldBpm3 = fBPM;
2629	fOldBpm4 = fBPM;
2630	fOldBpm5 = fBPM;
2631	fOldBpm6 = fBPM;
2632	fOldBpm7 = fBPM;
2633	fOldBpm8 = fBPM;
2634	}
2635
2636	fBPM = ( fBPM + fOldBpm1 + fOldBpm2 + fOldBpm3 + fOldBpm4 + fOldBpm5
2637	+ fOldBpm6 + fOldBpm7 + fOldBpm8 ) / 9.0;
2638
2639
2640	_INFOLOG( QString( "avg BPM = %1" ).arg( fBPM ) );
2641	fOldBpm8 = fOldBpm7;
2642	fOldBpm7 = fOldBpm6;
2643	fOldBpm6 = fOldBpm5;
2644	fOldBpm5 = fOldBpm4;
2645	fOldBpm4 = fOldBpm3;
2646	fOldBpm3 = fOldBpm2;
2647	fOldBpm2 = fOldBpm1;
2648	fOldBpm1 = fBPM;
2649
2650	AudioEngine::get_instance()->lock( "Hydrogen::setTapTempo" );
2651
2652	// m_pAudioDriver->setBpm( fBPM );
2653	// m_pSong->setBpm( fBPM );
2654
2655	setBPM( fBPM );
2656
2657	AudioEngine::get_instance()->unlock();
2658	}
2659
2660
2661	// Called with audioEngine in LOCKED state.
2662	void Hydrogen::setBPM( float fBPM )
2663	{
2664	if ( m_pAudioDriver && m_pSong ) {
2665	m_pAudioDriver->setBpm( fBPM );
2666	m_pSong->__bpm = fBPM;
2667	m_nNewBpmJTM = fBPM;
2668	// audioEngine_process_checkBPMChanged();
2669	}
2670	}
2671
2672
2673
2674	void Hydrogen::restartLadspaFX()
2675	{
2676	if ( m_pAudioDriver ) {
2677	AudioEngine::get_instance()->lock( "Hydrogen::restartLadspaFX" );
2678	audioEngine_setupLadspaFX( m_pAudioDriver->getBufferSize() );
2679	AudioEngine::get_instance()->unlock();
2680	} else {
2681	_ERRORLOG( "m_pAudioDriver = NULL" );
2682	}
2683	}
2684
2685
2686
2687	int Hydrogen::getSelectedPatternNumber()
2688	{
2689	return m_nSelectedPatternNumber;
2690	}
2691
2692
2693
2694	void Hydrogen::setSelectedPatternNumber( int nPat )
2695	{
2696	// FIXME: controllare se e' valido..
2697	if ( nPat == m_nSelectedPatternNumber ) return;
2698
2699
2700	if ( Preferences::getInstance()->patternModePlaysSelected() ) {
2701	AudioEngine::get_instance()
2702	->lock( "Hydrogen::setSelectedPatternNumber" );
2703
2704	m_nSelectedPatternNumber = nPat;
2705	AudioEngine::get_instance()->unlock();
2706	} else {
2707	m_nSelectedPatternNumber = nPat;
2708	}
2709
2710	EventQueue::get_instance()->push_event( EVENT_SELECTED_PATTERN_CHANGED, -1 );
2711	}
2712
2713
2714
2715	int Hydrogen::getSelectedInstrumentNumber()
2716	{
2717	return m_nSelectedInstrumentNumber;
2718	}
2719
2720
2721
2722	void Hydrogen::setSelectedInstrumentNumber( int nInstrument )
2723	{
2724	if ( m_nSelectedInstrumentNumber == nInstrument ) return;
2725
2726	m_nSelectedInstrumentNumber = nInstrument;
2727	EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
2728	}
2729
2730
2731	#ifdef JACK_SUPPORT
2732	void Hydrogen::renameJackPorts()
2733	{
2734	if( Preferences::getInstance()->m_bJackTrackOuts == true ){
2735	audioEngine_renameJackPorts();
2736	}
2737	}
2738	#endif
2739
2740
2741	///BeatCounter
2742
2743	void Hydrogen::setbeatsToCount( int beatstocount)
2744	{
2745	m_nbeatsToCount = beatstocount;
2746	}
2747
2748
2749	int Hydrogen::getbeatsToCount()
2750	{
2751	return m_nbeatsToCount;
2752	}
2753
2754
2755	void Hydrogen::setNoteLengh( float notelengh)
2756	{
2757	m_ntaktoMeterCompute = notelengh;
2758	}
2759
2760
2761
2762	float Hydrogen::getNoteLengh()
2763	{
2764	return m_ntaktoMeterCompute;
2765	}
2766
2767
2768
2769	int Hydrogen::getBcStatus()
2770	{
2771	return eventCount;
2772	}
2773
2774
2775	void Hydrogen::setBcOffsetAdjust()
2776	{
2777	//individual fine tuning for the beatcounter
2778	//to adjust ms_offset from different people and controller
2779	Preferences *pref = Preferences::getInstance();
2780
2781	m_nCoutOffset = pref->m_countOffset;
2782	m_nStartOffset = pref->m_startOffset;
2783	}
2784
2785
2786	void Hydrogen::handleBeatCounter()
2787	{
2788	// Get first time value:
2789	if (beatCount == 1)
2790	gettimeofday(&currentTime,NULL);
2791
2792	eventCount++;
2793
2794	// Set wlastTime to wcurrentTime to remind the time:
2795	lastTime = currentTime;
2796
2797	// Get new time:
2798	gettimeofday(&currentTime,NULL);
2799
2800
2801	// Build doubled time difference:
2802	lastBeatTime = (double)(
2803	lastTime.tv_sec
2804	+ (double)(lastTime.tv_usec * US_DIVIDER)
2805	+ (int)m_nCoutOffset * .0001
2806	);
2807	currentBeatTime = (double)(
2808	currentTime.tv_sec
2809	+ (double)(currentTime.tv_usec * US_DIVIDER)
2810	);
2811	beatDiff = beatCount == 1 ? 0 : currentBeatTime - lastBeatTime;
2812
2813	//if differences are to big reset the beatconter
2814	if( beatDiff > 3.001){
2815	eventCount = 1;
2816	beatCount = 1;
2817	return;
2818	}
2819	// Only accept differences big enough
2820	if (beatCount == 1 \|\| beatDiff > .001) {
2821	if (beatCount > 1)
2822	beatDiffs[beatCount - 2] = beatDiff ;
2823	// Compute and reset:
2824	if (beatCount == m_nbeatsToCount){
2825	// unsigned long currentframe = getRealtimeFrames();
2826	double beatTotalDiffs = 0;
2827	for(int i = 0; i < (m_nbeatsToCount - 1); i++)
2828	beatTotalDiffs += beatDiffs[i];
2829	double beatDiffAverage =
2830	beatTotalDiffs
2831	/ (beatCount - 1)
2832	* m_ntaktoMeterCompute ;
2833	beatCountBpm =
2834	(float) ((int) (60 / beatDiffAverage * 100))
2835	/ 100;
2836	AudioEngine::get_instance()
2837	->lock( "Hydrogen::handleBeatCounter");
2838	if ( beatCountBpm > 500)
2839	beatCountBpm = 500;
2840	setBPM( beatCountBpm );
2841	AudioEngine::get_instance()->unlock();
2842	if (Preferences::getInstance()->m_mmcsetplay
2843	== Preferences::SET_PLAY_OFF) {
2844	beatCount = 1;
2845	eventCount = 1;
2846	}else{
2847	if ( m_audioEngineState != STATE_PLAYING ){
2848	unsigned bcsamplerate =
2849	m_pAudioDriver->getSampleRate();
2850	unsigned long rtstartframe = 0;
2851	if ( m_ntaktoMeterCompute <= 1){
2852	rtstartframe =
2853	bcsamplerate
2854	* beatDiffAverage
2855	* ( 1/ m_ntaktoMeterCompute );
2856	}else
2857	{
2858	rtstartframe =
2859	bcsamplerate
2860	* beatDiffAverage
2861	/ m_ntaktoMeterCompute ;
2862	}
2863
2864	int sleeptime =
2865	( (float) rtstartframe
2866	/ (float) bcsamplerate
2867	* (int) 1000 )
2868	+ (int)m_nCoutOffset
2869	+ (int) m_nStartOffset;
2870	#ifdef WIN32
2871	Sleep( sleeptime );
2872	#else
2873	usleep( 1000 * sleeptime );
2874	#endif
2875
2876	sequencer_play();
2877	}
2878
2879	beatCount = 1;
2880	eventCount = 1;
2881	return;
2882	}
2883	}
2884	else {
2885	beatCount ++;
2886	}
2887	}
2888	return;
2889	}
2890	//~ beatcounter
2891
2892	// jack transport master
2893	unsigned long Hydrogen::getHumantimeFrames()
2894	{
2895	return m_nHumantimeFrames;
2896	}
2897
2898	void Hydrogen::setHumantimeFrames(unsigned long hframes)
2899	{
2900	m_nHumantimeFrames = hframes;
2901	}
2902
2903
2904
2905	#ifdef JACK_SUPPORT
2906	void Hydrogen::offJackMaster()
2907	{
2908	static_cast< JackOutput* >( m_pAudioDriver )->com_release();
2909	}
2910
2911	void Hydrogen::onJackMaster()
2912	{
2913	static_cast< JackOutput* >( m_pAudioDriver )->initTimeMaster();
2914	}
2915
2916	unsigned long Hydrogen::getTimeMasterFrames()
2917	{
2918	float allframes = 0 ;
2919
2920	if ( m_pAudioDriver->m_transport.m_status == TransportInfo::STOPPED ){
2921
2922	int oldtick = getTickPosition();
2923	for (int i = 0; i <= getPatternPos(); i++){
2924	float framesforposition =
2925	(long)getTickForHumanPosition(i)
2926	* (float)m_pAudioDriver->m_transport.m_nTickSize;
2927	allframes = framesforposition + allframes;
2928	}
2929	unsigned long framesfortimemaster = (unsigned int)(
2930	allframes
2931	+ oldtick * (float)m_pAudioDriver->m_transport.m_nTickSize
2932	);
2933	m_nHumantimeFrames = framesfortimemaster;
2934	return framesfortimemaster;
2935	}else
2936	{
2937	return m_nHumantimeFrames;
2938	}
2939	}
2940	#endif
2941
2942	long Hydrogen::getTickForHumanPosition( int humanpos )
2943	{
2944	std::vector< PatternList* > * columns = m_pSong->get_pattern_group_vector();
2945
2946	int nPatternGroups = columns->size();
2947	if ( humanpos >= nPatternGroups ) {
2948	if ( m_pSong->is_loop_enabled() ) {
2949	humanpos = humanpos % nPatternGroups;
2950	} else {
2951	return -1;
2952	}
2953	}
2954
2955	// std::vector<PatternList> pColumns =
2956	// m_pSong->get_pattern_group_vector()[ humanpos - 1 ]
2957	// .get( 0 )->get_lenght();
2958
2959	// ERRORLOG( "Kick me!" );
2960	if ( humanpos == 0 ) return 0;
2961	Pattern *pPattern = columns->at( humanpos - 1 )->get( 0 );
2962	if ( pPattern ) {
2963	return pPattern->get_lenght();
2964	} else {
2965	return MAX_NOTES;
2966	}
2967	// int nPatternSize;
2968
2969	// pColumns
2970
2971	/* Pattern *pPattern = NULL;
2972	for ( int i = 0; i < humanpos; ++i ) {
2973	PatternList pColumn = ( pColumns )[ i ];
2974	pPattern = pColumn->get( 0 );
2975	if ( pPattern ) {
2976	nPatternSize = pPattern->get_lenght();
2977	} else {
2978	nPatternSize = MAX_NOTES;
2979	}
2980
2981	humanTick = nPatternSize;
2982	}*/
2983	// return humanTick;
2984	}
2985
2986
2987
2988	float Hydrogen::getNewBpmJTM()
2989	{
2990	return m_nNewBpmJTM;
2991	}
2992
2993	void Hydrogen::setNewBpmJTM( float bpmJTM )
2994	{
2995	m_nNewBpmJTM = bpmJTM;
2996	}
2997
2998
2999	void Hydrogen::ComputeHumantimeFrames(uint32_t nFrames)
3000	{
3001	if ( ( m_audioEngineState == STATE_PLAYING ) )
3002	m_nHumantimeFrames = nFrames + m_nHumantimeFrames;
3003	}
3004
3005
3006	//~ jack transport master
3007
3008	void Hydrogen::triggerRelocateDuringPlay()
3009	{
3010	if ( m_pSong->get_mode() == Song::PATTERN_MODE )
3011	m_nPatternStartTick = -1; // This forces the barline position
3012	}
3013
3014
3015	void Hydrogen::togglePlaysSelected()
3016	{
3017	if ( getSong()->get_mode() != Song::PATTERN_MODE )
3018	return;
3019	Preferences * P = Preferences::getInstance();
3020
3021	AudioEngine::get_instance()->lock( "Live mode" );
3022
3023	bool isPlaysSelected = P->patternModePlaysSelected();
3024
3025	if (isPlaysSelected)
3026	{
3027	m_pPlayingPatterns->clear();
3028	Pattern * pSelectedPattern =
3029	m_pSong
3030	->get_pattern_list()
3031	->get(m_nSelectedPatternNumber);
3032	m_pPlayingPatterns->add( pSelectedPattern );
3033	}
3034
3035	P->setPatternModePlaysSelected( !isPlaysSelected );
3036
3037	AudioEngine::get_instance()->unlock();
3038
3039	}
3040
3041	void Hydrogen::__kill_instruments()
3042	{
3043	int c = 0;
3044	Instrument * pInstr = NULL;
3045	while ( __instrument_death_row.size()
3046	&& __instrument_death_row.front()->is_queued() == 0 ) {
3047	pInstr = __instrument_death_row.front();
3048	__instrument_death_row.pop_front();
3049	INFOLOG( QString( "Deleting unused instrument (%1). "
3050	"%2 unused remain." )
3051	. arg( pInstr->get_name() )
3052	. arg( __instrument_death_row.size() ) );
3053	delete pInstr;
3054	c++;
3055	}
3056	if ( __instrument_death_row.size() ) {
3057	pInstr = __instrument_death_row.front();
3058	INFOLOG( QString( "Instrument %1 still has %2 active notes. "
3059	"Delaying 'delete instrument' operation." )
3060	. arg( pInstr->get_name() )
3061	. arg( pInstr->is_queued() ) );
3062	}
3063	}
3064
3065
3066
3067	void Hydrogen::__panic()
3068	{
3069	sequencer_stop();
3070	AudioEngine::get_instance()->get_sampler()->stop_playing_notes();
3071	}
3072
3073	int Hydrogen::__get_selected_PatterNumber()
3074	{
3075	return m_nSelectedPatternNumber;
3076	}
3077
3078	unsigned int Hydrogen::__getMidiRealtimeNoteTickPosition()
3079	{
3080	return m_naddrealtimenotetickposition;
3081	}
3082
3083
3084	void Hydrogen::sortVolVectors()
3085	{
3086	//sort the volume vector to xframes a < b
3087	sort(m_volumen.begin(), m_volumen.end(), VolComparator());
3088	}
3089
3090
3091	void Hydrogen::sortPanVectors()
3092	{
3093	//sort the pan vector to xframes a < b
3094	sort(m_pan.begin(), m_pan.end(), PanComparator());
3095	}
3096	};
3097

Note: See TracBrowser for help on using the browser.

hydrogen

Context Navigation

root/branches/new_fx_rack_and_sample_fun/libs/hydrogen/src/hydrogen.cpp @ 762

Download in other formats: