eessppeelllloo/veejay
1
0
Fork 0
mirror of https://github.com/game-stop/veejay.git synced 2025-12-20 06:40:01 +01:00
Code Issues Packages Projects Releases Wiki Activity

Bind output parameters to user defined OSC path, implemented OSC client and OSC server using liblo, added liblo as requirement to build script, added events for registering and unregistering OSC paths, added events for starting and stopping OSC client, fixed bug in cloning fx output parameters, minor cleanup

Browse Source 
git-svn-id: svn://code.dyne.org/veejay/trunk@592 eb8d1916-c9e9-0310-b8de-cf0c9472ead5
This commit is contained in:
Niels Elburg
2006-08-30 22:20:22 +00:00
parent b3fb2882d2
commit 50bad29ab1
20 changed files with 1093 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
veejay-ng/config.h.in
View File

@@ -87,6 +87,9 @@
/* Define to 1 if you have the `dl' library (-ldl). */ /* Define to 1 if you have the `dl' library (-ldl). */
#undef HAVE_LIBDL #undef HAVE_LIBDL
/* liblo installed */
#undef HAVE_LIBLO
/* Compiling with pthread library */ /* Compiling with pthread library */
#undef HAVE_LIBPTHREAD #undef HAVE_LIBPTHREAD

20
veejay-ng/configure.ac
View File

@@ -298,6 +298,25 @@ if test x$have_mjpegtools != xtrue ; then
AC_MSG_ERROR([The MJPEGTools not found. Get it from http://mjpeg.sourceforge.net]) AC_MSG_ERROR([The MJPEGTools not found. Get it from http://mjpeg.sourceforge.net])
fi fi
dnl *********************************************************************
dnl Check for liblo
dnl *********************************************************************
have_liblo=false
PKG_CHECK_MODULES( LIBLO, [liblo >= 0.23 ],
[
AC_SUBST( LIBLO_CFLAGS )
AC_SUBST( LIBLO_LIBS )
have_liblo=true
AC_DEFINE( HAVE_LIBLO, 1, [liblo installed])],
[have_liblo=false])
if test x$have_liblo != xtrue ; then
AC_MSG_ERROR([Liblo-0.23 (Leightweight OSC implementation) not found. Get it from http://www.ecs.soton.ac.uk/~njh/liblo/])
fi
dnl ******************************************************************** dnl ********************************************************************
dnl Check to see if __progname is provided by the system dnl Check to see if __progname is provided by the system
dnl ******************************************************************** dnl ********************************************************************
@@ -832,6 +851,7 @@ AC_MSG_NOTICE([ Required dependencies:])
AC_MSG_NOTICE([ - POSIX Threads (pthread) : ${have_pthread}]) AC_MSG_NOTICE([ - POSIX Threads (pthread) : ${have_pthread}])
AC_MSG_NOTICE([ - MJPEGTools : ${have_mjpegtools}]) AC_MSG_NOTICE([ - MJPEGTools : ${have_mjpegtools}])
AC_MSG_NOTICE([ - SDL Video : ${have_sdl}]) AC_MSG_NOTICE([ - SDL Video : ${have_sdl}])
AC_MSG_NOTICE([ - Leightweight OSC : ${have_liblo}])
AC_MSG_NOTICE([ Optional dependencies]) AC_MSG_NOTICE([ Optional dependencies])
AC_MSG_NOTICE([ - unicap : ${have_unicap}]) AC_MSG_NOTICE([ - unicap : ${have_unicap}])
AC_MSG_NOTICE([ - Jack : ${have_jack}]) AC_MSG_NOTICE([ - Jack : ${have_jack}])

2
veejay-ng/libplugger/defs.h
View File

@@ -15,6 +15,8 @@ typedef void (*generic_default_values_f)(void *instance, void *fx_values);
typedef void (*generic_push_parameter_f)(void *instance, int seq_num, void *value ); typedef void (*generic_push_parameter_f)(void *instance, int seq_num, void *value );
typedef void (*generic_clone_parameter_f)(void *instance, int seq_num, void *fx_values ); typedef void (*generic_clone_parameter_f)(void *instance, int seq_num, void *fx_values );
typedef void (*generic_reverse_clone_parameter_f)(void *instance, int seq_num, void *fxvalues ); typedef void (*generic_reverse_clone_parameter_f)(void *instance, int seq_num, void *fxvalues );
typedef void (*generic_reverse_clone_out_parameter_f)(void *instance, void *fxvalues );
typedef void (*generic_deinit_f)(void *instance); typedef void (*generic_deinit_f)(void *instance);
typedef void (*generic_init_f)(void *instance, int w, int h ); typedef void (*generic_init_f)(void *instance, int w, int h );

112
veejay-ng/libplugger/livido-loader.c
View File

@@ -194,6 +194,69 @@ void livido_plug_parameter_set_coord( void *parameter, void *value )
vevo_property_set( parameter, "value", LIVIDO_ATOM_TYPE_DOUBLE, 2, value ); vevo_property_set( parameter, "value", LIVIDO_ATOM_TYPE_DOUBLE, 2, value );
} }
static int livido_pname_to_host_kind( const char *str )
{
if (strcasecmp( str, "NUMBER" ) == 0 ) {
return HOST_PARAM_NUMBER;
}
else if(strcasecmp(str, "INDEX" ) == 0 ) {
return HOST_PARAM_INDEX;
}
else if(strcasecmp(str, "SWITCH") == 0 ) {
return HOST_PARAM_SWITCH;
}
else if(strcasecmp(str, "COORD") == 0 ) {
return HOST_PARAM_COORD;
}
else if(strcasecmp(str, "COLOR") == 0 ) {
return HOST_PARAM_COLOR;
}
else if(strcasecmp(str, "TEXT") == 0 ) {
return HOST_PARAM_TEXT;
}
return 0;
}
static int livido_scan_out_parameters( void *plugin , void *plugger_port)
{
int n = 0;
int vj_np = 0;
int NP = vevo_property_num_elements( plugin , "out_parameter_templates");
int error = 0;
if( NP <= 0 )
return 0;
for( n = 0; n < NP; n ++ )
{
char key[20];
void *param = NULL;
error = vevo_property_get( plugin, "out_parameter_templates", n, &param );
#ifdef STRICT_CHECKING
assert( error == LIVIDO_NO_ERROR );
#endif
sprintf(key, "p%02d", n );
int ikind = 0;
char *kind = get_str_vevo( param, "kind" );
ikind = livido_pname_to_host_kind(kind);
veejay_msg(0, "Parameter %d, kind '%s', type '%d'",n,kind,ikind );
vevo_property_set( param, "HOST_kind", VEVO_ATOM_TYPE_INT,1,&ikind );
void *vje_port = vevo_port_new( VEVO_VJE_PORT );
vevo_property_set( plugger_port, key, LIVIDO_ATOM_TYPE_PORTPTR,1, &vje_port );
free(kind);
}
return NP;
}
static int livido_scan_parameters( void *plugin, void *plugger_port ) static int livido_scan_parameters( void *plugin, void *plugger_port )
{ {
int n = 0; int n = 0;
@@ -265,7 +328,7 @@ static int livido_scan_parameters( void *plugin, void *plugger_port )
tmp[0] = 0; tmp[1] = 1; tmp[0] = 0; tmp[1] = 1;
vevo_property_set(vje_port, "min", VEVO_ATOM_TYPE_BOOL,1, &tmp[0] ); vevo_property_set(vje_port, "min", VEVO_ATOM_TYPE_BOOL,1, &tmp[0] );
vevo_property_set(vje_port, "max", VEVO_ATOM_TYPE_BOOL,1, &tmp[1] ); vevo_property_set(vje_port, "max", VEVO_ATOM_TYPE_BOOL,1, &tmp[1] );
} else if (strcasecmp(kind, "COORDINATE" ) == 0 ) { } else if (strcasecmp(kind, "COORD" ) == 0 ) {
ikind = HOST_PARAM_COORD; vj_np += 2; ikind = HOST_PARAM_COORD; vj_np += 2;
dtmp[0] = 0.0; dtmp[1] = 0.0; dtmp[0] = 0.0; dtmp[1] = 0.0;
vevo_property_set(vje_port, "min", VEVO_ATOM_TYPE_DOUBLE,1, &dtmp[0] ); vevo_property_set(vje_port, "min", VEVO_ATOM_TYPE_DOUBLE,1, &dtmp[0] );
@@ -292,7 +355,9 @@ static int livido_scan_parameters( void *plugin, void *plugger_port )
#endif #endif
} }
vevo_property_set( param, "HOST_kind", VEVO_ATOM_TYPE_INT,1,&ikind ); vevo_property_set( param, "HOST_kind", VEVO_ATOM_TYPE_INT,1,&ikind );
vevo_property_set( vje_port, "HOST_kind", VEVO_ATOM_TYPE_INT,1,&ikind ); vevo_property_set( vje_port, "HOST_kind", VEVO_ATOM_TYPE_INT,1,&ikind );
free(kind);
} }
return vj_np; return vj_np;
@@ -304,8 +369,10 @@ static int init_parameter_port(livido_port_t *ptr, livido_port_t *in_param )
int error = vevo_property_get( ptr, "HOST_kind", 0, &kind ); int error = vevo_property_get( ptr, "HOST_kind", 0, &kind );
if( error != VEVO_NO_ERROR ) if( error != VEVO_NO_ERROR )
{
veejay_msg(0, "\tProperty 'HOST_kind' not set in parameter");
return 0; return 0;
}
livido_set_parameter_f pctrl; livido_set_parameter_f pctrl;
switch(kind) switch(kind)
@@ -324,6 +391,7 @@ static int init_parameter_port(livido_port_t *ptr, livido_port_t *in_param )
pctrl = livido_plug_parameter_set_text; break; pctrl = livido_plug_parameter_set_text; break;
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
default: default:
veejay_msg(0, "Invalid kind : '%d'", kind );
return 0; return 0;
break; break;
#endif #endif
@@ -454,12 +522,19 @@ static int init_ports_from_template( livido_port_t *filter_instance, livido_port
if( id == LIVIDO_PORT_TYPE_CHANNEL ) if( id == LIVIDO_PORT_TYPE_CHANNEL )
{ {
if(!init_channel_port( ptr,in_channels[i],w,h)) if(!init_channel_port( ptr,in_channels[i],w,h))
{
veejay_msg(0,
"Unable to intialize output channel %d ",i );
return -1; return -1;
}
} }
else if( id == LIVIDO_PORT_TYPE_PARAMETER ) else if( id == LIVIDO_PORT_TYPE_PARAMETER )
{ {
if(!init_parameter_port( ptr, in_channels[i] )) if(!init_parameter_port( ptr, in_channels[i] ))
{
veejay_msg(0, "Unable to initialize output parameter %d", i);
return -1; return -1;
}
} }
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
else else
@@ -500,8 +575,11 @@ void *livido_plug_init(void *plugin,int w, int h )
w,h, 0); w,h, 0);
if( num_in_channels < 0 ) if( num_in_channels < 0 )
{
veejay_msg(0 ,"Not dealing with generator plugins yet");
return NULL; return NULL;
}
int num_out_channels = init_ports_from_template( int num_out_channels = init_ports_from_template(
filter_instance, filter_templ, filter_instance, filter_templ,
LIVIDO_PORT_TYPE_CHANNEL, LIVIDO_PORT_TYPE_CHANNEL,
@@ -509,8 +587,10 @@ void *livido_plug_init(void *plugin,int w, int h )
w,h, 0 ); w,h, 0 );
if( num_out_channels < 0 ) if( num_out_channels < 0 )
{
veejay_msg(0, "Require at least 1 output channel");
return NULL; return NULL;
}
int num_in_params = init_ports_from_template( int num_in_params = init_ports_from_template(
filter_instance, filter_templ, filter_instance, filter_templ,
LIVIDO_PORT_TYPE_PARAMETER, LIVIDO_PORT_TYPE_PARAMETER,
@@ -518,8 +598,10 @@ void *livido_plug_init(void *plugin,int w, int h )
w,h, 0 ); w,h, 0 );
if( num_in_params < 0 ) if( num_in_params < 0 )
{
veejay_msg(0, "Require at least 0 input parameter");
return NULL; return NULL;
}
int num_out_params = init_ports_from_template( int num_out_params = init_ports_from_template(
filter_instance, filter_templ, filter_instance, filter_templ,
LIVIDO_PORT_TYPE_PARAMETER, LIVIDO_PORT_TYPE_PARAMETER,
@@ -527,8 +609,11 @@ void *livido_plug_init(void *plugin,int w, int h )
w,h,0 ); w,h,0 );
if( num_out_params < 0 ) if( num_out_params < 0 )
{
veejay_msg(0, "Require at least 0 output parameters (%d)",
num_out_params);
return NULL; return NULL;
}
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
assert( num_in_params >= 0 ); assert( num_in_params >= 0 );
assert( num_out_params >= 0 ); assert( num_out_params >= 0 );
@@ -566,6 +651,10 @@ void *livido_plug_init(void *plugin,int w, int h )
vevo_property_set( filter_instance, "HOST_plugin_param_clone_f", VEVO_ATOM_TYPE_VOIDPTR,1,&gcc ); vevo_property_set( filter_instance, "HOST_plugin_param_clone_f", VEVO_ATOM_TYPE_VOIDPTR,1,&gcc );
generic_reverse_clone_parameter_f grc = livido_reverse_clone_parameter; generic_reverse_clone_parameter_f grc = livido_reverse_clone_parameter;
vevo_property_set( filter_instance, "HOST_plugin_param_reverse_f", VEVO_ATOM_TYPE_VOIDPTR,1,&grc ); vevo_property_set( filter_instance, "HOST_plugin_param_reverse_f", VEVO_ATOM_TYPE_VOIDPTR,1,&grc );
generic_reverse_clone_out_parameter_f gro = livido_plug_read_output_parameters;
vevo_property_set( filter_instance, "HOST_plugin_out_param_reverse_f", VEVO_ATOM_TYPE_VOIDPTR,1,&gro );
generic_deinit_f gin = livido_plug_deinit; generic_deinit_f gin = livido_plug_deinit;
vevo_property_set( filter_instance, "HOST_plugin_deinit_f", VEVO_ATOM_TYPE_VOIDPTR,1,&gin); vevo_property_set( filter_instance, "HOST_plugin_deinit_f", VEVO_ATOM_TYPE_VOIDPTR,1,&gin);
@@ -727,6 +816,7 @@ void livido_plug_read_output_parameters( void *instance, void *fx_values )
{ {
int np = vevo_property_num_elements( instance, "out_parameters" ); int np = vevo_property_num_elements( instance, "out_parameters" );
int i; int i;
for( i = 0; i < np ; i ++ ) for( i = 0; i < np ; i ++ )
{ {
char vkey[10]; char vkey[10];
@@ -739,6 +829,8 @@ void livido_plug_read_output_parameters( void *instance, void *fx_values )
#endif #endif
sprintf(vkey, "p%02d", i ); sprintf(vkey, "p%02d", i );
clone_prop_vevo( param, fx_values, "value", vkey ); clone_prop_vevo( param, fx_values, "value", vkey );
} }
} }
@@ -884,6 +976,9 @@ void* deal_with_livido( void *handle, const char *name )
#endif #endif
int n_params = livido_scan_parameters( filter_templ, port ); int n_params = livido_scan_parameters( filter_templ, port );
int n_oparams = livido_scan_out_parameters( filter_templ, port );
//@ p%02d is a key with a portptr value. it contains min,max,defaults for each plugin setup() //@ p%02d is a key with a portptr value. it contains min,max,defaults for each plugin setup()
int is_mix = 0; int is_mix = 0;
int n_inputs = livido_property_num_elements( filter_templ, "in_channel_templates" ); int n_inputs = livido_property_num_elements( filter_templ, "in_channel_templates" );
@@ -899,6 +994,7 @@ void* deal_with_livido( void *handle, const char *name )
veejay_msg(0, "Livido plugin '%s'", plugin_name ); veejay_msg(0, "Livido plugin '%s'", plugin_name );
vevo_property_set( port, "num_params", VEVO_ATOM_TYPE_INT, 1, &n_params ); vevo_property_set( port, "num_params", VEVO_ATOM_TYPE_INT, 1, &n_params );
vevo_property_set( port, "num_out_params", VEVO_ATOM_TYPE_INT,1,&n_oparams );
vevo_property_set( port, "name", VEVO_ATOM_TYPE_STRING,1, &clone_name ); vevo_property_set( port, "name", VEVO_ATOM_TYPE_STRING,1, &clone_name );
vevo_property_set( port, "num_inputs", VEVO_ATOM_TYPE_INT,1, &n_inputs); vevo_property_set( port, "num_inputs", VEVO_ATOM_TYPE_INT,1, &n_inputs);
vevo_property_set( port, "info", LIVIDO_ATOM_TYPE_PORTPTR,1,&filter_templ ); vevo_property_set( port, "info", LIVIDO_ATOM_TYPE_PORTPTR,1,&filter_templ );
@@ -907,6 +1003,8 @@ void* deal_with_livido( void *handle, const char *name )
free(clone_name); free(clone_name);
free(plugin_name); free(plugin_name);
veejay_msg(0, "Input:%d, Output; %d", n_params, n_oparams );
return port; return port;
} }

