2008-06-02 17:41:35 -04:00
/*
2009-10-14 12:10:01 -04:00
Copyright ( C ) 2002 Paul Davis
2008-06-02 17:41:35 -04:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include <unistd.h>
# include <cerrno>
# include <vector>
# include <exception>
# include <stdexcept>
# include <sstream>
# include <glibmm/timer.h>
2010-06-24 10:13:45 -04:00
2009-02-25 13:26:51 -05:00
# include "pbd/pthread_utils.h"
# include "pbd/stacktrace.h"
# include "pbd/unknown_type.h"
2010-12-22 23:17:45 -05:00
# include "pbd/epa.h"
2008-06-02 17:41:35 -04:00
2011-09-28 09:37:57 -04:00
# include <jack/weakjack.h>
2010-07-05 20:16:36 -04:00
# include "midi++/port.h"
2012-04-23 22:28:51 -04:00
# include "midi++/jack_midi_port.h"
2010-06-29 09:47:53 -04:00
# include "midi++/mmc.h"
2010-07-05 11:41:05 -04:00
# include "midi++/manager.h"
2008-06-02 17:41:35 -04:00
2009-06-16 10:58:33 -04:00
# include "ardour/audio_port.h"
2009-02-25 13:26:51 -05:00
# include "ardour/audioengine.h"
# include "ardour/buffer.h"
# include "ardour/cycle_timer.h"
2012-01-14 18:31:55 -05:00
# include "ardour/internal_send.h"
2009-06-16 10:58:33 -04:00
# include "ardour/meter.h"
# include "ardour/midi_port.h"
# include "ardour/port.h"
2012-05-24 02:09:29 -04:00
# include "ardour/process_thread.h"
2009-06-16 10:58:33 -04:00
# include "ardour/session.h"
2008-06-02 17:41:35 -04:00
# include "i18n.h"
using namespace std ;
using namespace ARDOUR ;
using namespace PBD ;
gint AudioEngine : : m_meter_exit ;
2009-10-14 13:35:33 -04:00
AudioEngine * AudioEngine : : _instance = 0 ;
# define GET_PRIVATE_JACK_POINTER(j) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return; }
# define GET_PRIVATE_JACK_POINTER_RET(j,r) jack_client_t* _priv_jack = (jack_client_t*) (j); if (!_priv_jack) { return r; }
2008-06-02 17:41:35 -04:00
2010-04-02 14:54:33 -04:00
AudioEngine : : AudioEngine ( string client_name , string session_uuid )
2008-06-02 17:41:35 -04:00
: ports ( new Ports )
{
2009-10-14 13:35:33 -04:00
_instance = this ; /* singleton */
2008-06-02 17:41:35 -04:00
session_remove_pending = false ;
_running = false ;
_has_run = false ;
last_monitor_check = 0 ;
2010-09-17 12:24:22 -04:00
monitor_check_interval = INT32_MAX ;
2008-06-02 17:41:35 -04:00
_processed_frames = 0 ;
_usecs_per_cycle = 0 ;
_jack = 0 ;
_frame_rate = 0 ;
_buffer_size = 0 ;
2008-09-10 11:03:30 -04:00
_freewheeling = false ;
2012-02-06 12:09:53 -05:00
_pre_freewheel_mmc_enabled = false ;
2010-04-13 16:48:33 -04:00
_main_thread = 0 ;
2011-04-19 12:54:18 -04:00
port_remove_in_progress = false ;
2008-06-02 17:41:35 -04:00
m_meter_thread = 0 ;
g_atomic_int_set ( & m_meter_exit , 0 ) ;
2010-04-02 14:54:33 -04:00
if ( connect_to_jack ( client_name , session_uuid ) ) {
2008-06-02 17:41:35 -04:00
throw NoBackendAvailable ( ) ;
}
2008-09-10 11:03:30 -04:00
2008-06-02 17:41:35 -04:00
Port : : set_engine ( this ) ;
}
AudioEngine : : ~ AudioEngine ( )
{
{
Glib : : Mutex : : Lock tm ( _process_lock ) ;
session_removed . signal ( ) ;
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
if ( _running ) {
jack_client_close ( _jack ) ;
2008-09-10 17:27:39 -04:00
_jack = 0 ;
2008-06-02 17:41:35 -04:00
}
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
stop_metering_thread ( ) ;
}
}
jack_client_t *
AudioEngine : : jack ( ) const
{
return _jack ;
}
void
2009-07-21 11:55:17 -04:00
_thread_init_callback ( void * /*arg*/ )
2008-06-02 17:41:35 -04:00
{
/* make sure that anybody who needs to know about this thread
knows about it .
*/
2009-12-31 14:49:22 -05:00
pthread_set_name ( X_ ( " audioengine " ) ) ;
2009-12-26 11:15:11 -05:00
2009-12-08 22:05:14 -05:00
PBD : : notify_gui_about_thread_creation ( " gui " , pthread_self ( ) , X_ ( " Audioengine " ) , 4096 ) ;
PBD : : notify_gui_about_thread_creation ( " midiui " , pthread_self ( ) , X_ ( " Audioengine " ) , 128 ) ;
2009-12-04 14:24:09 -05:00
SessionEvent : : create_per_thread_pool ( X_ ( " Audioengine " ) , 512 ) ;
2012-04-23 22:28:51 -04:00
MIDI : : JackMIDIPort : : set_process_thread ( pthread_self ( ) ) ;
2009-12-02 16:26:26 -05:00
}
2011-10-28 13:04:15 -04:00
static void
ardour_jack_error ( const char * msg )
{
error < < " JACK: " < < msg < < endmsg ;
}
2011-03-01 20:39:52 -05:00
void
AudioEngine : : set_jack_callbacks ( )
{
GET_PRIVATE_JACK_POINTER ( _jack ) ;
if ( jack_on_info_shutdown ) {
jack_on_info_shutdown ( _priv_jack , halted_info , this ) ;
} else {
jack_on_shutdown ( _priv_jack , halted , this ) ;
}
2011-06-01 12:50:12 -04:00
2011-03-01 20:39:52 -05:00
jack_set_thread_init_callback ( _priv_jack , _thread_init_callback , this ) ;
jack_set_process_thread ( _priv_jack , _process_thread , this ) ;
jack_set_sample_rate_callback ( _priv_jack , _sample_rate_callback , this ) ;
jack_set_buffer_size_callback ( _priv_jack , _bufsize_callback , this ) ;
2011-04-19 12:54:18 -04:00
jack_set_graph_order_callback ( _priv_jack , _graph_order_callback , this ) ;
jack_set_port_registration_callback ( _priv_jack , _registration_callback , this ) ;
jack_set_port_connect_callback ( _priv_jack , _connect_callback , this ) ;
2011-03-01 20:39:52 -05:00
jack_set_xrun_callback ( _priv_jack , _xrun_callback , this ) ;
jack_set_sync_callback ( _priv_jack , _jack_sync_callback , this ) ;
jack_set_freewheel_callback ( _priv_jack , _freewheel_callback , this ) ;
2011-04-19 12:54:18 -04:00
2011-03-01 20:39:52 -05:00
if ( _session & & _session - > config . get_jack_time_master ( ) ) {
jack_set_timebase_callback ( _priv_jack , 0 , _jack_timebase_callback , this ) ;
}
2011-06-01 12:50:12 -04:00
# ifdef HAVE_JACK_SESSION
2011-03-01 20:39:52 -05:00
if ( jack_set_session_callback )
jack_set_session_callback ( _priv_jack , _session_callback , this ) ;
# endif
2011-03-10 21:55:52 -05:00
2011-03-01 20:39:52 -05:00
if ( jack_set_latency_callback ) {
jack_set_latency_callback ( _priv_jack , _latency_callback , this ) ;
}
2011-04-19 12:54:18 -04:00
2011-10-28 13:04:15 -04:00
jack_set_error_function ( ardour_jack_error ) ;
2011-03-01 20:39:52 -05:00
}
2008-06-02 17:41:35 -04:00
int
AudioEngine : : start ( )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2008-09-10 17:27:39 -04:00
2008-06-02 17:41:35 -04:00
if ( ! _running ) {
2011-06-19 17:47:21 -04:00
if ( ! jack_port_type_get_buffer_size ) {
2011-03-01 20:39:52 -05:00
warning < < _ ( " This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size() " ) < < endmsg ;
2011-06-19 17:47:21 -04:00
}
2009-10-14 12:10:01 -04:00
2009-12-17 13:24:23 -05:00
if ( _session ) {
2008-06-02 17:41:35 -04:00
BootMessage ( _ ( " Connect session to engine " ) ) ;
2009-12-17 13:24:23 -05:00
_session - > set_frame_rate ( jack_get_sample_rate ( _priv_jack ) ) ;
2008-06-02 17:41:35 -04:00
}
2011-03-01 20:39:52 -05:00
/* a proxy for whether jack_activate() will definitely call the buffer size
* callback . with older versions of JACK , this function symbol will be null .
* this is reliable , but not clean .
*/
2008-06-02 17:41:35 -04:00
2011-06-01 12:50:12 -04:00
if ( ! jack_port_type_get_buffer_size ) {
2011-06-19 17:47:21 -04:00
jack_bufsize_callback ( jack_get_buffer_size ( _priv_jack ) ) ;
2011-03-01 20:39:52 -05:00
}
2011-06-19 17:47:21 -04:00
_processed_frames = 0 ;
last_monitor_check = 0 ;
set_jack_callbacks ( ) ;
2009-12-02 16:26:26 -05:00
2009-10-14 13:35:33 -04:00
if ( jack_activate ( _priv_jack ) = = 0 ) {
2008-06-02 17:41:35 -04:00
_running = true ;
_has_run = true ;
Running ( ) ; /* EMIT SIGNAL */
} else {
// error << _("cannot activate JACK client") << endmsg;
}
}
2011-06-19 17:47:21 -04:00
2008-06-02 17:41:35 -04:00
return _running ? 0 : - 1 ;
}
int
AudioEngine : : stop ( bool forever )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2009-10-14 13:35:33 -04:00
if ( _priv_jack ) {
2008-06-02 17:41:35 -04:00
if ( forever ) {
2008-09-10 17:27:39 -04:00
disconnect_from_jack ( ) ;
2008-06-02 17:41:35 -04:00
} else {
2009-10-14 13:35:33 -04:00
jack_deactivate ( _priv_jack ) ;
2008-09-10 17:27:39 -04:00
Stopped ( ) ; /* EMIT SIGNAL */
2012-04-23 22:28:51 -04:00
MIDI : : JackMIDIPort : : JackHalted ( ) ; /* EMIT SIGNAL */
2008-06-02 17:41:35 -04:00
}
}
2010-08-16 15:58:34 -04:00
if ( forever ) {
stop_metering_thread ( ) ;
}
2008-06-02 17:41:35 -04:00
return _running ? - 1 : 0 ;
}
bool
2010-12-03 17:26:29 -05:00
AudioEngine : : get_sync_offset ( pframes_t & offset ) const
2008-06-02 17:41:35 -04:00
{
# ifdef HAVE_JACK_VIDEO_SUPPORT
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , false ) ;
2009-10-14 13:35:33 -04:00
2008-06-02 17:41:35 -04:00
jack_position_t pos ;
2009-10-14 12:10:01 -04:00
2009-10-14 13:35:33 -04:00
if ( _priv_jack ) {
( void ) jack_transport_query ( _priv_jack , & pos ) ;
2009-10-14 12:10:01 -04:00
2008-09-10 17:27:39 -04:00
if ( pos . valid & JackVideoFrameOffset ) {
offset = pos . video_offset ;
return true ;
}
2008-06-02 17:41:35 -04:00
}
2009-08-09 08:06:03 -04:00
# else
/* keep gcc happy */
offset = 0 ;
2008-06-02 17:41:35 -04:00
# endif
return false ;
}
void
2010-12-03 17:26:29 -05:00
AudioEngine : : _jack_timebase_callback ( jack_transport_state_t state , pframes_t nframes ,
2008-06-02 17:41:35 -04:00
jack_position_t * pos , int new_position , void * arg )
{
static_cast < AudioEngine * > ( arg ) - > jack_timebase_callback ( state , nframes , pos , new_position ) ;
}
void
2010-12-03 17:26:29 -05:00
AudioEngine : : jack_timebase_callback ( jack_transport_state_t state , pframes_t nframes ,
2008-06-02 17:41:35 -04:00
jack_position_t * pos , int new_position )
{
2009-12-17 13:24:23 -05:00
if ( _jack & & _session & & _session - > synced_to_jack ( ) ) {
_session - > jack_timebase_callback ( state , nframes , pos , new_position ) ;
2008-06-02 17:41:35 -04:00
}
}
int
AudioEngine : : _jack_sync_callback ( jack_transport_state_t state , jack_position_t * pos , void * arg )
{
return static_cast < AudioEngine * > ( arg ) - > jack_sync_callback ( state , pos ) ;
}
int
AudioEngine : : jack_sync_callback ( jack_transport_state_t state , jack_position_t * pos )
{
2009-12-17 13:24:23 -05:00
if ( _jack & & _session ) {
return _session - > jack_sync_callback ( state , pos ) ;
2008-06-02 17:41:35 -04:00
}
return true ;
}
int
AudioEngine : : _xrun_callback ( void * arg )
{
AudioEngine * ae = static_cast < AudioEngine * > ( arg ) ;
2008-09-10 17:27:39 -04:00
if ( ae - > connected ( ) ) {
2008-06-02 17:41:35 -04:00
ae - > Xrun ( ) ; /* EMIT SIGNAL */
}
return 0 ;
}
2010-04-02 14:54:33 -04:00
# ifdef HAVE_JACK_SESSION
void
AudioEngine : : _session_callback ( jack_session_event_t * event , void * arg )
{
AudioEngine * ae = static_cast < AudioEngine * > ( arg ) ;
if ( ae - > connected ( ) ) {
ae - > JackSessionEvent ( event ) ; /* EMIT SIGNAL */
}
}
# endif
2012-02-02 13:51:32 -05:00
2008-06-02 17:41:35 -04:00
int
AudioEngine : : _graph_order_callback ( void * arg )
{
AudioEngine * ae = static_cast < AudioEngine * > ( arg ) ;
2011-04-19 13:59:52 -04:00
2011-04-19 12:54:18 -04:00
if ( ae - > connected ( ) & & ! ae - > port_remove_in_progress ) {
2008-06-02 17:41:35 -04:00
ae - > GraphReordered ( ) ; /* EMIT SIGNAL */
}
2011-10-19 14:44:21 -04:00
2008-06-02 17:41:35 -04:00
return 0 ;
}
2010-04-13 16:48:33 -04:00
void *
AudioEngine : : _process_thread ( void * arg )
{
return static_cast < AudioEngine * > ( arg ) - > process_thread ( ) ;
}
2008-06-02 17:41:35 -04:00
void
AudioEngine : : _freewheel_callback ( int onoff , void * arg )
{
2012-02-06 12:09:53 -05:00
static_cast < AudioEngine * > ( arg ) - > freewheel_callback ( onoff ) ;
}
void
AudioEngine : : freewheel_callback ( int onoff )
{
_freewheeling = onoff ;
if ( onoff ) {
_pre_freewheel_mmc_enabled = MIDI : : Manager : : instance ( ) - > mmc ( ) - > send_enabled ( ) ;
MIDI : : Manager : : instance ( ) - > mmc ( ) - > enable_send ( false ) ;
} else {
MIDI : : Manager : : instance ( ) - > mmc ( ) - > enable_send ( _pre_freewheel_mmc_enabled ) ;
}
2008-06-02 17:41:35 -04:00
}
2009-10-11 18:16:20 -04:00
void
AudioEngine : : _registration_callback ( jack_port_id_t /*id*/ , int /*reg*/ , void * arg )
{
AudioEngine * ae = static_cast < AudioEngine * > ( arg ) ;
2011-04-19 12:54:18 -04:00
if ( ! ae - > port_remove_in_progress ) {
ae - > PortRegisteredOrUnregistered ( ) ; /* EMIT SIGNAL */
}
2009-10-11 18:16:20 -04:00
}
2011-02-15 14:55:14 -05:00
void
AudioEngine : : _latency_callback ( jack_latency_callback_mode_t mode , void * arg )
{
return static_cast < AudioEngine * > ( arg ) - > jack_latency_callback ( mode ) ;
}
2010-04-05 11:23:54 -04:00
void
2010-12-29 12:52:32 -05:00
AudioEngine : : _connect_callback ( jack_port_id_t id_a , jack_port_id_t id_b , int conn , void * arg )
2010-04-05 11:23:54 -04:00
{
AudioEngine * ae = static_cast < AudioEngine * > ( arg ) ;
2010-12-29 12:52:32 -05:00
2011-04-19 12:54:18 -04:00
if ( ae - > port_remove_in_progress ) {
return ;
}
2010-12-29 12:52:32 -05:00
GET_PRIVATE_JACK_POINTER ( ae - > _jack ) ;
jack_port_t * jack_port_a = jack_port_by_id ( _priv_jack , id_a ) ;
jack_port_t * jack_port_b = jack_port_by_id ( _priv_jack , id_b ) ;
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port > port_a ;
boost : : shared_ptr < Port > port_b ;
2010-12-29 12:52:32 -05:00
boost : : shared_ptr < Ports > pr = ae - > ports . reader ( ) ;
Ports : : iterator i = pr - > begin ( ) ;
while ( i ! = pr - > end ( ) & & ( port_a = = 0 | | port_b = = 0 ) ) {
2012-01-27 08:23:39 -05:00
if ( jack_port_a = = i - > second - > jack_port ( ) ) {
port_a = i - > second ;
} else if ( jack_port_b = = i - > second - > jack_port ( ) ) {
port_b = i - > second ;
2010-12-29 12:52:32 -05:00
}
+ + i ;
}
2011-06-01 12:50:12 -04:00
2011-09-26 18:22:21 -04:00
ae - > PortConnectedOrDisconnected (
port_a , jack_port_name ( jack_port_a ) ,
port_b , jack_port_name ( jack_port_b ) ,
conn = = 0 ? false : true
) ; /* EMIT SIGNAL */
2010-04-05 11:23:54 -04:00
}
2009-04-23 13:48:37 -04:00
void
2010-12-03 17:26:29 -05:00
AudioEngine : : split_cycle ( pframes_t offset )
2009-04-23 13:48:37 -04:00
{
/* caller must hold process lock */
2011-03-10 21:55:52 -05:00
Port : : increment_global_port_buffer_offset ( offset ) ;
2009-04-23 13:48:37 -04:00
/* tell all Ports that we're going to start a new (split) cycle */
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
i - > second - > cycle_split ( ) ;
2009-04-23 13:48:37 -04:00
}
}
2010-04-13 16:48:33 -04:00
void *
AudioEngine : : process_thread ( )
{
2011-06-01 12:50:12 -04:00
/* JACK doesn't do this for us when we use the wait API
2010-04-13 16:48:33 -04:00
*/
_thread_init_callback ( 0 ) ;
_main_thread = new ProcessThread ;
while ( 1 ) {
GET_PRIVATE_JACK_POINTER_RET ( _jack , 0 ) ;
2011-04-19 12:54:18 -04:00
pframes_t nframes = jack_cycle_wait ( _priv_jack ) ;
2010-04-13 16:48:33 -04:00
if ( process_callback ( nframes ) ) {
return 0 ;
}
2011-04-19 12:54:18 -04:00
jack_cycle_signal ( _priv_jack , 0 ) ;
2010-04-13 16:48:33 -04:00
}
return 0 ;
}
2012-01-10 18:39:39 -05:00
/** Method called by our ::process_thread when there is work to be done.
* @ param nframes Number of frames to process .
2008-06-02 17:41:35 -04:00
*/
int
2010-12-03 17:26:29 -05:00
AudioEngine : : process_callback ( pframes_t nframes )
2008-06-02 17:41:35 -04:00
{
2010-04-13 16:48:33 -04:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , 0 ) ;
2008-06-02 17:41:35 -04:00
Glib : : Mutex : : Lock tm ( _process_lock , Glib : : TRY_LOCK ) ;
2012-01-14 17:02:59 -05:00
PT_TIMING_REF ;
PT_TIMING_CHECK ( 1 ) ;
2008-06-02 17:41:35 -04:00
/// The number of frames that will have been processed when we've finished
2010-12-03 17:26:29 -05:00
pframes_t next_processed_frames ;
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
/* handle wrap around of total frames counter */
2010-09-17 12:24:22 -04:00
if ( max_framepos - _processed_frames < nframes ) {
next_processed_frames = nframes - ( max_framepos - _processed_frames ) ;
2008-06-02 17:41:35 -04:00
} else {
next_processed_frames = _processed_frames + nframes ;
}
2012-04-23 12:24:41 -04:00
if ( ! tm . locked ( ) ) {
2008-06-02 17:41:35 -04:00
/* return having done nothing */
_processed_frames = next_processed_frames ;
return 0 ;
}
2012-06-20 18:24:14 -04:00
if ( session_remove_pending ) {
/* perform the actual session removal */
_session = 0 ;
session_remove_pending = false ;
2012-06-21 11:00:10 -04:00
/* pump one cycle of silence into the ports
before the session tears them all down
( asynchronously ) .
*/
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
if ( i - > second - > sends_output ( ) ) {
i - > second - > get_buffer ( nframes ) . silence ( nframes ) ;
}
}
2012-06-20 18:24:14 -04:00
session_removed . signal ( ) ;
}
2012-04-23 12:24:41 -04:00
if ( _session = = 0 ) {
if ( ! _freewheeling ) {
MIDI : : Manager : : instance ( ) - > cycle_start ( nframes ) ;
MIDI : : Manager : : instance ( ) - > cycle_end ( ) ;
}
2008-06-02 17:41:35 -04:00
_processed_frames = next_processed_frames ;
2012-06-20 18:24:14 -04:00
2008-06-02 17:41:35 -04:00
return 0 ;
}
2009-06-09 16:21:19 -04:00
/* tell all relevant objects that we're starting a new cycle */
2009-04-23 13:48:37 -04:00
2012-01-14 18:31:55 -05:00
InternalSend : : CycleStart ( nframes ) ;
2011-03-10 21:55:52 -05:00
Port : : set_global_port_buffer_offset ( 0 ) ;
Port : : set_cycle_framecnt ( nframes ) ;
2009-04-23 13:48:37 -04:00
/* tell all Ports that we're starting a new cycle */
2008-06-03 08:14:59 -04:00
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
2008-09-29 05:44:25 -04:00
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
i - > second - > cycle_start ( nframes ) ;
2008-09-29 05:44:25 -04:00
}
2010-07-14 17:06:12 -04:00
/* test if we are freewheeling and there are freewheel signals connected.
ardour should act normally even when freewheeling unless / it / is exporting */
if ( _freewheeling & & ! Freewheel . empty ( ) ) {
2011-06-01 12:50:12 -04:00
/* emit the Freewheel signal and stop freewheeling in the event of trouble
2009-12-17 13:24:23 -05:00
*/
2010-06-21 11:26:03 -04:00
boost : : optional < int > r = Freewheel ( nframes ) ;
if ( r . get_value_or ( 0 ) ) {
2009-10-14 13:35:33 -04:00
jack_set_freewheel ( _priv_jack , false ) ;
2008-06-02 17:41:35 -04:00
}
2008-06-03 08:14:59 -04:00
} else {
2012-04-23 12:24:41 -04:00
MIDI : : Manager : : instance ( ) - > cycle_start ( nframes ) ;
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > process ( nframes ) ;
2008-06-03 08:14:59 -04:00
}
2012-04-23 12:24:41 -04:00
MIDI : : Manager : : instance ( ) - > cycle_end ( ) ;
2008-06-02 17:41:35 -04:00
}
2009-10-14 12:10:01 -04:00
2008-06-03 08:14:59 -04:00
if ( _freewheeling ) {
return 0 ;
}
2008-06-02 17:41:35 -04:00
if ( ! _running ) {
_processed_frames = next_processed_frames ;
return 0 ;
}
if ( last_monitor_check + monitor_check_interval < next_processed_frames ) {
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
bool x ;
2009-10-14 12:10:01 -04:00
2012-01-27 08:23:39 -05:00
if ( i - > second - > last_monitor ( ) ! = ( x = i - > second - > jack_monitoring_input ( ) ) ) {
i - > second - > set_last_monitor ( x ) ;
2009-10-14 12:10:01 -04:00
/* XXX I think this is dangerous, due to
2008-06-02 17:41:35 -04:00
a likely mutex in the signal handlers . . .
*/
2012-01-27 08:23:39 -05:00
i - > second - > MonitorInputChanged ( x ) ; /* EMIT SIGNAL */
2008-06-02 17:41:35 -04:00
}
}
last_monitor_check = next_processed_frames ;
}
2009-12-17 13:24:23 -05:00
if ( _session - > silent ( ) ) {
2008-06-02 17:41:35 -04:00
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2009-10-14 12:10:01 -04:00
2012-01-27 08:23:39 -05:00
if ( i - > second - > sends_output ( ) ) {
i - > second - > get_buffer ( nframes ) . silence ( nframes ) ;
2008-06-02 17:41:35 -04:00
}
}
2009-10-14 12:10:01 -04:00
}
2008-06-02 17:41:35 -04:00
2009-04-23 13:48:37 -04:00
// Finalize ports
2008-10-08 16:14:22 -04:00
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
i - > second - > cycle_end ( nframes ) ;
2008-10-08 16:14:22 -04:00
}
2009-04-23 13:48:37 -04:00
2008-06-02 17:41:35 -04:00
_processed_frames = next_processed_frames ;
2012-01-14 17:02:59 -05:00
PT_TIMING_CHECK ( 2 ) ;
2008-06-02 17:41:35 -04:00
return 0 ;
}
int
2010-12-03 17:26:29 -05:00
AudioEngine : : _sample_rate_callback ( pframes_t nframes , void * arg )
2008-06-02 17:41:35 -04:00
{
return static_cast < AudioEngine * > ( arg ) - > jack_sample_rate_callback ( nframes ) ;
}
int
2010-12-03 17:26:29 -05:00
AudioEngine : : jack_sample_rate_callback ( pframes_t nframes )
2008-06-02 17:41:35 -04:00
{
_frame_rate = nframes ;
_usecs_per_cycle = ( int ) floor ( ( ( ( double ) frames_per_cycle ( ) / nframes ) ) * 1000000.0 ) ;
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
/* check for monitor input change every 1/10th of second */
monitor_check_interval = nframes / 10 ;
last_monitor_check = 0 ;
2009-10-14 12:10:01 -04:00
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > set_frame_rate ( nframes ) ;
2008-06-02 17:41:35 -04:00
}
SampleRateChanged ( nframes ) ; /* EMIT SIGNAL */
return 0 ;
}
2011-02-15 14:55:14 -05:00
void
AudioEngine : : jack_latency_callback ( jack_latency_callback_mode_t mode )
{
if ( _session ) {
_session - > update_latency ( mode = = JackPlaybackLatency ) ;
}
}
2008-06-02 17:41:35 -04:00
int
2010-12-03 17:26:29 -05:00
AudioEngine : : _bufsize_callback ( pframes_t nframes , void * arg )
2008-06-02 17:41:35 -04:00
{
return static_cast < AudioEngine * > ( arg ) - > jack_bufsize_callback ( nframes ) ;
}
int
2010-12-03 17:26:29 -05:00
AudioEngine : : jack_bufsize_callback ( pframes_t nframes )
2008-06-02 17:41:35 -04:00
{
2011-03-01 20:39:52 -05:00
/* if the size has not changed, this should be a no-op */
if ( nframes = = _buffer_size ) {
return 0 ;
}
GET_PRIVATE_JACK_POINTER_RET ( _jack , 1 ) ;
2010-06-09 09:00:54 -04:00
2008-06-02 17:41:35 -04:00
_buffer_size = nframes ;
_usecs_per_cycle = ( int ) floor ( ( ( ( double ) nframes / frame_rate ( ) ) ) * 1000000.0 ) ;
last_monitor_check = 0 ;
2011-03-21 12:58:16 -04:00
if ( jack_port_type_get_buffer_size ) {
_raw_buffer_sizes [ DataType : : AUDIO ] = jack_port_type_get_buffer_size ( _priv_jack , JACK_DEFAULT_AUDIO_TYPE ) ;
_raw_buffer_sizes [ DataType : : MIDI ] = jack_port_type_get_buffer_size ( _priv_jack , JACK_DEFAULT_MIDI_TYPE ) ;
} else {
/* Old version of JACK.
2011-06-01 12:50:12 -04:00
2011-03-21 12:58:16 -04:00
These crude guesses , see below where we try to get the right answers .
2011-06-01 12:50:12 -04:00
2011-03-21 12:58:16 -04:00
Note that our guess for MIDI deliberatey tries to overestimate
by a little . It would be nicer if we could get the actual
2011-06-01 12:50:12 -04:00
size from a port , but we have to use this estimate in the
2011-03-21 12:58:16 -04:00
event that there are no MIDI ports currently . If there are
the value will be adjusted below .
*/
2011-06-01 12:50:12 -04:00
2011-03-21 12:58:16 -04:00
_raw_buffer_sizes [ DataType : : AUDIO ] = nframes * sizeof ( Sample ) ;
_raw_buffer_sizes [ DataType : : MIDI ] = nframes * 4 - ( nframes / 2 ) ;
}
2010-06-09 09:00:54 -04:00
2011-06-01 12:50:12 -04:00
{
2011-04-19 12:54:18 -04:00
Glib : : Mutex : : Lock lm ( _process_lock ) ;
2011-06-01 12:50:12 -04:00
2011-04-19 12:54:18 -04:00
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
2011-06-01 12:50:12 -04:00
2011-04-19 12:54:18 -04:00
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
i - > second - > reset ( ) ;
2011-04-19 12:54:18 -04:00
}
2008-06-02 17:41:35 -04:00
}
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > set_block_size ( _buffer_size ) ;
2008-06-02 17:41:35 -04:00
}
return 0 ;
}
void
AudioEngine : : stop_metering_thread ( )
{
if ( m_meter_thread ) {
g_atomic_int_set ( & m_meter_exit , 1 ) ;
m_meter_thread - > join ( ) ;
m_meter_thread = 0 ;
}
}
void
AudioEngine : : start_metering_thread ( )
{
if ( m_meter_thread = = 0 ) {
g_atomic_int_set ( & m_meter_exit , 0 ) ;
2009-12-17 13:24:23 -05:00
m_meter_thread = Glib : : Thread : : create ( boost : : bind ( & AudioEngine : : meter_thread , this ) ,
2008-06-02 17:41:35 -04:00
500000 , true , true , Glib : : THREAD_PRIORITY_NORMAL ) ;
}
}
void
AudioEngine : : meter_thread ( )
{
2009-12-31 14:49:22 -05:00
pthread_set_name ( X_ ( " meter " ) ) ;
2008-06-02 17:41:35 -04:00
while ( true ) {
Glib : : usleep ( 10000 ) ; /* 1/100th sec interval */
if ( g_atomic_int_get ( & m_meter_exit ) ) {
break ;
}
2009-12-19 15:26:31 -05:00
Metering : : Meter ( ) ;
2008-06-02 17:41:35 -04:00
}
}
2009-10-14 12:10:01 -04:00
void
2008-06-02 17:41:35 -04:00
AudioEngine : : set_session ( Session * s )
{
Glib : : Mutex : : Lock pl ( _process_lock ) ;
2011-06-01 12:50:12 -04:00
2009-12-17 13:24:23 -05:00
SessionHandlePtr : : set_session ( s ) ;
2008-06-02 17:41:35 -04:00
2009-12-17 13:24:23 -05:00
if ( _session ) {
2009-12-31 14:49:22 -05:00
start_metering_thread ( ) ;
2011-06-01 12:50:12 -04:00
2010-12-03 17:26:29 -05:00
pframes_t blocksize = jack_get_buffer_size ( _jack ) ;
2011-06-01 12:50:12 -04:00
2008-06-02 17:41:35 -04:00
/* page in as much of the session process code as we
can before we really start running .
*/
2011-06-01 12:50:12 -04:00
2008-06-02 17:41:35 -04:00
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
2011-06-01 12:50:12 -04:00
2008-06-02 17:41:35 -04:00
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
i - > second - > cycle_start ( blocksize ) ;
2008-06-02 17:41:35 -04:00
}
2011-06-01 12:50:12 -04:00
2009-12-17 13:24:23 -05:00
_session - > process ( blocksize ) ;
_session - > process ( blocksize ) ;
_session - > process ( blocksize ) ;
_session - > process ( blocksize ) ;
_session - > process ( blocksize ) ;
_session - > process ( blocksize ) ;
_session - > process ( blocksize ) ;
_session - > process ( blocksize ) ;
2011-06-01 12:50:12 -04:00
2008-06-02 17:41:35 -04:00
for ( Ports : : iterator i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
i - > second - > cycle_end ( blocksize ) ;
2008-06-02 17:41:35 -04:00
}
}
2011-06-01 12:50:12 -04:00
}
2008-06-02 17:41:35 -04:00
2009-10-14 12:10:01 -04:00
void
2008-06-02 17:41:35 -04:00
AudioEngine : : remove_session ( )
{
Glib : : Mutex : : Lock lm ( _process_lock ) ;
if ( _running ) {
2009-12-31 14:49:22 -05:00
stop_metering_thread ( ) ;
2009-12-17 13:24:23 -05:00
if ( _session ) {
2008-06-02 17:41:35 -04:00
session_remove_pending = true ;
session_removed . wait ( _process_lock ) ;
}
} else {
2009-12-17 13:24:23 -05:00
SessionHandlePtr : : set_session ( 0 ) ;
2008-06-02 17:41:35 -04:00
}
2009-10-14 12:10:01 -04:00
2009-09-02 18:59:12 -04:00
remove_all_ports ( ) ;
2008-06-02 17:41:35 -04:00
}
void
AudioEngine : : port_registration_failure ( const std : : string & portname )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER ( _jack ) ;
2008-06-02 17:41:35 -04:00
string full_portname = jack_client_name ;
full_portname + = ' : ' ;
full_portname + = portname ;
2009-10-14 12:10:01 -04:00
2009-10-14 13:35:33 -04:00
jack_port_t * p = jack_port_by_name ( _priv_jack , full_portname . c_str ( ) ) ;
2008-06-02 17:41:35 -04:00
string reason ;
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
if ( p ) {
2009-04-15 14:04:23 -04:00
reason = string_compose ( _ ( " a port with the name \" %1 \" already exists: check for duplicated track/bus names " ) , portname ) ;
2008-06-02 17:41:35 -04:00
} else {
2012-02-27 11:29:05 -05:00
reason = string_compose ( _ ( " No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks. " ) , PROGRAM_NAME ) ;
2008-06-02 17:41:35 -04:00
}
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
throw PortRegistrationFailure ( string_compose ( _ ( " AudioEngine: cannot register port \" %1 \" : %2 " ) , portname , reason ) . c_str ( ) ) ;
2009-10-14 12:10:01 -04:00
}
2008-06-02 17:41:35 -04:00
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port >
2009-02-10 19:58:24 -05:00
AudioEngine : : register_port ( DataType dtype , const string & portname , bool input )
2008-06-02 17:41:35 -04:00
{
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port > newport ;
2008-06-02 17:41:35 -04:00
try {
if ( dtype = = DataType : : AUDIO ) {
2011-10-28 13:04:09 -04:00
newport . reset ( new AudioPort ( portname , ( input ? Port : : IsInput : Port : : IsOutput ) ) ) ;
2008-06-02 17:41:35 -04:00
} else if ( dtype = = DataType : : MIDI ) {
2011-10-28 13:04:09 -04:00
newport . reset ( new MidiPort ( portname , ( input ? Port : : IsInput : Port : : IsOutput ) ) ) ;
2008-06-02 17:41:35 -04:00
} else {
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
throw PortRegistrationFailure ( " unable to create port (unknown type) " ) ;
2008-06-02 17:41:35 -04:00
}
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
RCUWriter < Ports > writer ( ports ) ;
boost : : shared_ptr < Ports > ps = writer . get_copy ( ) ;
2012-01-27 08:23:39 -05:00
ps - > insert ( make_pair ( make_port_name_relative ( portname ) , newport ) ) ;
2008-06-02 17:41:35 -04:00
/* writer goes out of scope, forces update */
return newport ;
}
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
catch ( PortRegistrationFailure & err ) {
throw err ;
} catch ( std : : exception & e ) {
throw PortRegistrationFailure ( string_compose (
_ ( " unable to create port: %1 " ) , e . what ( ) ) . c_str ( ) ) ;
} catch ( . . . ) {
throw PortRegistrationFailure ( " unable to create port (unknown error) " ) ;
2008-06-02 17:41:35 -04:00
}
}
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port >
2009-02-10 19:58:24 -05:00
AudioEngine : : register_input_port ( DataType type , const string & portname )
2008-06-02 17:41:35 -04:00
{
2009-02-10 19:58:24 -05:00
return register_port ( type , portname , true ) ;
2008-06-02 17:41:35 -04:00
}
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port >
2009-02-10 19:58:24 -05:00
AudioEngine : : register_output_port ( DataType type , const string & portname )
2008-06-02 17:41:35 -04:00
{
2009-02-10 19:58:24 -05:00
return register_port ( type , portname , false ) ;
2008-06-02 17:41:35 -04:00
}
int
2011-10-28 13:04:09 -04:00
AudioEngine : : unregister_port ( boost : : shared_ptr < Port > port )
2008-06-02 17:41:35 -04:00
{
/* caller must hold process lock */
2009-10-14 12:10:01 -04:00
if ( ! _running ) {
2008-06-02 17:41:35 -04:00
/* probably happening when the engine has been halted by JACK,
in which case , there is nothing we can do here .
*/
return 0 ;
}
{
RCUWriter < Ports > writer ( ports ) ;
boost : : shared_ptr < Ports > ps = writer . get_copy ( ) ;
2012-01-27 08:23:39 -05:00
Ports : : iterator x = ps - > find ( make_port_name_relative ( port - > name ( ) ) ) ;
if ( x ! = ps - > end ( ) ) {
ps - > erase ( x ) ;
}
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
/* writer goes out of scope, forces update */
}
2009-10-14 12:10:01 -04:00
2011-10-28 13:04:09 -04:00
ports . flush ( ) ;
2008-06-02 17:41:35 -04:00
return 0 ;
}
2009-10-14 12:10:01 -04:00
int
2008-06-02 17:41:35 -04:00
AudioEngine : : connect ( const string & source , const string & destination )
{
int ret ;
if ( ! _running ) {
if ( ! _has_run ) {
fatal < < _ ( " connect called before engine was started " ) < < endmsg ;
/*NOTREACHED*/
} else {
return - 1 ;
}
}
string s = make_port_name_non_relative ( source ) ;
string d = make_port_name_non_relative ( destination ) ;
2009-01-20 21:27:21 -05:00
2009-10-14 13:35:33 -04:00
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port > src = get_port_by_name ( s ) ;
boost : : shared_ptr < Port > dst = get_port_by_name ( d ) ;
2008-06-02 17:41:35 -04:00
2009-10-14 13:35:33 -04:00
if ( src ) {
2009-12-19 15:26:31 -05:00
ret = src - > connect ( d ) ;
2009-01-23 16:24:11 -05:00
} else if ( dst ) {
2009-12-19 15:26:31 -05:00
ret = dst - > connect ( s ) ;
2008-06-02 17:41:35 -04:00
} else {
/* neither port is known to us, and this API isn't intended for use as a general patch bay */
ret = - 1 ;
}
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
if ( ret > 0 ) {
2009-06-11 09:56:12 -04:00
/* already exists - no error, no warning */
2008-06-02 17:41:35 -04:00
} else if ( ret < 0 ) {
2009-10-14 12:10:01 -04:00
error < < string_compose ( _ ( " AudioEngine: cannot connect %1 (%2) to %3 (%4) " ) ,
source , s , destination , d )
2008-06-02 17:41:35 -04:00
< < endmsg ;
}
return ret ;
}
2009-10-14 12:10:01 -04:00
int
2008-06-02 17:41:35 -04:00
AudioEngine : : disconnect ( const string & source , const string & destination )
{
int ret ;
if ( ! _running ) {
if ( ! _has_run ) {
fatal < < _ ( " disconnect called before engine was started " ) < < endmsg ;
/*NOTREACHED*/
} else {
return - 1 ;
}
}
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
string s = make_port_name_non_relative ( source ) ;
string d = make_port_name_non_relative ( destination ) ;
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port > src = get_port_by_name ( s ) ;
boost : : shared_ptr < Port > dst = get_port_by_name ( d ) ;
2008-06-02 17:41:35 -04:00
2009-05-04 11:50:51 -04:00
if ( src ) {
2009-01-20 21:27:21 -05:00
ret = src - > disconnect ( d ) ;
2009-01-23 16:24:11 -05:00
} else if ( dst ) {
2009-01-20 21:27:21 -05:00
ret = dst - > disconnect ( s ) ;
2008-06-02 17:41:35 -04:00
} else {
/* neither port is known to us, and this API isn't intended for use as a general patch bay */
ret = - 1 ;
}
return ret ;
}
int
2011-10-28 13:04:09 -04:00
AudioEngine : : disconnect ( boost : : shared_ptr < Port > port )
2008-06-02 17:41:35 -04:00
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2009-10-14 13:35:33 -04:00
2008-06-02 17:41:35 -04:00
if ( ! _running ) {
if ( ! _has_run ) {
fatal < < _ ( " disconnect called before engine was started " ) < < endmsg ;
/*NOTREACHED*/
} else {
return - 1 ;
}
}
2011-10-28 13:04:09 -04:00
return port - > disconnect_all ( ) ;
2008-06-02 17:41:35 -04:00
}
2010-12-03 17:26:29 -05:00
ARDOUR : : framecnt_t
2009-12-27 09:46:23 -05:00
AudioEngine : : frame_rate ( ) const
2008-06-02 17:41:35 -04:00
{
2010-12-03 17:26:29 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , 0 ) ;
2009-10-14 13:35:33 -04:00
if ( _frame_rate = = 0 ) {
2010-12-03 17:26:29 -05:00
return ( _frame_rate = jack_get_sample_rate ( _priv_jack ) ) ;
2008-06-02 17:41:35 -04:00
} else {
2010-12-03 17:26:29 -05:00
return _frame_rate ;
2008-06-02 17:41:35 -04:00
}
}
2009-05-04 11:50:51 -04:00
size_t
AudioEngine : : raw_buffer_size ( DataType t )
{
std : : map < DataType , size_t > : : const_iterator s = _raw_buffer_sizes . find ( t ) ;
return ( s ! = _raw_buffer_sizes . end ( ) ) ? s - > second : 0 ;
}
2010-12-03 18:15:53 -05:00
ARDOUR : : pframes_t
2009-12-27 09:46:23 -05:00
AudioEngine : : frames_per_cycle ( ) const
2008-06-02 17:41:35 -04:00
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , 0 ) ;
2009-10-14 13:35:33 -04:00
if ( _buffer_size = = 0 ) {
2011-03-01 20:39:52 -05:00
return jack_get_buffer_size ( _jack ) ;
2008-06-02 17:41:35 -04:00
} else {
2010-12-03 17:26:29 -05:00
return _buffer_size ;
2008-06-02 17:41:35 -04:00
}
}
2010-12-11 15:48:18 -05:00
/** @param name Full or short name of port
2011-10-28 13:04:09 -04:00
* @ return Corresponding Port or 0.
2008-06-02 17:41:35 -04:00
*/
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port >
2009-01-20 21:27:21 -05:00
AudioEngine : : get_port_by_name ( const string & portname )
2008-06-02 17:41:35 -04:00
{
if ( ! _running ) {
if ( ! _has_run ) {
2010-11-27 12:42:09 -05:00
fatal < < _ ( " get_port_by_name() called before engine was started " ) < < endmsg ;
2008-06-02 17:41:35 -04:00
/*NOTREACHED*/
} else {
2011-10-28 13:04:09 -04:00
boost : : shared_ptr < Port > ( ) ;
2008-06-02 17:41:35 -04:00
}
}
2009-01-20 21:27:21 -05:00
2011-03-18 16:21:51 -04:00
if ( ! port_is_mine ( portname ) ) {
/* not an ardour port */
2011-10-28 13:04:09 -04:00
return boost : : shared_ptr < Port > ( ) ;
2011-03-18 16:21:51 -04:00
}
2009-01-20 21:27:21 -05:00
2008-06-02 17:41:35 -04:00
boost : : shared_ptr < Ports > pr = ports . reader ( ) ;
2012-01-27 08:23:39 -05:00
std : : string rel = make_port_name_relative ( portname ) ;
Ports : : iterator x = pr - > find ( rel ) ;
if ( x ! = pr - > end ( ) ) {
/* its possible that the port was renamed by some 3rd party and
we don ' t know about it . check for this ( the check is quick
and cheap ) , and if so , rename the port ( which will alter
the port map as a side effect ) .
*/
const std : : string check = make_port_name_relative ( jack_port_name ( x - > second - > jack_port ( ) ) ) ;
if ( check ! = rel ) {
x - > second - > set_name ( check ) ;
2008-06-02 17:41:35 -04:00
}
2012-01-27 08:23:39 -05:00
return x - > second ;
2008-06-02 17:41:35 -04:00
}
2011-10-28 13:04:09 -04:00
return boost : : shared_ptr < Port > ( ) ;
2008-06-02 17:41:35 -04:00
}
2012-01-27 08:23:39 -05:00
void
AudioEngine : : port_renamed ( const std : : string & old_relative_name , const std : : string & new_relative_name )
{
RCUWriter < Ports > writer ( ports ) ;
boost : : shared_ptr < Ports > p = writer . get_copy ( ) ;
Ports : : iterator x = p - > find ( old_relative_name ) ;
if ( x ! = p - > end ( ) ) {
boost : : shared_ptr < Port > port = x - > second ;
p - > erase ( x ) ;
p - > insert ( make_pair ( new_relative_name , port ) ) ;
}
}
2008-06-02 17:41:35 -04:00
const char * *
AudioEngine : : get_ports ( const string & port_name_pattern , const string & type_name_pattern , uint32_t flags )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , 0 ) ;
2008-06-02 17:41:35 -04:00
if ( ! _running ) {
if ( ! _has_run ) {
fatal < < _ ( " get_ports called before engine was started " ) < < endmsg ;
/*NOTREACHED*/
} else {
return 0 ;
}
}
2009-10-14 13:35:33 -04:00
return jack_get_ports ( _priv_jack , port_name_pattern . c_str ( ) , type_name_pattern . c_str ( ) , flags ) ;
2008-06-02 17:41:35 -04:00
}
2010-04-20 22:24:38 -04:00
void
AudioEngine : : halted_info ( jack_status_t code , const char * reason , void * arg )
{
/* called from jack shutdown handler */
2011-06-01 12:50:12 -04:00
2010-04-20 22:24:38 -04:00
AudioEngine * ae = static_cast < AudioEngine * > ( arg ) ;
bool was_running = ae - > _running ;
2011-06-01 12:50:12 -04:00
2010-04-20 22:24:38 -04:00
ae - > stop_metering_thread ( ) ;
2011-06-01 12:50:12 -04:00
2010-04-20 22:24:38 -04:00
ae - > _running = false ;
ae - > _buffer_size = 0 ;
ae - > _frame_rate = 0 ;
ae - > _jack = 0 ;
2011-06-01 12:50:12 -04:00
2010-04-20 22:24:38 -04:00
if ( was_running ) {
# ifdef HAVE_JACK_ON_INFO_SHUTDOWN
switch ( code ) {
case JackBackendError :
ae - > Halted ( reason ) ; /* EMIT SIGNAL */
break ;
default :
ae - > Halted ( " " ) ; /* EMIT SIGNAL */
}
# else
ae - > Halted ( " " ) ; /* EMIT SIGNAL */
# endif
}
}
2008-06-02 17:41:35 -04:00
void
AudioEngine : : halted ( void * arg )
{
2010-04-13 16:48:33 -04:00
cerr < < " HALTED by JACK \n " ;
2009-10-14 13:35:33 -04:00
/* called from jack shutdown handler */
2008-06-02 17:41:35 -04:00
AudioEngine * ae = static_cast < AudioEngine * > ( arg ) ;
bool was_running = ae - > _running ;
ae - > stop_metering_thread ( ) ;
ae - > _running = false ;
ae - > _buffer_size = 0 ;
ae - > _frame_rate = 0 ;
2010-04-20 22:24:38 -04:00
ae - > _jack = 0 ;
2008-09-10 17:27:39 -04:00
2008-06-02 17:41:35 -04:00
if ( was_running ) {
2010-04-20 22:24:38 -04:00
ae - > Halted ( " " ) ; /* EMIT SIGNAL */
2012-04-23 22:28:51 -04:00
MIDI : : JackMIDIPort : : JackHalted ( ) ; /* EMIT SIGNAL */
2008-06-02 17:41:35 -04:00
}
}
2009-10-14 13:35:33 -04:00
void
AudioEngine : : died ( )
{
/* called from a signal handler for SIGPIPE */
stop_metering_thread ( ) ;
_running = false ;
_buffer_size = 0 ;
_frame_rate = 0 ;
_jack = 0 ;
}
2008-06-02 17:41:35 -04:00
bool
2009-10-14 12:10:01 -04:00
AudioEngine : : can_request_hardware_monitoring ( )
2008-06-02 17:41:35 -04:00
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , false ) ;
2008-06-02 17:41:35 -04:00
const char * * ports ;
2009-10-14 13:35:33 -04:00
if ( ( ports = jack_get_ports ( _priv_jack , NULL , JACK_DEFAULT_AUDIO_TYPE , JackPortCanMonitor ) ) = = 0 ) {
2008-06-02 17:41:35 -04:00
return false ;
}
free ( ports ) ;
return true ;
}
2010-07-27 20:43:15 -04:00
ChanCount
AudioEngine : : n_physical ( unsigned long flags ) const
2008-06-02 17:41:35 -04:00
{
2010-07-27 20:43:15 -04:00
ChanCount c ;
2011-06-01 12:50:12 -04:00
2010-07-27 20:43:15 -04:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , c ) ;
2008-06-02 17:41:35 -04:00
2010-07-27 20:43:15 -04:00
const char * * ports = jack_get_ports ( _priv_jack , NULL , NULL , JackPortIsPhysical | flags ) ;
if ( ports = = 0 ) {
return c ;
2008-06-02 17:41:35 -04:00
}
2010-06-26 09:45:59 -04:00
for ( uint32_t i = 0 ; ports [ i ] ; + + i ) {
2010-07-27 20:43:15 -04:00
if ( ! strstr ( ports [ i ] , " Midi-Through " ) ) {
DataType t ( jack_port_type ( jack_port_by_name ( _jack , ports [ i ] ) ) ) ;
c . set ( t , c . get ( t ) + 1 ) ;
}
}
2010-06-26 09:45:59 -04:00
2008-06-02 17:41:35 -04:00
free ( ports ) ;
2010-07-27 20:43:15 -04:00
return c ;
2008-06-02 17:41:35 -04:00
}
2010-07-27 20:43:15 -04:00
ChanCount
AudioEngine : : n_physical_inputs ( ) const
2008-06-02 17:41:35 -04:00
{
2010-07-27 20:43:15 -04:00
return n_physical ( JackPortIsInput ) ;
}
2008-06-02 17:41:35 -04:00
2010-07-27 20:43:15 -04:00
ChanCount
AudioEngine : : n_physical_outputs ( ) const
{
return n_physical ( JackPortIsOutput ) ;
2008-06-02 17:41:35 -04:00
}
void
2010-07-27 20:43:15 -04:00
AudioEngine : : get_physical ( DataType type , unsigned long flags , vector < string > & phy )
2008-06-02 17:41:35 -04:00
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER ( _jack ) ;
2008-06-02 17:41:35 -04:00
const char * * ports ;
2009-10-14 12:10:01 -04:00
2010-07-27 20:43:15 -04:00
if ( ( ports = jack_get_ports ( _priv_jack , NULL , type . to_jack_type ( ) , JackPortIsPhysical | flags ) ) = = 0 ) {
2008-06-02 17:41:35 -04:00
return ;
}
if ( ports ) {
2010-02-23 15:25:53 -05:00
for ( uint32_t i = 0 ; ports [ i ] ; + + i ) {
2010-06-26 09:45:59 -04:00
if ( strstr ( ports [ i ] , " Midi-Through " ) ) {
continue ;
}
2010-07-27 20:43:15 -04:00
phy . push_back ( ports [ i ] ) ;
2008-06-02 17:41:35 -04:00
}
free ( ports ) ;
}
}
2010-08-04 11:42:45 -04:00
/** Get physical ports for which JackPortIsOutput is set; ie those that correspond to
* a physical input connector .
*/
2008-06-02 17:41:35 -04:00
void
2010-07-27 20:43:15 -04:00
AudioEngine : : get_physical_inputs ( DataType type , vector < string > & ins )
2008-06-02 17:41:35 -04:00
{
2010-08-04 11:42:45 -04:00
get_physical ( type , JackPortIsOutput , ins ) ;
2010-07-27 20:43:15 -04:00
}
2009-10-14 12:10:01 -04:00
2010-08-04 11:42:45 -04:00
/** Get physical ports for which JackPortIsInput is set; ie those that correspond to
* a physical output connector .
*/
2010-07-27 20:43:15 -04:00
void
AudioEngine : : get_physical_outputs ( DataType type , vector < string > & outs )
{
2010-08-04 11:42:45 -04:00
get_physical ( type , JackPortIsInput , outs ) ;
2008-06-02 17:41:35 -04:00
}
void
AudioEngine : : transport_stop ( )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER ( _jack ) ;
2009-10-14 13:35:33 -04:00
jack_transport_stop ( _priv_jack ) ;
2008-06-02 17:41:35 -04:00
}
void
AudioEngine : : transport_start ( )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER ( _jack ) ;
2009-10-14 13:35:33 -04:00
jack_transport_start ( _priv_jack ) ;
2008-06-02 17:41:35 -04:00
}
void
2010-12-03 17:26:29 -05:00
AudioEngine : : transport_locate ( framepos_t where )
2008-06-02 17:41:35 -04:00
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER ( _jack ) ;
2009-10-14 13:35:33 -04:00
jack_transport_locate ( _priv_jack , where ) ;
2008-06-02 17:41:35 -04:00
}
AudioEngine : : TransportState
AudioEngine : : transport_state ( )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , ( ( TransportState ) JackTransportStopped ) ) ;
2009-10-14 13:35:33 -04:00
jack_position_t pos ;
return ( TransportState ) jack_transport_query ( _priv_jack , & pos ) ;
2008-06-02 17:41:35 -04:00
}
int
AudioEngine : : reset_timebase ( )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2009-12-17 13:24:23 -05:00
if ( _session ) {
if ( _session - > config . get_jack_time_master ( ) ) {
2009-10-14 13:35:33 -04:00
return jack_set_timebase_callback ( _priv_jack , 0 , _jack_timebase_callback , this ) ;
2008-06-02 17:41:35 -04:00
} else {
return jack_release_timebase ( _jack ) ;
}
}
2009-10-14 13:35:33 -04:00
return 0 ;
2008-06-02 17:41:35 -04:00
}
int
AudioEngine : : freewheel ( bool onoff )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2008-06-02 17:41:35 -04:00
2009-10-14 13:35:33 -04:00
if ( onoff ! = _freewheeling ) {
2010-03-16 11:33:04 -04:00
return jack_set_freewheel ( _priv_jack , onoff ) ;
2011-06-01 12:50:12 -04:00
2008-06-02 17:41:35 -04:00
} else {
2010-03-16 11:33:04 -04:00
/* already doing what has been asked for */
return 0 ;
2008-06-02 17:41:35 -04:00
}
}
void
AudioEngine : : remove_all_ports ( )
{
2011-04-19 12:54:18 -04:00
/* make sure that JACK callbacks that will be invoked as we cleanup
* ports know that they have nothing to do .
*/
2011-06-01 12:50:12 -04:00
2011-04-19 12:54:18 -04:00
port_remove_in_progress = true ;
/* process lock MUST be held by caller
*/
2008-06-02 17:41:35 -04:00
{
RCUWriter < Ports > writer ( ports ) ;
boost : : shared_ptr < Ports > ps = writer . get_copy ( ) ;
2009-09-02 18:59:12 -04:00
ps - > clear ( ) ;
2008-06-02 17:41:35 -04:00
}
2009-11-27 12:29:27 -05:00
2011-04-19 12:54:18 -04:00
/* clear dead wood list in RCU */
2009-11-27 12:29:27 -05:00
ports . flush ( ) ;
2011-04-19 12:54:18 -04:00
port_remove_in_progress = false ;
2008-06-02 17:41:35 -04:00
}
int
2010-04-02 14:54:33 -04:00
AudioEngine : : connect_to_jack ( string client_name , string session_uuid )
2008-06-02 17:41:35 -04:00
{
2011-01-07 11:25:57 -05:00
EnvironmentalProtectionAgency * global_epa = EnvironmentalProtectionAgency : : get_global_epa ( ) ;
boost : : scoped_ptr < EnvironmentalProtectionAgency > current_epa ;
2008-06-02 17:41:35 -04:00
jack_status_t status ;
2010-12-22 23:17:45 -05:00
/* revert all environment settings back to whatever they were when ardour started
*/
if ( global_epa ) {
2011-01-07 11:25:57 -05:00
current_epa . reset ( new EnvironmentalProtectionAgency ( true ) ) ; /* will restore settings when we leave scope */
2010-12-22 23:17:45 -05:00
global_epa - > restore ( ) ;
}
2008-06-02 17:41:35 -04:00
jack_client_name = client_name ; /* might be reset below */
2010-04-02 14:54:33 -04:00
# ifdef HAVE_JACK_SESSION
if ( ! session_uuid . empty ( ) )
_jack = jack_client_open ( jack_client_name . c_str ( ) , JackSessionID , & status , session_uuid . c_str ( ) ) ;
else
# endif
2012-06-19 21:30:14 -04:00
_jack = jack_client_open ( jack_client_name . c_str ( ) , JackNullOption , & status , 0 ) ;
2008-06-02 17:41:35 -04:00
if ( _jack = = NULL ) {
// error message is not useful here
return - 1 ;
}
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2009-10-14 13:35:33 -04:00
2008-06-02 17:41:35 -04:00
if ( status & JackNameNotUnique ) {
2009-10-14 13:35:33 -04:00
jack_client_name = jack_get_client_name ( _priv_jack ) ;
2008-06-02 17:41:35 -04:00
}
return 0 ;
}
2009-10-14 12:10:01 -04:00
int
2008-06-02 17:41:35 -04:00
AudioEngine : : disconnect_from_jack ( )
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , 0 ) ;
2008-06-02 17:41:35 -04:00
2008-09-10 17:27:39 -04:00
if ( _running ) {
stop_metering_thread ( ) ;
}
2009-10-14 12:10:01 -04:00
{
2008-09-10 17:27:39 -04:00
Glib : : Mutex : : Lock lm ( _process_lock ) ;
2009-10-14 13:35:33 -04:00
jack_client_close ( _priv_jack ) ;
2008-09-10 17:27:39 -04:00
_jack = 0 ;
}
2008-06-02 17:41:35 -04:00
_buffer_size = 0 ;
_frame_rate = 0 ;
2009-05-04 11:50:51 -04:00
_raw_buffer_sizes . clear ( ) ;
2008-06-02 17:41:35 -04:00
if ( _running ) {
_running = false ;
Stopped ( ) ; /* EMIT SIGNAL */
2012-04-23 22:28:51 -04:00
MIDI : : JackMIDIPort : : JackHalted ( ) ; /* EMIT SIGNAL */
2008-06-02 17:41:35 -04:00
}
return 0 ;
}
int
AudioEngine : : reconnect_to_jack ( )
{
2008-09-10 17:27:39 -04:00
if ( _running ) {
2008-06-02 17:41:35 -04:00
disconnect_from_jack ( ) ;
/* XXX give jackd a chance */
Glib : : usleep ( 250000 ) ;
}
2010-04-02 14:54:33 -04:00
if ( connect_to_jack ( jack_client_name , " " ) ) {
2008-06-02 17:41:35 -04:00
error < < _ ( " failed to connect to JACK " ) < < endmsg ;
return - 1 ;
}
Ports : : iterator i ;
boost : : shared_ptr < Ports > p = ports . reader ( ) ;
for ( i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
if ( i - > second - > reestablish ( ) ) {
2008-06-02 17:41:35 -04:00
break ;
2009-10-14 12:10:01 -04:00
}
2008-06-02 17:41:35 -04:00
}
if ( i ! = p - > end ( ) ) {
/* failed */
remove_all_ports ( ) ;
return - 1 ;
2009-10-14 12:10:01 -04:00
}
2008-06-02 17:41:35 -04:00
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2008-06-02 17:41:35 -04:00
2010-07-05 11:41:05 -04:00
MIDI : : Manager : : instance ( ) - > reestablish ( _priv_jack ) ;
2011-06-01 12:50:12 -04:00
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > reset_jack_connection ( _priv_jack ) ;
2010-04-13 16:48:33 -04:00
jack_bufsize_callback ( jack_get_buffer_size ( _priv_jack ) ) ;
2009-12-17 13:24:23 -05:00
_session - > set_frame_rate ( jack_get_sample_rate ( _priv_jack ) ) ;
2008-06-02 17:41:35 -04:00
}
last_monitor_check = 0 ;
2011-06-01 12:50:12 -04:00
2011-03-01 20:39:52 -05:00
set_jack_callbacks ( ) ;
2009-10-14 12:10:01 -04:00
2009-10-14 13:35:33 -04:00
if ( jack_activate ( _priv_jack ) = = 0 ) {
2008-06-02 17:41:35 -04:00
_running = true ;
_has_run = true ;
} else {
return - 1 ;
}
/* re-establish connections */
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
for ( i = p - > begin ( ) ; i ! = p - > end ( ) ; + + i ) {
2012-01-27 08:23:39 -05:00
i - > second - > reconnect ( ) ;
2008-06-02 17:41:35 -04:00
}
2010-07-05 11:41:05 -04:00
MIDI : : Manager : : instance ( ) - > reconnect ( ) ;
2008-06-02 17:41:35 -04:00
Running ( ) ; /* EMIT SIGNAL*/
start_metering_thread ( ) ;
return 0 ;
}
int
2010-12-03 17:26:29 -05:00
AudioEngine : : request_buffer_size ( pframes_t nframes )
2008-06-02 17:41:35 -04:00
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , - 1 ) ;
2008-06-02 17:41:35 -04:00
2009-10-14 13:35:33 -04:00
if ( nframes = = jack_get_buffer_size ( _priv_jack ) ) {
2011-03-01 20:39:52 -05:00
return 0 ;
2008-06-02 17:41:35 -04:00
}
2011-06-01 12:50:12 -04:00
2009-10-14 13:35:33 -04:00
return jack_set_buffer_size ( _priv_jack , nframes ) ;
2008-06-02 17:41:35 -04:00
}
string
2011-03-18 16:21:51 -04:00
AudioEngine : : make_port_name_relative ( string portname ) const
2008-06-02 17:41:35 -04:00
{
string : : size_type len ;
string : : size_type n ;
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
len = portname . length ( ) ;
for ( n = 0 ; n < len ; + + n ) {
if ( portname [ n ] = = ' : ' ) {
break ;
}
}
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
if ( ( n ! = len ) & & ( portname . substr ( 0 , n ) = = jack_client_name ) ) {
return portname . substr ( n + 1 ) ;
}
return portname ;
}
string
2011-03-18 16:21:51 -04:00
AudioEngine : : make_port_name_non_relative ( string portname ) const
2008-06-02 17:41:35 -04:00
{
string str ;
if ( portname . find_first_of ( ' : ' ) ! = string : : npos ) {
return portname ;
}
str = jack_client_name ;
str + = ' : ' ;
str + = portname ;
2009-10-14 12:10:01 -04:00
2008-06-02 17:41:35 -04:00
return str ;
}
2011-03-18 16:21:51 -04:00
bool
AudioEngine : : port_is_mine ( const string & portname ) const
{
if ( portname . find_first_of ( ' : ' ) ! = string : : npos ) {
if ( portname . substr ( 0 , jack_client_name . length ( ) ) ! = jack_client_name ) {
return false ;
}
}
return true ;
}
2008-06-02 17:41:35 -04:00
bool
AudioEngine : : is_realtime ( ) const
{
2010-02-23 15:25:53 -05:00
GET_PRIVATE_JACK_POINTER_RET ( _jack , false ) ;
2009-10-14 13:35:33 -04:00
return jack_is_realtime ( _priv_jack ) ;
2008-06-02 17:41:35 -04:00
}
2010-06-24 10:13:45 -04:00
2010-11-10 17:50:52 -05:00
int
AudioEngine : : create_process_thread ( boost : : function < void ( ) > f , pthread_t * thread , size_t stacksize )
2010-06-24 10:13:45 -04:00
{
GET_PRIVATE_JACK_POINTER_RET ( _jack , 0 ) ;
ThreadData * td = new ThreadData ( this , f , stacksize ) ;
2011-06-01 12:50:12 -04:00
if ( jack_client_create_thread ( _priv_jack , thread , jack_client_real_time_priority ( _priv_jack ) ,
2010-06-24 10:13:45 -04:00
jack_is_realtime ( _priv_jack ) , _start_process_thread , td ) ) {
return - 1 ;
2011-06-01 12:50:12 -04:00
}
2010-06-24 10:13:45 -04:00
2010-11-10 17:50:52 -05:00
return 0 ;
2010-06-24 10:13:45 -04:00
}
void *
AudioEngine : : _start_process_thread ( void * arg )
{
ThreadData * td = reinterpret_cast < ThreadData * > ( arg ) ;
boost : : function < void ( ) > f = td - > f ;
delete td ;
f ( ) ;
return 0 ;
}
2011-03-15 15:32:21 -04:00
2011-06-01 12:50:12 -04:00
bool
2011-03-15 15:32:21 -04:00
AudioEngine : : port_is_physical ( const std : : string & portname ) const
{
GET_PRIVATE_JACK_POINTER_RET ( _jack , false ) ;
jack_port_t * port = jack_port_by_name ( _priv_jack , portname . c_str ( ) ) ;
if ( ! port ) {
return false ;
}
2011-06-01 12:50:12 -04:00
2011-03-15 15:32:21 -04:00
return jack_port_flags ( port ) & JackPortIsPhysical ;
}
2011-06-01 12:50:12 -04:00
void
2011-12-22 20:11:41 -05:00
AudioEngine : : request_jack_monitors_input ( const std : : string & portname , bool yn ) const
2011-03-15 15:32:21 -04:00
{
GET_PRIVATE_JACK_POINTER ( _jack ) ;
jack_port_t * port = jack_port_by_name ( _priv_jack , portname . c_str ( ) ) ;
if ( ! port ) {
return ;
}
jack_port_request_monitor ( port , yn ) ;
}
2011-09-21 13:28:13 -04:00
void
AudioEngine : : update_latencies ( )
{
if ( jack_recompute_total_latencies ) {
GET_PRIVATE_JACK_POINTER ( _jack ) ;
jack_recompute_total_latencies ( _priv_jack ) ;
}
}
2011-12-15 09:33:20 -05:00
void
AudioEngine : : destroy ( )
{
delete _instance ;
_instance = 0 ;
}