//transport---------------------------------------------------------------------------
void JackNetAdapter::DecodeTransportData()
{
//TODO : we need here to get the actual timebase master to eventually release it from its duty (see JackNetDriver)
//is there a new transport state ?
if (fSendTransportData.fNewState &&(fSendTransportData.fState != jack_transport_query(fClient, NULL))) {
switch (fSendTransportData.fState)
{
case JackTransportStopped :
jack_transport_stop(fClient);
jack_info("NetMaster : transport stops");
break;
case JackTransportStarting :
jack_transport_reposition(fClient, &fSendTransportData.fPosition);
jack_transport_start(fClient);
jack_info("NetMaster : transport starts");
break;
case JackTransportRolling :
// TODO, we need to :
// - find a way to call TransportEngine->SetNetworkSync()
// - turn the transport state to JackTransportRolling
jack_info("NetMaster : transport rolls");
break;
}
}
}
void JackOutput::stop()
{
if ( ( Preferences::get_instance() )->m_bJackTransportMode == Preferences::USE_JACK_TRANSPORT || Preferences::get_instance()->m_bJackMasterMode == Preferences::USE_JACK_TIME_MASTER ) {
if ( client ) {
INFOLOG( "jack_transport_stop()" );
jack_transport_stop( client );
}
} else {
m_transport.m_status = TransportInfo::STOPPED;
}
}
static PyObject* transport_stop (PyObject* self, PyObject* args)
{
pyjack_client_t * client = self_or_global_client(self);
if(client->pjc == NULL) {
PyErr_SetString(JackNotConnectedError, "Jack connection has not yet been established.");
return NULL;
}
jack_transport_stop (client->pjc);
return Py_None;
}
void JackAudioDriver::stop()
{
Preferences* P = Preferences::get_instance();
if ( P->m_bJackTransportMode == Preferences::USE_JACK_TRANSPORT ||
P->m_bJackMasterMode == Preferences::USE_JACK_TIME_MASTER ) {
if ( m_pClient ) {
INFOLOG( "jack_transport_stop()" );
jack_transport_stop( m_pClient );
}
} else {
m_transport.m_status = TransportInfo::STOPPED;
}
}
void
Transport::stop ( void )
{
// MESSAGE( "Stopping transport" );
if ( _record_button->value() )
{
if ( _stop_disables_record )
_record_button->value( 0 );
update_record_state();
}
jack_transport_stop( client );
}
static void cbox_jackio_control_transport(struct cbox_io_impl *impl, gboolean roll, uint32_t pos)
{
struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
if (jii->debug_transport)
g_message("JACK transport: control(op=%s, pos=%d)\n", roll ? "roll" : "stop", (int)pos);
jack_transport_state_t state = jack_transport_query(jii->client, NULL);
if (roll && state == JackTransportStopped)
jack_transport_start(jii->client);
if (!roll && state != JackTransportStopped)
jack_transport_stop(jii->client);
if (pos != (uint32_t)-1)
jack_transport_locate(jii->client, pos);
}
static gboolean
gst_jack_ring_buffer_pause (GstRingBuffer * buf)
{
GstJackAudioSink *sink;
sink = GST_JACK_AUDIO_SINK (GST_OBJECT_PARENT (buf));
GST_DEBUG_OBJECT (sink, "pause");
if (sink->transport & GST_JACK_TRANSPORT_MASTER) {
jack_client_t *client;
client = gst_jack_audio_client_get_client (sink->client);
jack_transport_stop (client);
}
return TRUE;
}
static gboolean
gst_jack_ring_buffer_stop (GstRingBuffer * buf)
{
GstJackAudioSrc *src;
src = GST_JACK_AUDIO_SRC (GST_OBJECT_PARENT (buf));
GST_DEBUG_OBJECT (src, "stop");
if (src->transport & GST_JACK_TRANSPORT_MASTER) {
jack_client_t *client;
client = gst_jack_audio_client_get_client (src->client);
jack_transport_stop (client);
}
return TRUE;
}
static void on_jack_stop( mlt_properties owner, mlt_properties properties )
{
mlt_log_verbose( NULL, "%s\n", __FUNCTION__ );
jack_client_t *jack_client = mlt_properties_get_data( properties, "jack_client", NULL );
jack_transport_stop( jack_client );
}
static void do_jack(jack_client_t* client, char *button, int bk)
{
black_keys = bk;
// Jack Transport
if (button[0] && (button[0] != button_prev_val[0])) //select :: Change octave
{
if (oct == 0) {
oct = 1; //C6
if (debug) printf("STAT: Changed base octave to C6\n");
} else if (oct == 1) {
oct = 2; //C7
if (debug) printf("STAT: Changed base octave to C7\n");
} else if (oct == 2) {
oct = -2; //C3
if (debug) printf("STAT: Changed base octave to C3\n");
} else if (oct == -2) {
oct = -1; //C4
if (debug) printf("STAT: Changed base octave to C4\n");
} else {
oct = 0; //C5
if (debug) printf("STAT: Changed base octave to C5\n");
}
}
else if (button[3] && (button[3] != button_prev_val[3])) //start :: Start/Stop Transport
{
state = jack_transport_query(client, NULL);
if (state) {
jack_transport_stop(client);
if (debug) printf("STAT: Transport stopped\n");
} else {
jack_transport_start(client);
if (debug) printf("STAT: Transport started\n");
}
}
if (button[16] && (button[16] != button_prev_val[16])) //PS :: Panic button
{
if (debug) printf("STAT: Panic!\n");
jack_transport_stop(client);
jack_transport_locate(client, 0);
jack_transport_stop(client);
int h;
for (h=8; h<20; h++) {
axis[h] = 0;
axis_prev_velocity[h] = 0;
}
}
else if (button[1]) //L3 :: Move transport backwards
{
jack_transport_query(client, &position);
int prevJackFrame = position.frame - 100000;
if (prevJackFrame < 0) prevJackFrame = 0;
jack_transport_locate(client, prevJackFrame);
if (button[1] != button_prev_val[1])
if (debug) printf("STAT: Transport backwards...\n");
}
else if (button[1] != button_prev_val[1])
{
if (debug) printf("STAT: Transport normal\n");
}
else if (button[2]) //R3 :: Move transport forwards
{
jack_transport_query(client, &position);
int nextJackFrame = position.frame + 100000;
jack_transport_locate(client, nextJackFrame);
if (button[2] != button_prev_val[2])
if (debug) printf("STAT: Transport forwards...\n");
}
else if (button[2] != button_prev_val[2])
{
if (debug) printf("STAT: Transport normal\n");
}
button_prev_val[0] = button[0];
button_prev_val[1] = button[1];
button_prev_val[2] = button[2];
button_prev_val[3] = button[3];
button_prev_val[16] = button[16];
}
void jackt_stop() {
if (jack_client) {
jack_transport_stop (jack_client);
}
}
//------------------------------------------------------------------------
void TJackSynchro::StopSync()
{
assert(fClient);
jack_transport_stop(fClient);
}
void
Client::transport_stop ( )
{
jack_transport_stop( _client );
}
void jackStop() {
if (api == SYS_API_JACK) {
jack_client_t *client = jackGetHandle();
jack_transport_stop(client);
}
}
void AUD_JackDevice::stopPlayback()
{
jack_transport_stop(m_client);
m_nextState = JackTransportStopped;
}
static void com_stop(char *arg)
{
jack_transport_stop(client);
}
static void jack_transport_stoper(jack_transport_t * x)
{
jack_transport_stop(x->x_jack_client);
return;
}
void rove_transport_stop() {
jack_transport_stop(state.client);
jack_transport_locate(state.client, 0);
}
void luajack_transport_stop(luajack_t *client)
{
cud_t *cud = get_cud(client);
if(cud)
jack_transport_stop(cud->client);
}