14
veejay-ng/libplugger/plugload.c
View File

@@ -450,19 +450,13 @@ void plug_clone_from_output_parameters( void *instance, void *fx_values )
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
assert( instance != NULL ); assert( instance != NULL );
#endif #endif
int type = 0; generic_reverse_clone_out_parameter_f grc;
int error = vevo_property_get( instance, "HOST_plugin_type", 0, &type); int error = vevo_property_get( instance, "HOST_plugin_out_param_reverse_f", 0, &grc );
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
assert( error == VEVO_NO_ERROR ); assert( error == VEVO_NO_ERROR );
#endif #endif
switch( type ) (*grc)(instance,fx_values);
{ /// livido_plug_read_output_parameters( instance, fx_values );
case VEVO_PLUG_LIVIDO:
livido_plug_read_output_parameters( instance, fx_values );
break;
default:
break;
}
} }
void plug_clone_parameters( void *instance, void *fx_values ) void plug_clone_parameters( void *instance, void *fx_values )

43
veejay-ng/libvevo/vevo.c
View File

@@ -1915,6 +1915,49 @@ char *vevo_format_property( vevo_port_t *port, const char *key )
return res; return res;
} }
char *vevo_format_kind( vevo_port_t *port, const char *key )
{
char *res = NULL;
char token[5];
int atom_type = vevo_property_atom_type( port, key );
bzero(token,5);
switch( atom_type )
{
case VEVO_ATOM_TYPE_INT:
case VEVO_ATOM_TYPE_BOOL:
token[0] = 'd';
break;
case VEVO_ATOM_TYPE_UINT64:
token[0] = 'D';
break;
case VEVO_ATOM_TYPE_DOUBLE:
token[0] = 'g';
break;
case VEVO_ATOM_TYPE_STRING:
token[0] = 's';
break;
case VEVO_ATOM_TYPE_VOIDPTR:
token[0] = 'x';
break;
case VEVO_ATOM_TYPE_PORTPTR:
token[0] = 'p';
break;
default:
token[0] = 'g';
break;
}
if( token[0])
{
res = strdup( token );
}
return res;
}
const char *vevo_split_token_( const char *s, const char delim, char *buf, int buf_len ) const char *vevo_split_token_( const char *s, const char delim, char *buf, int buf_len )
{ {

6
veejay-ng/veejay/Makefile.am
View File

@@ -19,7 +19,7 @@ INCLUDES = -I$(top_srcdir) -I$(includedir) \
-I$(top_srcdir)/libvevo \ -I$(top_srcdir)/libvevo \
$(FFMPEG_CFLAGS)\ $(FFMPEG_CFLAGS)\
${XML_CFLAGS} ${DV_FLAGS} ${X_CFLAGS} ${XML_CPPFLAGS} \ ${XML_CFLAGS} ${DV_FLAGS} ${X_CFLAGS} ${XML_CPPFLAGS} \
${PTHREAD_CFLAGS} ${MJPEGTOOLS_CFLAGS} ${GL_CFLAGS} ${SDL_CFLAGS} ${PTHREAD_CFLAGS} ${MJPEGTOOLS_CFLAGS} ${GL_CFLAGS} ${SDL_CFLAGS} ${LIBLO_CFLAGS}
VEEJAY_LIB_FILE = libveejay.la VEEJAY_LIB_FILE = libveejay.la
@@ -35,6 +35,8 @@ libveejay_la_SOURCES = vj-misc.c \
gl.c vj-sdl.c \ gl.c vj-sdl.c \
vj-eventman.c \ vj-eventman.c \
vj-event.c \ vj-event.c \
oscsend.c \
oscservit.c \
liblavplayvj.c liblavplayvj.c
libveejay_la_LDFLAGS = $(VEEJAY_ALL_LIB_OPTS ) libveejay_la_LDFLAGS = $(VEEJAY_ALL_LIB_OPTS )
@@ -68,4 +70,4 @@ bin_PROGRAMS = $(VEEJAY_BIN)
veejay_SOURCES = veejay.c veejay_SOURCES = veejay.c
veejay_LDADD = libveejay.la @LIBGETOPT_LIB@ ${FFMPEG_AVCODEC_LIBS} ${FFMPEG_AVFORMAT_LIBS} \ veejay_LDADD = libveejay.la @LIBGETOPT_LIB@ ${FFMPEG_AVCODEC_LIBS} ${FFMPEG_AVFORMAT_LIBS} \
${PTHREAD_LIBS} ${XML_LIBS} ${LIBDV_LIBS} ${GL_LIBS} \ ${PTHREAD_LIBS} ${XML_LIBS} ${LIBDV_LIBS} ${GL_LIBS} \
${MJPEGTOOLS_LIBS} ${UNICAP_LIBS} ${LIBM_LIBS} ${SDL_LIBS} ${MJPEGTOOLS_LIBS} ${UNICAP_LIBS} ${LIBM_LIBS} ${SDL_LIBS} ${LIBLO_LIBS}

8
veejay-ng/veejay/liblavplayvj.c
View File

@@ -406,7 +406,7 @@ void veejay_signal_loop(void *arg)
\param arg info Veejay Object \param arg info Veejay Object
\return Error Code \return Error Code
*/ */
static int gl_ready_ = 0; //static int gl_ready_ = 0;
int veejay_push_results( veejay_t *info ) int veejay_push_results( veejay_t *info )
{ {
sample_video_info_t *vid_info = info->video_info; sample_video_info_t *vid_info = info->video_info;
@@ -424,6 +424,7 @@ int veejay_push_results( veejay_t *info )
vj_sdl_update_yuv_overlay( info->sdl_display, ref ); vj_sdl_update_yuv_overlay( info->sdl_display, ref );
break; break;
} }
performer_clean_output_frame( info );
return 1; return 1;
} }
@@ -691,6 +692,7 @@ void veejay_deinit(veejay_t *info)
vj_server_shutdown(info->status_socket); vj_server_shutdown(info->status_socket);
vj_server_shutdown(info->command_socket); vj_server_shutdown(info->command_socket);
vj_server_shutdown(info->frame_socket); vj_server_shutdown(info->frame_socket);
veejay_free_osc_server(info->osc_server );
vj_event_stop(); vj_event_stop();
samplebank_free(); samplebank_free();
plug_sys_free(); plug_sys_free();
@@ -1176,6 +1178,10 @@ int vj_server_setup(veejay_t * info)
if(!info->frame_socket) if(!info->frame_socket)
return 0; return 0;
const char port_str[50];
sprintf(port_str, "%d",port );
info->osc_server = veejay_new_osc_server( (void*)info, port_str );
// info->mcast_socket = // info->mcast_socket =
// vj_server_alloc(port, info->settings->vims_group_name, V_CMD ); // vj_server_alloc(port, info->settings->vims_group_name, V_CMD );
// GoMultiCast( info->settings->group_name ); // GoMultiCast( info->settings->group_name );

