286 lines
7.4 KiB
C
286 lines
7.4 KiB
C
|
||
/*******************************************************************************/
|
||
/* Copyright (C) 2008 Jonathan Moore Liles */
|
||
/* */
|
||
/* 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; see the file COPYING. If not,write to the Free Software */
|
||
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||
/*******************************************************************************/
|
||
|
||
#include "Engine.H"
|
||
#include "../Transport.H"
|
||
|
||
#include "../Timeline.H" // for process()
|
||
#include "../Sequence_Widget.H" // for BBT and position info.
|
||
|
||
#define APP_NAME "Non-DAW" // FIXME: wrong place for this!
|
||
|
||
/* This is the home of the JACK process callback (does this *really*
|
||
need to be a class?) */
|
||
|
||
#include "util/Thread.H"
|
||
|
||
Engine::Engine ( ) : _thread( "RT" )
|
||
{
|
||
_freewheeling = false;
|
||
_client = NULL;
|
||
_buffers_dropped = 0;
|
||
_xruns = 0;
|
||
}
|
||
|
||
/*******************/
|
||
/* Static Wrappers */
|
||
/*******************/
|
||
|
||
int
|
||
Engine::process ( nframes_t nframes, void *arg )
|
||
{
|
||
return ((Engine*)arg)->process( nframes );
|
||
}
|
||
|
||
int
|
||
Engine::sync ( jack_transport_state_t state, jack_position_t *pos, void *arg )
|
||
{
|
||
return ((Engine*)arg)->sync( state, pos );
|
||
}
|
||
|
||
int
|
||
Engine::xrun ( void *arg )
|
||
{
|
||
return ((Engine*)arg)->xrun();
|
||
}
|
||
|
||
void
|
||
Engine::timebase ( jack_transport_state_t state, jack_nframes_t nframes, jack_position_t *pos, int new_pos, void *arg )
|
||
{
|
||
((Engine*)arg)->timebase( state, nframes, pos, new_pos );
|
||
}
|
||
|
||
void
|
||
Engine::freewheel ( int starting, void *arg )
|
||
{
|
||
((Engine*)arg)->freewheel( starting );
|
||
}
|
||
|
||
int
|
||
Engine::buffer_size ( nframes_t nframes, void *arg )
|
||
{
|
||
return ((Engine*)arg)->buffer_size( nframes );
|
||
}
|
||
|
||
|
||
|
||
void
|
||
Engine::request_locate ( nframes_t frame )
|
||
{
|
||
if ( timeline )
|
||
timeline->seek( frame );
|
||
}
|
||
|
||
/* THREAD: RT */
|
||
/** This is the jack xrun callback */
|
||
int
|
||
Engine::xrun ( void )
|
||
{
|
||
++_xruns;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* THREAD: RT */
|
||
void
|
||
Engine::freewheel ( bool starting )
|
||
{
|
||
_freewheeling = starting;
|
||
|
||
if ( starting )
|
||
DMESSAGE( "entering freewheeling mode" );
|
||
else
|
||
DMESSAGE( "leaving freewheeling mode" );
|
||
}
|
||
|
||
/* THREAD: RT (non-RT) */
|
||
int
|
||
Engine::buffer_size ( nframes_t nframes )
|
||
{
|
||
/* TODO: inform all disktreams the the buffer size has changed */
|
||
timeline->resize_buffers( nframes );
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* THREAD: RT */
|
||
/** This is the jack slow-sync callback. */
|
||
int
|
||
Engine::sync ( jack_transport_state_t state, jack_position_t *pos )
|
||
{
|
||
static bool seeking = false;
|
||
|
||
switch ( state )
|
||
{
|
||
case JackTransportStopped: /* new position requested */
|
||
/* JACK docs lie. This is only called when the transport
|
||
is *really* stopped, not when starting a slow-sync
|
||
cycle */
|
||
transport->frame = pos->frame;
|
||
return 1;
|
||
case JackTransportStarting: /* this means JACK is polling slow-sync clients */
|
||
{
|
||
if ( ! seeking )
|
||
{
|
||
request_locate( pos->frame );
|
||
seeking = true;
|
||
}
|
||
|
||
int r = true;
|
||
|
||
if ( timeline )
|
||
r = timeline->seek_pending();
|
||
|
||
if ( ! r )
|
||
seeking = false;
|
||
|
||
return ! seeking;
|
||
}
|
||
case JackTransportRolling: /* JACK's timeout has expired */
|
||
/* FIXME: what's the right thing to do here? */
|
||
// request_locate( pos->frame );
|
||
return 1;
|
||
// return transport->frame == pos->frame;
|
||
break;
|
||
default:
|
||
printf( "unknown transport state.\n" );
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* THREAD: RT */
|
||
void
|
||
Engine::timebase ( jack_transport_state_t, jack_nframes_t, jack_position_t *pos, int )
|
||
{
|
||
position_info pi = timeline->solve_tempomap( pos->frame );
|
||
|
||
pos->valid = JackPositionBBT;
|
||
pos->beats_per_bar = pi.beats_per_bar;
|
||
pos->beat_type = pi.beat_type;
|
||
pos->beats_per_minute = pi.tempo;
|
||
|
||
pos->bar = pi.bbt.bar + 1;
|
||
pos->beat = pi.bbt.beat + 1;
|
||
pos->tick = pi.bbt.tick;
|
||
pos->ticks_per_beat = 1920.0; /* FIXME: wrong place for this */
|
||
|
||
/* FIXME: fill this in */
|
||
pos->bar_start_tick = 0;
|
||
|
||
}
|
||
|
||
|
||
/* THREAD: RT */
|
||
int
|
||
Engine::process ( nframes_t nframes )
|
||
{
|
||
/* FIXME: wrong place for this */
|
||
_thread.set( "RT" );
|
||
|
||
transport->poll();
|
||
|
||
if ( freewheeling() )
|
||
{
|
||
/* freewheeling mode/export. We're actually running
|
||
non-RT. Assume that everything is quiescent, locking is
|
||
unecessary and do I/O synchronously */
|
||
if ( timeline )
|
||
timeline->process( nframes );
|
||
|
||
/* because we're going faster than realtime. */
|
||
timeline->wait_for_buffers();
|
||
}
|
||
else
|
||
{
|
||
if ( ! trylock() )
|
||
{
|
||
/* the data structures we need to access here (tracks and
|
||
* their ports, but not track contents) may be in an
|
||
* inconsistent state at the moment. Just punt and drop this
|
||
* buffer. */
|
||
++_buffers_dropped;
|
||
return 0;
|
||
}
|
||
|
||
/* handle chicken/egg problem */
|
||
if ( timeline )
|
||
/* this will initiate the process() call graph for the various
|
||
* number and types of tracks, which will in turn send data out
|
||
* the appropriate ports. */
|
||
timeline->process( nframes );
|
||
|
||
unlock();
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/** enter or leave freehweeling mode */
|
||
void
|
||
Engine::freewheeling ( bool yes )
|
||
{
|
||
if ( jack_set_freewheel( _client, yes ) )
|
||
WARNING( "Unkown error while setting freewheeling mode" );
|
||
}
|
||
|
||
void
|
||
Engine::thread_init ( void *arg )
|
||
{
|
||
((Engine*)arg)->thread_init();
|
||
}
|
||
|
||
void
|
||
Engine::thread_init ( void )
|
||
{
|
||
_thread.set( "RT" );
|
||
}
|
||
|
||
int
|
||
Engine::init ( void )
|
||
{
|
||
if (( _client = jack_client_open ( APP_NAME, (jack_options_t)0, NULL )) == 0 )
|
||
return 0;
|
||
|
||
#define set_callback( name ) jack_set_ ## name ## _callback( _client, &Engine:: name , this )
|
||
|
||
set_callback( thread_init );
|
||
set_callback( process );
|
||
set_callback( xrun );
|
||
set_callback( freewheel );
|
||
set_callback( buffer_size );
|
||
|
||
/* FIXME: should we wait to register this until after the project
|
||
has been loaded (and we have disk threads running)? */
|
||
set_callback( sync );
|
||
|
||
jack_set_timebase_callback( _client, 0, &Engine::timebase, this );
|
||
|
||
jack_activate( _client );
|
||
|
||
_sample_rate = frame_rate();
|
||
|
||
timeline->_sample_rate = frame_rate();
|
||
|
||
/* we don't need to create any ports until tracks are created */
|
||
return 1;
|
||
}
|