Beispiel #1
0
//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;
            }
        }
    }
Beispiel #2
0
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;
	}
}
Beispiel #3
0
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;
	}
}
Beispiel #5
0
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 );
}
Beispiel #6
0
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;
}
Beispiel #9
0
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 );
}
Beispiel #10
0
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];

}
Beispiel #11
0
void jackt_stop() {
	if (jack_client) {
		jack_transport_stop (jack_client);
	}
}
Beispiel #12
0
//------------------------------------------------------------------------
void TJackSynchro::StopSync()
{
    assert(fClient);
    jack_transport_stop(fClient);
}
Beispiel #13
0
Datei: Client.C Projekt: 0mk/non
 void
 Client::transport_stop ( )
 {
     jack_transport_stop( _client );
 }
Beispiel #14
0
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;
}
Beispiel #16
0
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;
}
Beispiel #18
0
Datei: jack.c Projekt: rknLA/rove
void rove_transport_stop() {
	jack_transport_stop(state.client);
	jack_transport_locate(state.client, 0);
}
Beispiel #19
0
void luajack_transport_stop(luajack_t *client) 
	{
	cud_t *cud = get_cud(client);	
	if(cud)
		jack_transport_stop(cud->client);
	}