211
veejay-ng/veejay/oscsend.c Normal file
View File

@@ -0,0 +1,211 @@
/* veejay - Linux VeeJay
* (C) 2002-2006 Niels Elburg <nelburg@looze.net>
*
*
* 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 02139, USA.
*/
#include <config.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libvjmem/vjmem.h>
#include <libvjmsg/vj-common.h>
#include <libvevo/libvevo.h>
#include <lo/lo.h>
//@ client side implementation
#ifdef STRICT_CHECKING
#include <assert.h>
#endif
typedef struct
{
lo_address addr;
char *addr_str;
char *port_str;
} oscclient_t;
void *veejay_new_osc_sender( const char *addr, const char *port )
{
oscclient_t *osc = (oscclient_t*) vj_malloc(sizeof(oscclient_t));
osc->addr = lo_address_new( addr, port );
osc->addr_str = strdup( addr );
osc->port_str = port ? strdup( port ) : NULL;
return (void*) osc;
}
void veejay_free_osc_sender( void *dosc )
{
oscclient_t *osc = (oscclient_t*) dosc;
lo_address_free( osc->addr );
if( osc->port_str )
free( osc->port_str);
free(osc->addr_str);
free(osc);
osc = NULL;
}
static void veejay_add_arguments_ ( lo_message lmsg, const char *format, va_list ap )
{
//http://liblo.sourceforge.net/docs/group__liblolowlevel.html#g31ac1e4c0ec6c61f665ce3f9bbdc53c3
while( *format != 'x' )
{
switch(*format)
{
case 'i':
lo_message_add_int32( lmsg, (int32_t) *(va_arg( ap, int*)));
break;
case 'h':
lo_message_add_int64( lmsg, (int64_t) *(va_arg( ap, int64_t*)));
break;
case 'c':
lo_message_add_string( lmsg, (char*) va_arg( ap, char*) );
break;
case 'f':
lo_message_add_float( lmsg, (float) *(va_arg( ap, float*)));
break;
case 'd':
lo_message_add_double( lmsg, (double) *(va_arg(ap, double*)));
break;
default:
#ifdef STRICT_CHECKING
assert(0);
#endif
break;
}
*format ++;
}
}
int veejay_send_osc( void *osc ,const char *msg, const char *format, ... )
{
oscclient_t *c = (oscclient_t*) osc;
lo_message lmsg = lo_message_new();
va_list ap;
va_start( ap, format );
veejay_add_arguments_( lmsg, format, ap );
va_end(ap);
int result = lo_send_message( c->addr, msg, lmsg );
lo_message_free( lmsg );
return result;
}
static int _vevo_get_int( void *port, const char *key, int n_elem, lo_message lmsg )
{
int32_t *values = NULL;
if( n_elem == 0 )
return VEVO_NO_ERROR;
values = (int32_t*) vj_malloc(sizeof(int32_t) * n_elem );
int i;
int error;
for( i = 0; i < n_elem; i ++ )
{
error = vevo_property_get( port, key, i, &(values[i]));
#ifdef STRICT_CHECKING
assert( error == VEVO_NO_ERROR );
#endif
lo_message_add_int32( lmsg, values[i]);
}
return VEVO_NO_ERROR;
}
static int _vevo_get_dbl( void *port, const char *key, int n_elem, lo_message lmsg )
{
double *values = NULL;
if( n_elem == 0 )
return VEVO_NO_ERROR;
values = (double*) vj_malloc(sizeof(double) * n_elem );
int i;
int error;
for( i = 0; i < n_elem; i ++ )
{
error = vevo_property_get( port, key, i, &(values[i]));
#ifdef STRICT_CHECKING
assert( error == VEVO_NO_ERROR );
#endif
lo_message_add_double( lmsg, values[i]);
}
return VEVO_NO_ERROR;
}
int veejay_vevo_send_osc( void *osc, const char *msg, void *vevo_port )
{
char **keys = vevo_list_properties( vevo_port );
int i;
#ifdef STRICT_CHECKING
assert( keys != NULL );
#endif
lo_message lmsg = lo_message_new();
oscclient_t *c = (oscclient_t*) osc;
for ( i = 0; keys[i] != NULL; i ++ )
{
char *format = vevo_format_kind( vevo_port, keys[i] );
#ifdef STRICT_CHECKING
assert( format != NULL );
#endif
int n_elems = vevo_property_num_elements( vevo_port, keys[i] );
while( *format )
{
switch(*format)
{
case 'd':
_vevo_get_int( vevo_port, keys[i], n_elems, lmsg );
break;
case 'g':
_vevo_get_dbl( vevo_port, keys[i], n_elems, lmsg );
break;
default:
#ifdef STRICT_CHECKING
assert(0);
#endif
break;
}
*format++;
}
free(keys[i]);
}
free(keys);
int result = lo_send_message( c->addr, msg, lmsg );
lo_message_free( lmsg );
if( result == -1)
return VEVO_ERROR_HARDWARE; //@ long live bogus error codes
return VEVO_NO_ERROR;
}

