* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-#include <framework/mlt_filter.h>
-#include <framework/mlt_frame.h>
-#include <framework/mlt_log.h>
+#include <framework/mlt.h>
#include <stdio.h>
#include <stdlib.h>
#include "jack_rack.h"
+extern pthread_mutex_t g_activate_mutex;
+
#define BUFFER_LEN 204800 * 6
+static void jack_started_transmitter( mlt_listener listener, mlt_properties owner, mlt_service service, void **args )
+{
+ listener( owner, service, (mlt_position*) args[0] );
+}
+
+static void jack_stopped_transmitter( mlt_listener listener, mlt_properties owner, mlt_service service, void **args )
+{
+ listener( owner, service, (mlt_position*) args[0] );
+}
+
+static void jack_seek_transmitter( mlt_listener listener, mlt_properties owner, mlt_service service, void **args )
+{
+ listener( owner, service, (mlt_position*) args[0] );
+}
+
+#define JACKSTATE(x) (x==JackTransportStopped?"stopped":x==JackTransportStarting?"starting":x==JackTransportRolling?"rolling":"unknown")
+
+static int jack_sync( jack_transport_state_t state, jack_position_t *jack_pos, void *arg )
+{
+ mlt_filter filter = (mlt_filter) arg;
+ mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
+ mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE(filter) );
+ mlt_position position = mlt_profile_fps( profile ) * jack_pos->frame / jack_pos->frame_rate + 0.5;
+ int result = 1;
+
+ mlt_log_debug( MLT_FILTER_SERVICE(filter), "%s frame %u rate %u pos %d last_pos %d\n",
+ JACKSTATE(state), jack_pos->frame, jack_pos->frame_rate, position,
+ mlt_properties_get_position( properties, "_last_pos" ) );
+ if ( state == JackTransportStopped )
+ {
+ mlt_events_fire( properties, "jack-stopped", &position, NULL );
+ mlt_properties_set_int( properties, "_sync_guard", 0 );
+ }
+ else if ( state == JackTransportStarting )
+ {
+ result = 0;
+ if ( !mlt_properties_get_int( properties, "_sync_guard" ) )
+ {
+ mlt_properties_set_int( properties, "_sync_guard", 1 );
+ mlt_events_fire( properties, "jack-started", &position, NULL );
+ }
+ else if ( position >= mlt_properties_get_position( properties, "_last_pos" ) - 2 )
+ {
+ mlt_properties_set_int( properties, "_sync_guard", 0 );
+ result = 1;
+ }
+ }
+ else
+ {
+ mlt_properties_set_int( properties, "_sync_guard", 0 );
+ }
+
+ return result;
+}
+
+static void on_jack_start( 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_start( jack_client );
+}
+
+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 on_jack_seek( mlt_properties owner, mlt_filter filter, mlt_position *position )
+{
+ mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
+ mlt_log_verbose( MLT_FILTER_SERVICE(filter), "%s: %d\n", __FUNCTION__, *position );
+ mlt_properties_set_int( properties, "_sync_guard", 1 );
+ mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
+ jack_client_t *jack_client = mlt_properties_get_data( properties, "jack_client", NULL );
+ jack_nframes_t jack_frame = jack_get_sample_rate( jack_client );
+ jack_frame *= *position / mlt_profile_fps( profile );
+ jack_transport_locate( jack_client, jack_frame );
+}
+
static void initialise_jack_ports( mlt_properties properties )
{
int i;
sizeof( float *) * channels, mlt_pool_release, NULL );
mlt_properties_set_data( properties, "jack_input_buffers", jack_input_buffers,
sizeof( float *) * channels, mlt_pool_release, NULL );
-
- // Start Jack processing - required before registering ports
- jack_activate( jack_client );
// Register Jack ports
for ( i = 0; i < channels; i++ )
}
}
+ // Start Jack processing
+ pthread_mutex_lock( &g_activate_mutex );
+ jack_activate( jack_client );
+ pthread_mutex_unlock( &g_activate_mutex );
+
// Establish connections
for ( i = 0; i < channels; i++ )
{
}
ring_size = jack_ringbuffer_read_space( output_buffers[i] );
jack_ringbuffer_read( output_buffers[i], ( char * )jack_output_buffers[i], ring_size < jack_size ? ring_size : jack_size );
+ if ( ring_size < jack_size )
+ memset( &jack_output_buffers[i][ring_size], 0, jack_size - ring_size );
// Return audio through in port
jack_input_buffers[i] = jack_port_get_buffer( jack_input_ports[i], frames );
}
}
+ // Often jackd does not send the stopped event through the JackSyncCallback
+ jack_client_t *jack_client = mlt_properties_get_data( properties, "jack_client", NULL );
+ jack_position_t jack_pos;
+ jack_transport_state_t state = jack_transport_query( jack_client, &jack_pos );
+ int transport_state = mlt_properties_get_int( properties, "_transport_state" );
+ if ( state != transport_state )
+ {
+ mlt_properties_set_int( properties, "_transport_state", state );
+ if ( state == JackTransportStopped )
+ jack_sync( state, &jack_pos, filter );
+ }
+
return err;
}
jack_ringbuffer_read( input_buffers[j], (char*)( q + j * *samples ), size );
}
+ // help jack_sync() indicate when we are rolling
+ mlt_position pos = mlt_frame_get_position( frame );
+ mlt_properties_set_position( filter_properties, "_last_pos", pos );
+
return 0;
}
mlt_filter this = mlt_filter_new( );
if ( this != NULL )
{
- char name[14];
-
+ char name[16];
+ char *jack_client_name;
+ jack_status_t status = 0;
+
snprintf( name, sizeof( name ), "mlt%d", getpid() );
- jack_client_t *jack_client = jack_client_new( name );
+ jack_client_t *jack_client = jack_client_open( name, JackNullOption, &status, NULL );
if ( jack_client )
{
+ if ( status & JackNameNotUnique )
+ {
+ jack_client_name = jack_get_client_name ( jack_client );
+ strcpy( name, jack_client_name );
+ }
+
mlt_properties properties = MLT_FILTER_PROPERTIES( this );
pthread_mutex_t *output_lock = mlt_pool_alloc( sizeof( pthread_mutex_t ) );
pthread_cond_t *output_ready = mlt_pool_alloc( sizeof( pthread_cond_t ) );
jack_set_process_callback( jack_client, jack_process, this );
+ jack_set_sync_callback( jack_client, jack_sync, this );
+ jack_set_sync_timeout( jack_client, 5000000 );
//TODO: jack_on_shutdown( jack_client, jack_shutdown_cb, this );
this->process = filter_process;
this->close = filter_close;
mlt_properties_set_data( properties, "output_ready", output_ready, 0, mlt_pool_release, NULL );
mlt_properties_set_int( properties, "_sync", 1 );
mlt_properties_set_int( properties, "channels", 2 );
+
+ mlt_events_register( properties, "jack-started", (mlt_transmitter) jack_started_transmitter );
+ mlt_events_register( properties, "jack-stopped", (mlt_transmitter) jack_stopped_transmitter );
+ mlt_events_register( properties, "jack-start", NULL );
+ mlt_events_register( properties, "jack-stop", NULL );
+ mlt_events_register( properties, "jack-seek", (mlt_transmitter) jack_seek_transmitter );
+ mlt_events_listen( properties, properties, "jack-start", (mlt_listener) on_jack_start );
+ mlt_events_listen( properties, properties, "jack-stop", (mlt_listener) on_jack_stop );
+ mlt_events_listen( properties, this, "jack-seek", (mlt_listener) on_jack_seek );
+ mlt_properties_set_position( properties, "_jack_seek", -1 );
+ }
+ else
+ {
+ mlt_log_error( NULL, "Failed to connect to JACK server\n" );
+ mlt_filter_close( this );
+ this = NULL;
}
}
return this;
projects / mlt / blobdiff