25
veejay-ng/veejay/oscsend.h Normal file
View File

@@ -0,0 +1,25 @@
#ifndef OSC_CLIENT_H
#define OSC_CLIENT_H
/* veejay - Linux VeeJay
* (C) 2002-2006 Niels Elburg <nelburg@looze.net>
*
*
* 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 02139, USA.
*/
void *veejay_new_osc_sender( const char *addr, const char *port );
void veejay_free_osc_sender( void *dosc );
int veejay_send_osc( void *osc ,const char *msg, const char *format, ... );
int veejay_vevo_send_osc( void *osc, const char *msg, void *vevo_port );
#endif

255
veejay-ng/veejay/oscservit.c Normal file
View File

@@ -0,0 +1,255 @@
#ifndef OSC_SERVER_H
#define OSC_SERVER_H
/* veejay - Linux VeeJay
* (C) 2002-2006 Niels Elburg <nelburg@looze.net>
*
*
* 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 02139, USA.
*/
#include <config.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libvjmem/vjmem.h>
#include <libvjmsg/vj-common.h>
#include <libvevo/libvevo.h>
#include <veejay/vims.h>
#include <veejay/veejay.h>
#include <lo/lo.h>
//@ client side implementation
#ifdef STRICT_CHECKING
#include <assert.h>
#endif
#include <veejay/oscservit.h>
typedef struct
{
lo_server_thread st;
void *events;
} osc_recv_t;
static struct
{
const char *path;
int id;
} osc_paths_[] = {
{ "/sample/new", VIMS_SAMPLE_NEW },
{ "/sample/select", VIMS_SAMPLE_SELECT },
{ "/sample/del", VIMS_SAMPLE_DEL },
{ "/sample/set/properties", VIMS_SAMPLE_SET_PROPERTIES },
{ "/load/samplelist", VIMS_SAMPLE_LOAD },
{ "/save/samplelist", VIMS_SAMPLE_SAVE },
{ "/sample/rec/start", VIMS_SAMPLE_START_RECORDER },
{ "/sample/rec/stop", VIMS_SAMPLE_STOP_RECORDER },
{ "/sample/rec/configure", VIMS_SAMPLE_CONFIGURE_RECORDER },
{ "/sample/set/volume", VIMS_SAMPLE_SET_VOLUME },
{ "/sample/fxc/active", VIMS_SAMPLE_CHAIN_ACTIVE },
{ "/sample/edl/paste_at", VIMS_SAMPLE_EDL_PASTE_AT },
{ "/sample/edl/copy", VIMS_SAMPLE_EDL_COPY },
{ "/sample/edl/del", VIMS_SAMPLE_EDL_DEL },
{ "/sample/edl/crop", VIMS_SAMPLE_EDL_CROP },
{ "/sample/edl/cut", VIMS_SAMPLE_EDL_CUT },
{ "/sample/edl/append", VIMS_SAMPLE_EDL_ADD },
{ "/sample/edl/export", VIMS_SAMPLE_EDL_EXPORT },
{ "/sample/edl/load", VIMS_SAMPLE_EDL_LOAD },
{ "/sample/edl/save", VIMS_SAMPLE_EDL_SAVE },
{ "/sample/chain/clear", VIMS_SAMPLE_CHAIN_CLEAR },
{ "/sample/chain/entry/select", VIMS_SAMPLE_CHAIN_SET_ENTRY },
{ "/sample/chain/entry/set", VIMS_SAMPLE_CHAIN_ENTRY_SET_FX },
{ "/sample/chain/entry/preset", VIMS_SAMPLE_CHAIN_ENTRY_SET_PRESET },
{ "/sample/chain/entry/active", VIMS_SAMPLE_CHAIN_ENTRY_SET_ACTIVE },
{ "/sample/chain/entry/value", VIMS_SAMPLE_CHAIN_ENTRY_SET_VALUE },
{ "/sample/chain/entry/channel", VIMS_SAMPLE_CHAIN_ENTRY_SET_INPUT },
{ "/sample/chain/entry/alpha", VIMS_SAMPLE_CHAIN_ENTRY_SET_ALPHA },
{ "/sample/chain/entry/clear", VIMS_SAMPLE_CHAIN_ENTRY_CLEAR },
{ "/sample/chain/entry/state", VIMS_SAMPLE_CHAIN_ENTRY_SET_STATE },
{ "/sample/chain/entry/bind", VIMS_SAMPLE_ATTACH_OUT_PARAMETER },
{ "/sample/chain/entry/release", VIMS_SAMPLE_DETACH_OUT_PARAMETER },
{ "/sample/chain/entry/register_osc_path", VIMS_SAMPLE_BIND_OUTP_OSC },
{ "/sample/chain/entry/unregister_osc_path",VIMS_SAMPLE_RELEASE_OUTP_OSC },
{ "/sample/register_osc_client", VIMS_SAMPLE_OSC_START },
{ "/sample/unregister_osc_client", VIMS_SAMPLE_OSC_STOP },
{ "/samplebank/add", VIMS_SAMPLEBANK_ADD },
{ "/samplebank/del", VIMS_SAMPLEBANK_DEL },
{ "/play", VIMS_SAMPLE_PLAY_FORWARD },
{ "/reverse", VIMS_SAMPLE_PLAY_BACKWARD },
{ "/pause", VIMS_SAMPLE_PLAY_STOP },
{ "/skip", VIMS_SAMPLE_SKIP_FRAME },
{ "/prev", VIMS_SAMPLE_PREV_FRAME },
{ "/up", VIMS_SAMPLE_SKIP_SECOND },
{ "/down", VIMS_SAMPLE_PREV_SECOND },
{ "/start", VIMS_SAMPLE_GOTO_START },
{ "/end", VIMS_SAMPLE_GOTO_END },
{ "/frame", VIMS_SAMPLE_SET_FRAME },
{ "/speed", VIMS_SAMPLE_SET_SPEED },
{ "/slow", VIMS_SAMPLE_SET_SLOW },
{ "/fullscreen", VIMS_FULLSCREEN },
{ "/audio", VIMS_AUDIO_SET_ACTIVE },
{ "/resize", VIMS_RESIZE_SCREEN },
{ NULL, 0 }
};
void error_handler( int num, const char *msg, const char *path )
{
veejay_msg(0,"Liblo server error %d in path %s: %s",num,path,msg );
}
typedef void (*osc_event)(void *ptr, const char format[], va_list ap);
static char *vevo_str_to_liblo( const char *format )
{
int n = strlen(format);
if( n <= 0 )
return NULL;
char *res = (char*) malloc( n );
int k = 0;
bzero(res,n );
while(*format)
{
if(*format=='d' || *format=='s')
res[k++] = (*format == 'd' ? 'i' : 's');
*format++;
}
return res;
}
int generic_handler( const char *path, const char *types,
lo_arg **argv, int argc, void *data, void *user_data )
{
int vims_id = 0;
int args[16];
double gargs[16];
char *str[16];
int i;
int n = 0;
int s = 0;
int g = 0;
veejay_t *info = (veejay_t*) user_data;
osc_recv_t *st = (osc_recv_t*) info->osc_server;
int error = vevo_property_get( st->events, path,0, &vims_id );
memset(str, 0, sizeof(str));
if( vims_id == 0 || error != VEVO_NO_ERROR)
{
veejay_msg(0, "OSC path '%s' does not exist", path );
return 0;
}
int vims_args = vj_event_vevo_get_num_args( vims_id );
char *format = vj_event_vevo_get_event_format( vims_id );
for( i = 0; i < argc ; i ++ )
{
switch(types[i])
{
case 'i':
args[n++] = argv[i]->i32;
break;
case 's':
str[s++] = strdup( (char*) &argv[i]->s );
break;
case 'd':
gargs[g++] = argv[i]->d;
break;
default:
veejay_msg(0, "Skipping unknown argument type '%c' ",
types[i]);
break;
}
}
if( vims_args != (n + s) )
{
char *name = vj_event_vevo_get_event_name( vims_id );
char *loarg = vevo_str_to_liblo(format);
veejay_msg(0, "Wrong number of arguments for VIMS %d (%s)", vims_id, name);
veejay_msg(0, "FORMAT is '%s' but I received '%s'", loarg, types );
free(name);
if(loarg) free(loarg);
}
else
{
vj_event_fire_net_event( info,
vims_id,
str[0],
args,
n + s,
0,
gargs,
g );
}
if(format)
free(format);
for( i = 0; i < 16 ; i ++ )
if( str[i] )
free(str[i]);
return 0;
}
void *veejay_new_osc_server( void *data, const char *port )
{
osc_recv_t *s = (osc_recv_t*) vj_malloc(sizeof( osc_recv_t));
s->st = lo_server_thread_new( port, error_handler );
s->events = vevo_port_new( VEVO_ANONYMOUS_PORT );
int i;
for( i =0; osc_paths_[i].path != NULL ; i ++ )
{
int error =
vevo_property_set( s->events, osc_paths_[i].path, VEVO_ATOM_TYPE_INT,1,
&(osc_paths_[i].id) );
lo_server_thread_add_method(
s->st,
NULL,
NULL,
generic_handler,
data );
veejay_msg(0, "Added '%s", osc_paths_[i].path );
}
lo_server_thread_start( s->st );
veejay_msg( 0, "OSC server ready at UDP port %d", lo_server_thread_get_port(s->st) );
return (void*) s;
}
void veejay_free_osc_server( void *dosc )
{
osc_recv_t *s = (osc_recv_t*) dosc;
lo_server_thread_stop( s->st );
vevo_port_free( s->events );
free(s);
s = NULL;
}
#endif

23
veejay-ng/veejay/oscservit.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef OSC_SERVER_H
#define OSC_SERVER_H
/* veejay - Linux VeeJay
* (C) 2002-2006 Niels Elburg <nelburg@looze.net>
*
*
* 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 02139, USA.
*/
void *veejay_new_osc_server( void *data, const char *port );
void veejay_free_osc_server( void *dosc );
#endif

9
veejay-ng/veejay/performer.c
View File

@@ -474,6 +474,15 @@ void *performer_get_output_frame( veejay_t *info )
// return res; // return res;
} }
void performer_clean_output_frame( veejay_t *info )
{
performer_t *p = (performer_t*) info->performer;
memset( p->display->data[0],0,p->display->len );
memset( p->display->data[1],128,p->display->uv_len );
memset( p->display->data[2],128,p->display->uv_len );
}
//! Queue sufficient audio samples for immediate playback //! Queue sufficient audio samples for immediate playback
/**! /**!
\param info Veejay Object \param info Veejay Object

1
veejay-ng/veejay/veejay.h
View File

@@ -119,6 +119,7 @@ typedef struct
void *command_socket; void *command_socket;
void *frame_socket; void *frame_socket;
void *mcast_socket; void *mcast_socket;
void *osc_server;
int current_link; int current_link;
int port_offset; int port_offset;

12
veejay-ng/veejay/vims.h
View File

@@ -108,9 +108,15 @@ enum {
VIMS_SAMPLE_CHAIN_ENTRY_SET_STATE = 377, VIMS_SAMPLE_CHAIN_ENTRY_SET_STATE = 377,
VIMS_SAMPLE_ATTACH_OUT_PARAMETER = 378, VIMS_SAMPLE_ATTACH_OUT_PARAMETER = 378,
VIMS_SAMPLE_DETACH_OUT_PARAMETER = 379, VIMS_SAMPLE_DETACH_OUT_PARAMETER = 379,
VIMS_SAMPLE_CONFIGURE_RECORDER = 380,
VIMS_SAMPLE_START_RECORDER = 381, VIMS_SAMPLE_BIND_OUTP_OSC = 380,
VIMS_SAMPLE_STOP_RECORDER = 382, VIMS_SAMPLE_RELEASE_OUTP_OSC = 381,
VIMS_SAMPLE_OSC_START = 382,
VIMS_SAMPLE_OSC_STOP = 383,
VIMS_SAMPLE_CONFIGURE_RECORDER = 390,
VIMS_SAMPLE_START_RECORDER = 391,
VIMS_SAMPLE_STOP_RECORDER = 392,
VIMS_PERFORMER_SETUP_PREVIEW = 400, VIMS_PERFORMER_SETUP_PREVIEW = 400,
VIMS_PERFORMER_GET_PREVIEW = 401, VIMS_PERFORMER_GET_PREVIEW = 401,

143
veejay-ng/veejay/vj-event.c
View File

@@ -113,7 +113,32 @@ vj_server_send(v->frame_socket, v->current_link,str,strlen(str));\
} }
/* some macros for commonly used checks */ /* some macros for commonly used checks */
#define P_Ag(a,b,c,d,g)\
{\
int __z = 0;\
int __y = 0;\
unsigned char *__tmpstr = NULL;\
if(a!=NULL){\
unsigned int __rp;\
unsigned int __rplen = (sizeof(a) / sizeof(int) );\
for(__rp = 0; __rp < __rplen; __rp++) { a[__rp] = 0; g[__rp] = 0; }\
}\
while(*c) { \
if( (__z+__y) > _last_known_num_args ) break; \
switch(*c++) {\
case 's':\
__tmpstr = (char*)va_arg(d,char*);\
if(__tmpstr != NULL) {\
sprintf( b,"%s",__tmpstr);\
}\
__z++ ;\
break;\
case 'd': a[__z] = *( va_arg(d, int*)); __z++ ;\
break; }\
case 'g': g[__y] = *( va_arg(d, double*)); __y++;\
break; }\
}\
}
#define P_A(a,b,c,d)\ #define P_A(a,b,c,d)\
{\ {\
@@ -205,7 +230,7 @@ void vj_event_print_sample_info(veejay_t *v, int id);
//vj_msg_bundle *vj_event_bundle_new(char *bundle_msg, int event_id); //vj_msg_bundle *vj_event_bundle_new(char *bundle_msg, int event_id);
void vj_event_trigger_function(void *ptr, vj_event f, int max_args, const char format[], ...); void vj_event_trigger_function(void *ptr, vj_event f, int max_args, const char format[], ...);
//void vj_event_parse_bundle(veejay_t *v, char *msg ); //void vj_event_parse_bundle(veejay_t *v, char *msg );
void vj_event_fire_net_event(veejay_t *v, int net_id, char *str_arg, int *args, int arglen, int type); void vj_event_fire_net_event(veejay_t *v, int net_id, char *str_arg, int *args, int arglen, int type, double *gargs, int ng);
void vj_event_commit_bundle( veejay_t *v, int key_num, int key_mod); void vj_event_commit_bundle( veejay_t *v, int key_num, int key_mod);
#ifdef HAVE_XML2 #ifdef HAVE_XML2
@@ -468,7 +493,7 @@ static int vj_event_verify_args( int *fx, int net_id , int arglen, int np, int p
return 1; return 1;
} }
void vj_event_fire_net_event(veejay_t *v, int net_id, char *str_arg, int *args, int arglen, int prefixed) void vj_event_fire_net_event(veejay_t *v, int net_id, char *str_arg, int *args, int iarglen, int prefixed, double *gargs, int garglen)
{ {
int np = vj_event_vevo_get_num_args(net_id); int np = vj_event_vevo_get_num_args(net_id);
char *fmt = vj_event_vevo_get_event_format( net_id ); char *fmt = vj_event_vevo_get_event_format( net_id );
@@ -477,27 +502,24 @@ void vj_event_fire_net_event(veejay_t *v, int net_id, char *str_arg, int *args,
vims_arg_t vims_arguments[16]; vims_arg_t vims_arguments[16];
memset( vims_arguments, 0, sizeof(vims_arguments) ); memset( vims_arguments, 0, sizeof(vims_arguments) );
if(!vj_event_verify_args(args , net_id, arglen, np, prefixed, fmt ))
{
if(fmt) free(fmt);
return;
}
if( np == 0 ) if( np == 0 )
{ {
vj_event_vevo_inline_fire( (void*) v, net_id,NULL,NULL ); vj_event_vevo_inline_fire( (void*) v, net_id,NULL,NULL );
//vj_event_vevo_inline_fire_default( (void*) v, net_id, fmt );
//if(fmt) free(fmt);
return; return;
} }
int i=0; int i=0;
int arglen = iarglen + garglen;
while( i < arglen ) while( i < arglen )
{ {
if( fmt[fmt_offset] == 'd' ) if( fmt[fmt_offset] == 'd' )
{ {
vims_arguments[i].value = (void*) &(args[i]); vims_arguments[i].value = (void*) &(args[i]);
} }
if( fmt[fmt_offset] == 'g' )
{
vims_arguments[i].value = (void*) &(gargs[i]);
}
if( fmt[fmt_offset] == 's' ) if( fmt[fmt_offset] == 's' )
{ {
if(str_arg == NULL ) if(str_arg == NULL )
@@ -567,6 +589,18 @@ void vj_event_fire_net_event(veejay_t *v, int net_id, char *str_arg, int *args,
} }
static int inline_str_to_dbl(const char *msg, double *val)
{
char longest_num[16];
int str_len = 0;
if( sscanf( msg , "%g", val ) <= 0 )
return 0;
bzero( longest_num, 16 );
sprintf(longest_num, "%d", *val );
str_len = strlen( longest_num );
return str_len;
}
static int inline_str_to_int(const char *msg, int *val) static int inline_str_to_int(const char *msg, int *val)
{ {
char longest_num[16]; char longest_num[16];
@@ -734,7 +768,7 @@ int vj_event_parse_msg( veejay_t * v, char *msg )
i_args[i] = vj_event_vevo_get_default_value( net_id, i ); i_args[i] = vj_event_vevo_get_default_value( net_id, i );
i++; i++;
} }
vj_event_fire_net_event( v, net_id, NULL, i_args, np, 0 ); vj_event_fire_net_event( v, net_id, NULL, i_args, np, 0, NULL,0 );
} }
else else
{ {
@@ -742,7 +776,11 @@ int vj_event_parse_msg( veejay_t * v, char *msg )
char *fmt = vj_event_vevo_get_event_format( net_id ); char *fmt = vj_event_vevo_get_event_format( net_id );
int flags = vj_event_vevo_get_flags( net_id ); int flags = vj_event_vevo_get_flags( net_id );
int i = 0; int i = 0;
int ng = 0;
int ni = 0;
int ns = 0;
int i_args[16]; int i_args[16];
double g_args[16];
char *str = NULL; char *str = NULL;
int fmt_offset = 1; int fmt_offset = 1;
char *arg_str = NULL; char *arg_str = NULL;
@@ -776,12 +814,13 @@ int vj_event_parse_msg( veejay_t * v, char *msg )
if( fmt[fmt_offset] == 'd' ) if( fmt[fmt_offset] == 'd' )
{ {
int il = inline_str_to_int( arguments, &i_args[i] ); int il = inline_str_to_int( arguments, &i_args[ni] );
if( il > 0 ) if( il > 0 )
{ {
failed_arg = 0; failed_arg = 0;
arguments += il; arguments += il;
} }
ni ++;
} }
if( fmt[fmt_offset] == 's' && str == NULL) if( fmt[fmt_offset] == 's' && str == NULL)
{ {
@@ -791,8 +830,18 @@ int vj_event_parse_msg( veejay_t * v, char *msg )
failed_arg = 0; failed_arg = 0;
arguments += strlen(str); arguments += strlen(str);
} }
ns ++;
}
if( fmt[fmt_offset] == 'g' )
{
int il = inline_str_to_dbl( arguments, &g_args[ng]);
if( il > 0 )
{
failed_arg = 0;
arguments += il;
}
ng ++;
} }
if( failed_arg ) if( failed_arg )
{ {
char *name = vj_event_vevo_get_event_name( net_id ); char *name = vj_event_vevo_get_event_name( net_id );
@@ -817,7 +866,7 @@ int vj_event_parse_msg( veejay_t * v, char *msg )
if( flags & VIMS_ALLOW_ANY ) if( flags & VIMS_ALLOW_ANY )
i = np; i = np;
vj_event_fire_net_event( v, net_id, str, i_args, i, 0 ); vj_event_fire_net_event( v, net_id, str, i_args, ni + ns, 0, g_args,ng );
if(fmt) free(fmt); if(fmt) free(fmt);
@@ -1553,6 +1602,8 @@ void vj_event_chain_entry_set_input( void *ptr, const char format[], va_list ap
veejay_msg(VEEJAY_MSG_ERROR, "Error setting input channel"); veejay_msg(VEEJAY_MSG_ERROR, "Error setting input channel");
} }
} }
void vj_event_chain_entry_set_parameter_value( void *ptr, const char format[], va_list ap ) void vj_event_chain_entry_set_parameter_value( void *ptr, const char format[], va_list ap )
{ {
int args[4]; int args[4];
@@ -1580,7 +1631,6 @@ void vj_event_chain_entry_set_parameter_value( void *ptr, const char format[],
} }
} }
void vj_event_chain_entry_set_active( void *ptr, const char format[], va_list ap ) void vj_event_chain_entry_set_active( void *ptr, const char format[], va_list ap )
{ {
int args[4]; int args[4];
@@ -1947,3 +1997,64 @@ void vj_event_sample_stop_recorder( void *ptr, const char format[], va_list ap )
veejay_msg(2, "Stopped sample recorder. File is written"); veejay_msg(2, "Stopped sample recorder. File is written");
} }
} }
void vj_event_sample_bind_outp_osc( void *ptr, const char format[], va_list ap )
{
int args[2];
veejay_t *v = (veejay_t*) ptr;
char s[1024];
P_A(args, s, format, ap);
void *sample = which_sample( v, args );
if(sample)
{
sample_add_osc_path( sample, s, args[1] );
}
}
void vj_event_sample_release_outp_osc( void *ptr, const char format[], va_list ap)
{
int args[2];
veejay_t *v = (veejay_t*) ptr;
char *s = NULL;
P_A(args, s, format, ap);
void *sample = which_sample( v, args );
if(sample)
{
sample_del_osc_path( sample, args[1] );
}
}
void vj_event_sample_start_osc_sender( void *ptr, const char format[], va_list ap )
{
int args[2];
veejay_t *v = (veejay_t*) ptr;
char s[1024];
char port[50];
P_A(args, s, format, ap);
sprintf(port,"%d", args[1]);
void *sample = which_sample( v, args );
if(sample)
{
sample_new_osc_sender( sample, s, port );
}
}
void vj_event_sample_stop_osc_sender( void *ptr, const char format[], va_list ap )
{
int args[2];
veejay_t *v = (veejay_t*) ptr;
char *s = NULL;
P_A(args, s, format, ap);
void *sample = which_sample( v, args );
if(sample)
{
sample_close_osc_sender( sample );
}
}

52
veejay-ng/veejay/vj-event.h
View File

@@ -69,32 +69,30 @@ void vj_event_sample_new ( void *ptr, const char format[], va_list ap );
void vj_event_quit ( void *ptr, const char format[], va_list ap ); void vj_event_quit ( void *ptr, const char format[], va_list ap );
void vj_event_set_volume ( void *ptr, const char format[], va_list ap ); void vj_event_set_volume ( void *ptr, const char format[], va_list ap );
void vj_event_debug_level ( void *ptr, const char format[], va_list ap ); void vj_event_debug_level ( void *ptr, const char format[], va_list ap );
void vj_event_bezerk ( void *ptr, const char format[], va_list ap ); void vj_event_bezerk ( void *ptr, const char format[], va_list ap );
void vj_event_fullscreen ( void *ptr, const char format[], va_list ap ); void vj_event_fullscreen ( void *ptr, const char format[], va_list ap );
void vj_event_chain_entry_set_active ( void *ptr, const char format[], va_list ap );
void vj_event_chain_entry_set_active( void *ptr, const char format[], va_list ap ); void vj_event_chain_entry_set ( void *ptr, const char format[], va_list ap );
void vj_event_chain_entry_set(void *ptr, const char format[], va_list ap); void vj_event_chain_entry_clear ( void *ptr, const char format[], va_list ap );
void vj_event_chain_entry_clear( void *ptr, const char format[], va_list ap ); void vj_event_chain_entry_set_parameter_value( void *ptr, const char format[], va_list ap );
void vj_event_chain_entry_set_parameter_value( void *ptr, const char format[], va_list ap ); void vj_event_chain_entry_set_input ( void *ptr, const char format[], va_list ap );
void vj_event_chain_entry_set_input( void *ptr, const char format[], va_list ap ); void vj_event_chain_entry_set_alpha ( void *ptr, const char format[], va_list ap );
void vj_event_chain_entry_set_alpha( void *ptr, const char format[], va_list ap); void vj_event_sample_attach_out_parameter ( void *ptr, const char format[], va_list ap );
void vj_event_sample_detach_out_parameter ( void *ptr, const char format[], va_list ap );
void vj_event_sample_attach_out_parameter( void *ptr, const char format[], va_list ap ); void vj_event_sample_configure_recorder ( void *ptr, const char format[], va_list ap );
void vj_event_sample_detach_out_parameter( void *ptr, const char format[], va_list ap ); void vj_event_sample_start_recorder ( void *ptr, const char format[], va_list ap );
void vj_event_sample_stop_recorder ( void *ptr, const char format[], va_list ap );
void vj_event_sample_configure_recorder( void *ptr, const char format[], va_list ap ); void vj_event_performer_configure_preview ( void *ptr, const char format[], va_list ap );
void vj_event_sample_start_recorder( void *ptr, const char format[], va_list ap ); void vj_event_performer_get_preview_image ( void *ptr, const char format[], va_list ap );
void vj_event_sample_stop_recorder( void *ptr, const char format[], va_list ap ); void vj_event_samplebank_list ( void *ptr, const char format[], va_list ap );
void vj_event_samplebank_add ( void *ptr, const char format[], va_list ap );
void vj_event_performer_configure_preview( void *ptr, const char format[], va_list ap); void vj_event_samplebank_del ( void *ptr, const char format[], va_list ap );
void vj_event_performer_get_preview_image( void *ptr, const char format[], va_list ap); void vj_event_fx_list ( void *ptr, const char format[], va_list ap );
void vj_event_fx_info ( void *ptr, const char format[], va_list ap );
void vj_event_samplebank_list( void *ptr, const char format[], va_list ap ); void vj_event_sample_fx_details ( void *ptr, const char format[], va_list ap );
void vj_event_samplebank_add ( void *ptr, const char format[], va_list ap ); void vj_event_sample_fx_chain ( void *ptr, const char format[], va_list ap );
void vj_event_samplebank_del ( void *ptr, const char format[], va_list ap ); void vj_event_sample_bind_outp_osc ( void *ptr, const char format[], va_list ap );
void vj_event_fx_list ( void *ptr, const char format[], va_list ap ); void vj_event_sample_release_outp_osc ( void *ptr, const char format[], va_list ap );
void vj_event_fx_info ( void *ptr, const char format[], va_list ap ); void vj_event_sample_start_osc_sender ( void *ptr, const char format[], va_list ap );
void vj_event_sample_fx_details(void *ptr, const char format[], va_list ap); void vj_event_sample_stop_osc_sender ( void *ptr, const char format[], va_list ap );
void vj_event_sample_fx_chain( void *ptr, const char format[], va_list ap);
#endif #endif

62
veejay-ng/veejay/vj-eventman.c
View File

@@ -55,6 +55,7 @@ char *vj_event_vevo_help_vims( int id, int n );
int vj_event_vevo_get_default_value(int id, int p); int vj_event_vevo_get_default_value(int id, int p);
void vj_event_vevo_free(void); void vj_event_vevo_free(void);
static void dump_event_stderr(vevo_port_t *event) static void dump_event_stderr(vevo_port_t *event)
{ {
char *fmt = NULL; char *fmt = NULL;
@@ -209,7 +210,6 @@ static vevo_port_t *_new_event(
vevo_property_set( p, "arguments", VEVO_ATOM_TYPE_INT, 1, &n_arg ); vevo_property_set( p, "arguments", VEVO_ATOM_TYPE_INT, 1, &n_arg );
vevo_property_set( p, "flags", VEVO_ATOM_TYPE_INT, 1, &flags ); vevo_property_set( p, "flags", VEVO_ATOM_TYPE_INT, 1, &flags );
vevo_property_set( p, "vims_id", VEVO_ATOM_TYPE_INT, 1, &vims_id ); vevo_property_set( p, "vims_id", VEVO_ATOM_TYPE_INT, 1, &vims_id );
va_list ap; va_list ap;
va_start(ap, flags); va_start(ap, flags);
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
@@ -228,7 +228,7 @@ static vevo_port_t *_new_event(
sprintf(param_name, "argument_%d", n ); sprintf(param_name, "argument_%d", n );
const char *arg = va_arg( ap, const char*); const char *arg = va_arg( ap, const char*);
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
if(!arg) veejay_msg(VEEJAY_MSG_DEBUG, "\t%s - %d = '%s' of format %c (%s)",param_name, n, arg, format[it],format ); if(!arg) veejay_msg(0, "\t%s - %d = '%s' of format %c (%s)",param_name, n, arg, format[it],format );
assert( arg != NULL ); assert( arg != NULL );
#endif #endif
char *descr = (char*) strdup( arg ); char *descr = (char*) strdup( arg );
@@ -693,6 +693,36 @@ void vj_init_vevo_events(void)
-1, -1,
NULL ); NULL );
index_map_[VIMS_SAMPLE_BIND_OUTP_OSC] = _new_event(
"%d %d %s",
VIMS_SAMPLE_BIND_OUTP_OSC,
"Bind OSC path to fx output parameters",
vj_event_sample_bind_outp_osc,
3,
VIMS_LONG_PARAMS | VIMS_REQUIRE_ALL_PARAMS,
SAMPLE_ID_HELP,
0,
SAMPLE_FX_ENTRY_HELP,
0,
"OSC path",
NULL,
NULL );
index_map_[VIMS_SAMPLE_RELEASE_OUTP_OSC] = _new_event(
"%d %d",
VIMS_SAMPLE_RELEASE_OUTP_OSC,
"Release OSC path from fx output parameters",
vj_event_sample_release_outp_osc,
2,
VIMS_REQUIRE_ALL_PARAMS,
SAMPLE_ID_HELP,
0,
SAMPLE_FX_ENTRY_HELP,
0,
NULL );
index_map_[VIMS_SAMPLE_ATTACH_OUT_PARAMETER] = _new_event( index_map_[VIMS_SAMPLE_ATTACH_OUT_PARAMETER] = _new_event(
"%d %d %d %d %d", "%d %d %d %d %d",
VIMS_SAMPLE_ATTACH_OUT_PARAMETER, VIMS_SAMPLE_ATTACH_OUT_PARAMETER,
@@ -712,6 +742,34 @@ void vj_init_vevo_events(void)
-1, -1,
NULL ); NULL );
index_map_[VIMS_SAMPLE_OSC_START] = _new_event(
"%d %d %s",
VIMS_SAMPLE_OSC_START,
"Start new OSC sender",
vj_event_sample_start_osc_sender,
3,
VIMS_REQUIRE_ALL_PARAMS | VIMS_LONG_PARAMS,
SAMPLE_ID_HELP,
0,
"Port number",
0,
"Address",
NULL,
NULL );
index_map_[VIMS_SAMPLE_OSC_STOP] = _new_event(
"%d",
VIMS_SAMPLE_OSC_STOP,
"Stop OSC sender",
vj_event_sample_stop_osc_sender,
1,
VIMS_REQUIRE_ALL_PARAMS,
SAMPLE_ID_HELP,
0,
NULL );
index_map_[VIMS_PERFORMER_SETUP_PREVIEW] = _new_event( index_map_[VIMS_PERFORMER_SETUP_PREVIEW] = _new_event(
"%d %d", "%d %d",
VIMS_PERFORMER_SETUP_PREVIEW, VIMS_PERFORMER_SETUP_PREVIEW,

104
veejay-ng/vevosample/vevosample.c
View File

@@ -129,6 +129,7 @@ typedef struct
int type; /* type of sample */ int type; /* type of sample */
samplerecord_t *record; samplerecord_t *record;
sampleinfo_t *info; sampleinfo_t *info;
void *osc;
} sample_runtime_data; } sample_runtime_data;
@@ -205,6 +206,7 @@ static struct
{ "fx_values", VEVO_ATOM_TYPE_PORTPTR }, /* port of p0 .. pN, containing copy of fx parameter values */ { "fx_values", VEVO_ATOM_TYPE_PORTPTR }, /* port of p0 .. pN, containing copy of fx parameter values */
{ "fx_out_values", VEVO_ATOM_TYPE_PORTPTR }, /* output parmaters, p0 ... pN */ { "fx_out_values", VEVO_ATOM_TYPE_PORTPTR }, /* output parmaters, p0 ... pN */
{ "fx_channels", VEVO_ATOM_TYPE_PORTPTR }, /* contains list of sample pointers to use as input channels */ { "fx_channels", VEVO_ATOM_TYPE_PORTPTR }, /* contains list of sample pointers to use as input channels */
{ "fx_osc", VEVO_ATOM_TYPE_STRING }, /* osc message string (output)*/
}; };
/** /**
@@ -746,10 +748,12 @@ int sample_process_fx( void *sample, int fx_entry )
plug_clone_from_output_parameters( fx_instance, fx_out_values ); plug_clone_from_output_parameters( fx_instance, fx_out_values );
sample_apply_bind( sample, port ); sample_apply_bind( sample, port );
//@ send osc message if needed
sample_send_osc_path( sample, port );
return VEVO_NO_ERROR; return VEVO_NO_ERROR;
} }
@@ -1014,7 +1018,7 @@ static void sample_new_fx_chain_entry( void *sample, int id )
#endif #endif
void *fx_values = vevo_port_new( VEVO_FX_VALUES_PORT ); void *fx_values = vevo_port_new( VEVO_FX_VALUES_PORT );
void *fx_channels = vevo_port_new( VEVO_ANONYMOUS_PORT ); void *fx_channels = vevo_port_new( VEVO_ANONYMOUS_PORT );
void *fx_out_values = vevo_port_new( VEVO_FX_VALUES_PORT ); void *fx_out_values = vevo_port_new( VEVO_ANONYMOUS_PORT );
error = vevo_property_set( port, "fx_values", VEVO_ATOM_TYPE_PORTPTR,1,&fx_values); error = vevo_property_set( port, "fx_values", VEVO_ATOM_TYPE_PORTPTR,1,&fx_values);
#ifdef STRICT_CHECKING #ifdef STRICT_CHECKING
@@ -2403,6 +2407,11 @@ static int sample_sscanf_property( sample_runtime_data *srd ,vevo_port_t *port,
char *format = vevo_format_property( port, key ); char *format = vevo_format_property( port, key );
int atom = vevo_property_atom_type( port, key ); int atom = vevo_property_atom_type( port, key );
#ifdef STRICT_CHECKING
int n_elem = vevo_property_num_elements( port , key);
assert( n_elem == 1 ); // function not OK for arrays of atoms
#endif
if( format == NULL ) if( format == NULL )
return done; return done;
if(atom==-1) if(atom==-1)
@@ -2951,4 +2960,93 @@ int sample_apply_bind( void *sample, void *current_entry )
return 0; return 0;
} }
int sample_new_osc_sender(void *sample, const char *addr, const char *port )
{
sample_runtime_data *srd = (sample_runtime_data*) sample;
if(srd->osc)
{
veejay_msg(0, "There is already an OSC sender active");
return 1;
}
void *osc_client = veejay_new_osc_sender( addr, port );
if(!osc_client)
{
veejay_msg(0, "Unable to start OSC sender");
return 1;
}
srd->osc = osc_client;
veejay_msg(VEEJAY_MSG_INFO,
"OSC address '%s' port '%s', Sender active",
addr,port );
return VEVO_NO_ERROR;
}
void sample_close_osc_sender( void *sample )
{
sample_runtime_data *srd = (sample_runtime_data*) sample;
if(srd->osc)
{
veejay_free_osc_sender( srd->osc );
srd->osc = NULL;
veejay_msg(VEEJAY_MSG_INFO,
"OSC sender inactive");
}
}
void sample_add_osc_path( void *sample, const char *path, int fx_entry_id )
{
sample_runtime_data *srd = (sample_runtime_data*) sample;
//@ add osc path to entry
void *port = sample_get_fx_port_ptr( sample,fx_entry_id );
int error = vevo_property_set( port, "fx_osc", VEVO_ATOM_TYPE_STRING,1,&path );
#ifdef STRICT_CHECKING
assert( error == VEVO_NO_ERROR );
#endif
}
void sample_del_osc_path( void *sample, int fx_entry_id )
{
sample_runtime_data *srd = (sample_runtime_data*) sample;
//@ add osc path to entry
void *port = sample_get_fx_port_ptr( sample,fx_entry_id );
int error = vevo_property_set( srd->info_port, "fx_osc", VEVO_ATOM_TYPE_STRING,0,NULL );
#ifdef STRICT_CHECKING
assert( error == VEVO_NO_ERROR );
#endif
}
void sample_send_osc_path( void *sample, void *fx_entry )
{
sample_runtime_data *srd = (sample_runtime_data*) sample;
char *osc_path = get_str_vevo( fx_entry, "fx_osc" );
if(!osc_path)
{
return;
}
void *fx_out_values = NULL;
int error = vevo_property_get( fx_entry, "fx_out_values",0,&fx_out_values );
#ifdef STRICT_CHECKING
assert( error == VEVO_NO_ERROR );
#endif
if( osc_path )
{
veejay_vevo_send_osc( srd->osc,
osc_path,
fx_out_values );
free(osc_path);
}
}

143
veejay-ng/vevosample/vevosample.h
View File

@@ -38,100 +38,75 @@ typedef struct
int type; int type;
} sample_video_info_t; } sample_video_info_t;
int vevo_num_devices(); int vevo_num_devices();
void samplebank_init(); void samplebank_init();
void samplebank_free(); void samplebank_free();
int samplebank_size(); int samplebank_size();
void sample_delete_ptr(void *info); void sample_delete_ptr(void *info);
int sample_delete(int id); int sample_delete(int id);
void sample_set_property_ptr( void *ptr, const char *key, int atom_type, void *value ); void sample_set_property_ptr( void *ptr, const char *key, int atom_type, void *value );
void sample_set_property( int sample_id, const char *key, int atom_type, void *value ); void sample_set_property( int sample_id, const char *key, int atom_type, void *value );
void sample_get_property( int sample_id, const char *key, void *dst ); void sample_get_property( int sample_id, const char *key, void *dst );
void *sample_new( int type ); void *sample_new( int type );
void sample_free(int sample_id); void sample_free(int sample_id);
int sample_open( void *sample, const char *token, int extra_token, sample_video_info_t *settings ); int sample_open( void *sample, const char *token, int extra_token, sample_video_info_t *settings );
int sample_get_frame( void *current_sample, VJFrame *slot ); int sample_get_frame( void *current_sample, VJFrame *slot );
void sample_fx_set_parameter( int id, int fx_entry, int param_id,int n, void *data ); void sample_fx_set_parameter( int id, int fx_entry, int param_id,int n, void *data );
void sample_fx_get_parameter( int id, int fx_enty,int param_id,int idx, void *dst );
void sample_fx_get_parameter( int id, int fx_enty,int param_id,int idx, void *dst ); void sample_toggle_process_entry( void *data, int fx_entry, int v );
void sample_toggle_process_entry( void *data, int fx_entry, int v ); int sample_fx_set_active( int id, int fx_entry, int switch_value);
int sample_fx_set_active( int id, int fx_entry, int switch_value); int sample_fx_set_channel( int id, int fx_entry, int n_input, int channel_id );
int sample_fx_set_channel( int id, int fx_entry, int n_input, int channel_id ); int sample_get_fx_alpha( void *data, int fx_entry );
void sample_set_fx_alpha( void *data, int fx_entry, int v );
int sample_get_fx_alpha( void *data, int fx_entry ); void sample_set_itu601( void *current_sample, int status );
void sample_set_fx_alpha( void *data, int fx_entry, int v ); int sample_fx_set( void *info, int fx_entry, const int new_fx );
void sample_set_itu601( void *current_sample, int status ); void sample_set_input_frame( void *info, int fx_entry, int seq_num, VJFrame *frame );
void sample_process_fx_chain( void *srd );
int sample_fx_del( int id, int fx_entry );
int sample_fx_set( void *info, int fx_entry, const int new_fx ); int sample_xml_load( const char *filename, void *samplebank );
int samplebank_xml_save( const char *filename );
void sample_set_input_frame( void *info, int fx_entry, int seq_num, VJFrame *frame ); void *sample_get_fx_port( int id, int fx_entry );
void sample_process_fx_chain( void *srd ); int sample_process_inplace( void *sample , int fx_entry );
int sample_fx_del( int id, int fx_entry ); void sample_cache_data( void *sample_id );
void sample_save_cache_data( void *sample );
int sample_xml_load( const char *filename, void *samplebank ); int sample_fx_set_in_channel( void *info, int fx_entry, int seq_num, const int sample_id );
int samplebank_xml_save( const char *filename ); int sample_edl_get_audio_properties( void *current_sample, int *bits, int *bps, int *num_chans, long *rate );
int sample_get_audio_frame( void *current_sample, void *buffer , int n);
void *sample_get_fx_port( int id, int fx_entry );
int sample_process_inplace( void *sample , int fx_entry );
void sample_cache_data( void *sample_id );
void sample_save_cache_data( void *sample );
int sample_fx_set_in_channel( void *info, int fx_entry, int seq_num, const int sample_id );
int sample_edl_get_audio_properties( void *current_sample, int *bits, int *bps, int *num_chans, long *rate );
int sample_get_audio_frame( void *current_sample, void *buffer , int n);
uint64_t sample_get_start_pos( void *sample ); uint64_t sample_get_start_pos( void *sample );
uint64_t sample_get_end_pos( void *sample ); uint64_t sample_get_end_pos( void *sample );
int sample_get_speed( void *sample ); int sample_get_speed( void *sample );
uint64_t sample_get_current_pos( void *sample ); uint64_t sample_get_current_pos( void *sample );
int sample_get_looptype( void *sample ); int sample_get_looptype( void *sample );
int sample_has_audio( void *sample ); int sample_has_audio( void *sample );
int sample_valid_speed(void *sample, int new_speed); int sample_valid_speed(void *sample, int new_speed);
int sample_valid_pos(void *sample, uint64_t pos); int sample_valid_pos(void *sample, uint64_t pos);
void *sample_last(void);
void *sample_last(void); void *find_sample(int id);
void *find_sample(int id);
const char *sample_describe_type( int type ); const char *sample_describe_type( int type );
void sample_fx_chain_reset( void *sample );
void sample_fx_chain_reset( void *sample ); int sample_fx_chain_entry_clear(void *sample, int id );
int sample_fx_chain_entry_clear(void *sample, int id ); int sample_sscanf_port( void *sample, const char *s );
char *sample_sprintf_port( void *sample );
int sample_sscanf_port( void *sample, const char *s ); int sample_fx_push_in_channel( void *info, int fx_entry, int seq_num, void *frame_info );
char *sample_sprintf_port( void *sample ); int sample_fx_push_out_channel(void *info, int fx_entry, int seq_num, void *frame_info );
int sample_scan_out_channels( void *data, int fx_entry );
int sample_fx_push_in_channel( void *info, int fx_entry, int seq_num, void *frame_info ); void *sample_scan_in_channels( void *data, int fx_entry );
int sample_fx_push_out_channel(void *info, int fx_entry, int seq_num, void *frame_info ); void *sample_get_fx_port_ptr( void *data, int fx_entry );
void *sample_get_fx_port_channels_ptr( int id, int fx_entry );
int sample_scan_out_channels( void *data, int fx_entry );
void *sample_scan_in_channels( void *data, int fx_entry );
void *sample_get_fx_port_ptr( void *data, int fx_entry );
void *sample_get_fx_port_channels_ptr( int id, int fx_entry );
int sample_get_key_ptr( void *sample ); int sample_get_key_ptr( void *sample );
int sample_edl_delete( void *current_sample, uint64_t start, uint64_t end );
int sample_edl_paste_from_buffer( void *current_sample, uint64_t insert_at );
int sample_edl_cut_to_buffer( void *current_sample, uint64_t start_pos, uint64_t end_pos );
int sample_configure_recorder( void *sample, int format, const char *filename, int nframes, sample_video_info_t *ps );
int sample_start_recorder( void *sample, sample_video_info_t *ps );
int sample_stop_recorder( void *sample );
int sample_record_frame( void *sample, VJFrame *frame, uint8_t *audio_buffer, int a_len );
char *sample_get_recorded_file( void *sample );
int sample_edl_delete( void *current_sample, uint64_t start, uint64_t end ); int sample_new_osc_sender(void *sample, const char *addr, const char *port );
void sample_close_osc_sender( void *sample );
int sample_edl_paste_from_buffer( void *current_sample, uint64_t insert_at ); void sample_add_osc_path( void *sample, const char *path, int fx_entry_id );
void sample_del_osc_path( void *sample, int fx_entry_id );
int sample_edl_cut_to_buffer( void *current_sample, uint64_t start_pos, uint64_t end_pos ); void sample_send_osc_path( void *sample, void *fx_entry );
int sample_configure_recorder( void *sample, int format, const char *filename, int nframes, sample_video_info_t *ps );
int sample_start_recorder( void *sample, sample_video_info_t *ps );
int sample_stop_recorder( void *sample );
int sample_record_frame( void *sample, VJFrame *frame, uint8_t *audio_buffer, int a_len );
char * sample_get_recorded_file( void *sample );
#endif #endif