/* * Copyright (C) 2002-2006 Niels Elburg * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * */ /** \defgroup vevo_sample VeVo Samples * * Each video related object in veejay is called a Sample. * * Types of samples: * -# Edit Descision Lists * -# MJPEG avi file(s) * -# YUV4MPEG stream * -# DV1394 Digital Camera * -# V4L Video4Linux * -# Source generator (solid color) */ #ifdef STRICT_CHECKING #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_DV1394 #include #endif #include #include #include #ifdef USE_GDK_PIXBUF #include #endif #define XMLTAG_SAMPLES "veejay_samples" #define XMLTAG_SAMPLE "sample" #define KEY_LEN 64 #define SAMPLE_LIMIT 4096 #define VEVO_SAMPLE_PORT 700 /* Port identifiers, hashtables */ #define VEVO_SAMPLE_FX_PORT 707 #define VEVO_SAMPLE_FX_ENTRY 709 #define VEVO_SAMPLE_BANK_PORT 800 #define VEVO_VALUES_PORT 46 /* Linked list of values (cached) */ #define VEVO_FRAMES_PORT 47 /* Linked list of channel identifiers */ #define VEVO_FX_ENTRY_PORT 45 #define VEVO_FX_VALUES_PORT 44 #define VEVO_FX_CHANNELS_PORT 43 #define my_cmp(a,b) xmlStrcmp( a->name, (const xmlChar*) b ) static int num_samples_ = 0; /* total count of samples */ static int free_slots_[SAMPLE_LIMIT]; /* deleted sample id's */ static void *sample_bank_ = NULL; /* root of samplebank */ //! \typedef sampleinfo_t Sample A/V Information structure typedef struct { uint64_t start_pos; //!< Starting position uint64_t end_pos; //!< Ending position int looptype; //!< Looptype int speed; //!< Playback speed uint64_t in_point; //!< In point (overrides start_pos) uint64_t out_point; //!< Out point (overrides end_pos) uint64_t current_pos; //!< Current position int marker_lock; //!< Keep in-out point length constant int rel_pos; //!< Relative position int has_audio; //!< Audio available int type; //!< Type of Sample } sampleinfo_t; //! \typedef sample_runtime_data Sample Runtime Data structure typedef struct { void *data; /* private data, depends on stream type */ void *info_port; /* collection of sample properties */ int width; /* processing information */ int height; int format; int palette; int type; /* type of sample */ sampleinfo_t *info; } sample_runtime_data; /* forward */ static void sample_fx_clean_up( void *port ); static void *sample_get_fx_port_values_ptr( int id, int fx_entry ); static void sample_expand_properties( void *sample, const char *key, xmlNodePtr root ); static void sample_expand_port( void *port, xmlNodePtr node ); static void sample_close( sample_runtime_data *srd ); static void sample_new_fx_chain(void *sample); /* * 1. cache sample properties to sampleinfo * 2. do events * 3. update sample properties * 4. do work * 5. uncache * 6. goto 1 * */ /* * to reduce vevo set/get , cache each step */ void trap_vevo_sample() {} /** * elements in random access sample * */ static struct { const char *name; int atom_type; } sample_property_list[] = { { "start_pos", VEVO_ATOM_TYPE_UINT64 }, /* Starting position */ { "end_pos", VEVO_ATOM_TYPE_UINT64 }, /* Ending position */ { "speed", VEVO_ATOM_TYPE_INT }, /* Trickplay, speed */ { "current_pos", VEVO_ATOM_TYPE_UINT64 }, /* Current position */ { "fps", VEVO_ATOM_TYPE_DOUBLE }, /* video fps */ { "looptype", VEVO_ATOM_TYPE_INT }, /* Loop type , normal, pingpong or none */ { "in_point", VEVO_ATOM_TYPE_UINT64 }, /* In marker point */ { "out_point", VEVO_ATOM_TYPE_UINT64 }, { "marker_lock", VEVO_ATOM_TYPE_INT }, /* Marker length locked */ { "fx_fade", VEVO_ATOM_TYPE_INT }, /* Fade FX -> Original sample */ { "fx_fade_value", VEVO_ATOM_TYPE_DOUBLE }, { "fx_fade_dir", VEVO_ATOM_TYPE_INT }, { "current_entry", VEVO_ATOM_TYPE_INT }, /* Current active Entry */ { NULL, 0 } }; static struct { const char *name; int atom_type; } fx_entry_list_[] = { { "fx_status", VEVO_ATOM_TYPE_INT }, /* fx status */ { "fx_alpha", VEVO_ATOM_TYPE_INT }, /* alpha */ { "fx_instance", VEVO_ATOM_TYPE_VOIDPTR }, /* plugin instance point */ { "fx_values", VEVO_ATOM_TYPE_PORTPTR }, /* port of p0 .. pN, containing copy of fx parameter values */ { "fx_channels", VEVO_ATOM_TYPE_PORTPTR }, /* contains list of sample pointers to use as input channels */ }; /** * elements common in all types of samples */ static struct { const char *name; int atom_type; } common_property_list[] = { { "title", VEVO_ATOM_TYPE_STRING }, /* Title of this sample */ { "fx_status", VEVO_ATOM_TYPE_INT }, /* FX chain enabled/disabled */ { "primary_key", VEVO_ATOM_TYPE_INT }, /* Primary key of this sample */ { NULL, 0 } }; /** * sample recorder elements */ static struct { const char *name; int atom_type; } recorder_state_list[] = { { "format", VEVO_ATOM_TYPE_INT }, { "basename", VEVO_ATOM_TYPE_STRING }, { "sequence", VEVO_ATOM_TYPE_STRING }, { "frames_done", VEVO_ATOM_TYPE_INT }, { "paused", VEVO_ATOM_TYPE_BOOL }, { "switch", VEVO_ATOM_TYPE_BOOL }, { NULL, 0 } }; /** * stream properties */ static struct { const char *name; int atom_type; } stream_property_list[] = { { "width", VEVO_ATOM_TYPE_STRING }, { "height", VEVO_ATOM_TYPE_INT }, { "palette", VEVO_ATOM_TYPE_INT }, { "active", VEVO_ATOM_TYPE_INT }, { "format", VEVO_ATOM_TYPE_INT }, { "data", VEVO_ATOM_TYPE_VOIDPTR }, { NULL, 0 } }; static struct { const char *name; int atom_type; } stream_v4l_list[] = { { "device", VEVO_ATOM_TYPE_STRING }, { "channel", VEVO_ATOM_TYPE_INT }, { NULL, 0 } }; static struct { const char *name; int atom_type; } stream_socket_list[] = { { "hostname", VEVO_ATOM_TYPE_STRING }, { "port", VEVO_ATOM_TYPE_INT }, { NULL, 0 } }; static struct { const char *name; int atom_type; } stream_mcast_list[] = { { "hostname", VEVO_ATOM_TYPE_STRING }, { "port", VEVO_ATOM_TYPE_INT }, { NULL, 0 } }; static struct { const char *name; int atom_type; } stream_dv1394_list[] = { { "device", VEVO_ATOM_TYPE_STRING }, { "channel", VEVO_ATOM_TYPE_INT }, { NULL, 0 } }; static struct { const char *name; int atom_type; } stream_file_list[] = { { "filename", VEVO_ATOM_TYPE_STRING }, { NULL, 0 } }; static struct { const char *name; int atom_type; } stream_color_list[] = { { "red", VEVO_ATOM_TYPE_DOUBLE }, { "green", VEVO_ATOM_TYPE_DOUBLE }, { "blue", VEVO_ATOM_TYPE_DOUBLE }, { "alpha", VEVO_ATOM_TYPE_DOUBLE }, { NULL, 0 } }; static struct { const char *name; int atom_type; } stream_picture_list[] = { { "filename", VEVO_ATOM_TYPE_STRING }, { NULL, 0 } }; void *find_sample(int id) { char key[20]; void *info = NULL; int error; #ifdef STRICT_CHECKING assert( id > 0 && id < SAMPLE_LIMIT ); #endif sprintf(key, "sample%04x", id ); error = vevo_property_get( sample_bank_, key, 0, &info ); if(error != VEVO_NO_ERROR) { #ifdef STRICT_CHECKING veejay_msg(0, "%s: '%s' not found in samplebank", __FUNCTION__, key ); #endif return NULL; } #ifdef STRICT_CHECKING assert( info != NULL ); #endif return info; } static void *find_sample_by_key(const char *key) { void *info = NULL; int error = vevo_property_get( sample_bank_, key, 0, &info ); if( error == VEVO_NO_ERROR && info == NULL ) return NULL; return info; } static int find_slot(void) { int i; for(i = 0; i < SAMPLE_LIMIT; i++ ) { if(free_slots_[i]) return i; } return -1; } static void claim_slot(int idx) { free_slots_[idx] = 0; } static void free_slot(int key) { int i; for(i = 0; i < SAMPLE_LIMIT; i++ ) { if(!free_slots_[i]) { free_slots_[i] = key; break; } } } int sample_get_key_ptr( void *info ) { int pk = 0; sample_runtime_data *srd = (sample_runtime_data*) info; int error = vevo_property_get( srd->info_port, "primary_key", 0, &pk ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif return pk; } void sample_delete_ptr( void *info ) { sample_runtime_data *srd = (sample_runtime_data*) info; //@ FIXME: get default channel configuratioe_data *srd = (sample_runtime_data*) info; #ifdef STRICT_CHECKING if( info == NULL ) trap_vevo_sample(); assert( info != NULL ); assert( srd->info_port != NULL ); #endif int pk = 0; int error = vevo_property_get( srd->info_port, "primary_key", 0, &pk ); sample_fx_clean_up( srd->info_port ); sample_close( srd ); vevo_port_recursive_free( srd->info_port ); free_slot( pk ); free(srd->info); free(srd); if( error == VEVO_NO_ERROR ) { char pri_key[20]; sprintf(pri_key, "sample%04x", pk ); error = vevo_property_set( sample_bank_, pri_key, VEVO_ATOM_TYPE_VOIDPTR, 0, NULL ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif } } void sample_fx_chain_reset( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sample_fx_clean_up( srd->info_port ); sample_new_fx_chain ( srd->info_port ); } void sample_fx_set_parameter( int id, int fx_entry, int param_id,int n_elem, void *value ) { void *port = sample_get_fx_port( id, fx_entry ); int fx_id = 0; void *fx_instance = NULL; int error = vevo_property_get( port, "fx_instance", 0, &fx_instance ); #ifdef STRICT_CHECKING assert( error == 0 ); #endif plug_set_parameter( fx_instance, param_id, n_elem,value ); } void sample_fx_get_parameter( int id, int fx_entry, int param_id, int idx, void *dst) { void *fx_values = sample_get_fx_port_values_ptr( id, fx_entry ); char pkey[KEY_LEN]; sprintf(pkey, "p%02d", param_id ); vevo_property_get( fx_values, pkey, idx, dst ); } int sample_fx_set( void *info, int fx_entry, const int new_fx ) { void *port = sample_get_fx_port_ptr( info,fx_entry ); void *fx_values = NULL; void *fx_channels = NULL; //int cur_fx_id = 0; int error; #ifdef STRICT_CHECKING assert( port != NULL ); #endif void *fxi = NULL; error = vevo_property_get( port, "fx_instance", 0, &fxi ); if( error == VEVO_NO_ERROR ) { veejay_msg(0, "FX entry %d is used. Please select another", fx_entry); return 0; } error = vevo_property_set( port, "fx_id", VEVO_ATOM_TYPE_INT,1, &new_fx ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif void *fx_instance = plug_activate( new_fx ); if(!fx_instance) { veejay_msg(0, "Unable to initialize plugin %d", new_fx ); return 0; } error = vevo_property_set( port, "fx_instance", VEVO_ATOM_TYPE_PORTPTR, 1, &fx_instance ); #ifdef STRICT_CHECKING if(error != VEVO_NO_ERROR) veejay_msg(0, "Error code %d",error); assert( error == VEVO_NO_ERROR ); #endif error = vevo_property_get( port, "fx_values", 0, &fx_values ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif error = vevo_property_get( port, "fx_channels", 0, &fx_channels ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif int n_channels = vevo_property_num_elements( fx_instance, "in_channels" ); error = vevo_property_set( fx_channels, "n_in_channels", VEVO_ATOM_TYPE_INT,1, &n_channels ); int o_channels = vevo_property_num_elements( fx_instance, "out_channels" ); error = vevo_property_set( fx_channels, "n_out_channels",VEVO_ATOM_TYPE_INT,1, &o_channels ); plug_get_defaults( fx_instance, fx_values ); plug_set_defaults( fx_instance, fx_values ); int i; for(i=0; i < n_channels; i ++ ) sample_fx_set_in_channel(info,fx_entry,i, sample_get_key_ptr(info)); veejay_msg(0, "Entry %d Plug %d has %d Inputs, %d Outputs",fx_entry, new_fx,n_channels,o_channels ); //@ FIXME: get default channel configuration // plug_get_channels( fx_instance, fx_channels ); return 1; } int sample_fx_set_in_channel( void *info, int fx_entry, int seq_num, const int sample_id ) { void *port = sample_get_fx_port_ptr( info, fx_entry ); void *fx_channels = NULL; void *fx_instance = NULL; char key[64]; int error = vevo_property_get( port, "fx_channels",0, &fx_channels ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif int max_in = 0; error = vevo_property_get( fx_channels, "n_in_channels", 0, &max_in ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif if (seq_num < 0 || seq_num >= max_in ) { veejay_msg(0, "FX has at most %d input channel(s)", max_in ); return 0; } void *sample = find_sample( sample_id ); sprintf(key,"slot%d",seq_num ); #ifdef STRICT_CHECKING assert( sample != NULL ); #endif error = vevo_property_set( fx_channels, key, VEVO_ATOM_TYPE_VOIDPTR, 1, &sample ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif return 1; } int sample_fx_push_in_channel( void *info, int fx_entry, int seq_num, void *frame_info ) { void *port = sample_get_fx_port_ptr( info,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif void *fx_instance = NULL; int error = vevo_property_get( port, "fx_instance", 0, &fx_instance ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif plug_push_frame( fx_instance, 0,seq_num, frame_info ); return 1; } int sample_fx_push_out_channel( void *info, int fx_entry, int seq_num, void *frame_info ) { void *port = sample_get_fx_port_ptr( info,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif void *fx_instance = NULL; int error = vevo_property_get( port, "fx_instance", 0, &fx_instance ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif plug_push_frame( fx_instance, 1,seq_num, frame_info ); return 1; } int sample_process_entry( void *data, int fx_entry ) { void *port = sample_get_fx_port_ptr( data,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif int fx_status; int error = vevo_property_get( port, "fx_status",0,&fx_status); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif return fx_status; } int sample_get_fx_alpha( void *data, int fx_entry ) { void *port = sample_get_fx_port_ptr( data,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif int fx_alpha=0; int error = vevo_property_get( port, "fx_alpha",0,&fx_alpha); if( error != VEVO_NO_ERROR ) return 256; return fx_alpha; } void sample_set_fx_alpha( void *data, int fx_entry, int v ) { void *port = sample_get_fx_port_ptr( data,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif int fx_alpha = v; int error = vevo_property_set( port, "fx_alpha",VEVO_ATOM_TYPE_INT,1,&fx_alpha); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif } void sample_toggle_process_entry( void *data, int fx_entry, int v ) { void *port = sample_get_fx_port_ptr( data,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif int fx_status = v; int error = 0; void *fxi = NULL; error = vevo_property_get( port, "fx_instance", 0, &fxi ); if( error != VEVO_NO_ERROR ) { veejay_msg(0,"Nothing to enable on entry %d",fx_entry); return; } error = vevo_property_set( port, "fx_status",VEVO_ATOM_TYPE_INT,1,&fx_status); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif } void *sample_scan_in_channels( void *data, int fx_entry ) { void *port = sample_get_fx_port_ptr( data,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif int n = sample_fx_num_in_channels( port ); if( n <= 0 ) return NULL; //FIXME: fx_channels contains slot[d] with value sample ptr, //// quque list expects sample[d] with value sample ptr void *fx_channels = NULL; int error = vevo_property_get( port, "fx_channels",0, &fx_channels); #ifdef STRICT_CHECKING assert( error == 0 ); #endif return fx_channels; } /*void *sample_scan_in_channels( void *data, int fx_entry ) { #ifdef STRICT_CHECKING assert( data != NULL); #endif sample_runtime_data *info = (sample_runtime_data*) data; #ifdef STRICT_CHECKING assert( info != NULL ); assert( info->info_port != NULL ); #endif void *port = sample_get_fx_port_ptr( info,fx_entry ); int n = sample_fx_num_in_channels( port ); if( n <= 0 ) return NULL; void *fx_channels = NULL; int error = vevo_property_get( port, "fx_channels",0, &fx_channels); #ifdef STRICT_CHECKING assert( error == 0 ); #endif veejay_msg(0, "Entry %d has port fx_channels: %p", fx_entry,fx_channels ); char **list = vevo_list_properties( fx_channels ); int k = 0; for ( k = 0; list[k] != NULL ; k ++ ) { veejay_msg(0, "\t'%s'", list[k]); free(list[k]); } free(list); return fx_channels; }*/ int sample_scan_out_channels( void *data, int fx_entry ) { void *port = sample_get_fx_port_ptr( data,fx_entry ); if(!port) return NULL; #ifdef STRICT_CHECKING assert( port != NULL ); #endif return sample_fx_num_out_channels( port ); } // frame buffer passed by performer int sample_process_fx( void *sample, int fx_entry ) { unsigned int i,k; void *fx_instance = NULL; void *fx_values = NULL; void *port = sample_get_fx_port_ptr( sample,fx_entry ); #ifdef STRICT_CHECKING assert( port != NULL ); #endif int error = vevo_property_get( port, "fx_instance", 0, &fx_instance ); #ifdef STRICT_CHECKING assert( error == 0 ); #endif plug_process( fx_instance ); error = vevo_property_get( port, "fx_values", 0, &fx_values ); #ifdef STRICT_CHECKING assert( error == 0 ); #endif //update internal parameter values plug_clone_from_parameters( fx_instance, fx_values ); return VEVO_NO_ERROR; } int sample_fx_num_in_channels( void *port ) { void *fx_channels = NULL; int error = vevo_property_get( port, "fx_channels",0, &fx_channels ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif int n_channels = 0; error = vevo_property_get( fx_channels, "n_in_channels", 0, &n_channels ); if( error != VEVO_NO_ERROR ) n_channels = 0; return n_channels; } int sample_fx_num_out_channels( void *port ) { void *fx_channels = NULL; int error = vevo_property_get( port, "fx_channels",0, &fx_channels ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif int n_channels = 0; vevo_property_get( fx_channels, "n_out_channels", 0, &n_channels ); return n_channels; } int sample_fx_set_by_name( int id, int fx_entry, const char *name ) { return 0; } void *sample_get_fx_port_ptr( void *data, int fx_entry ) { sample_runtime_data *info = (sample_runtime_data*) data; void *port = NULL; char fx[KEY_LEN]; sprintf(fx, "fx_%x", fx_entry ); #ifdef STRICT_CHECKING assert( info->info_port != NULL ); #endif int error = vevo_property_get( info->info_port, fx, 0, &port ); #ifdef STRICT_CHECKING assert( error == 0 ); assert( port != NULL ); #endif return port; } int sample_get_fx_id( void *data , int fx_entry ) { void *port = sample_get_fx_port_ptr( data, fx_entry ); int fx_id = -1; int error = vevo_property_get( port, "fx_id",0, &fx_id ); return fx_id; } static void *sample_get_fx_port_values_ptr( int id, int fx_entry ) { void *port = sample_get_fx_port( id, fx_entry ); void *fx_values = NULL; int error = vevo_property_get( port, "fx_values", 0, &fx_values ); return fx_values; } void *sample_get_fx_port_channels_ptr( int id, int fx_entry ) { void *port = sample_get_fx_port( id, fx_entry ); void *fx_values = NULL; int error = vevo_property_get( port, "fx_channels", 0, &fx_values ); return fx_values; } void *sample_get_fx_port( int id, int fx_entry ) { return sample_get_fx_port_ptr( find_sample(id),fx_entry ); } void sample_set_property_ptr( void *ptr, const char *key, int atom_type, void *value ) { sample_runtime_data *info = (sample_runtime_data*) ptr; if(info) vevo_property_set( info->info_port, key, atom_type,1, value ); } void sample_set_property( int id, const char *key, int atom_type, void *value ) { sample_runtime_data *info = (sample_runtime_data*) find_sample( id ); if(info) vevo_property_set( info->info_port, key, atom_type,1, value ); } void sample_get_property( int id, const char *key, void *dst ) { sample_runtime_data *info = (sample_runtime_data*) find_sample( id ); if(info) vevo_property_get( info->info_port, key, 0, dst ); } static int sample_new_ext(void *info ) { int i; for(i = 0 ; sample_property_list[i].name != NULL ; i ++ ) vevo_property_set( info, sample_property_list[i].name, sample_property_list[i].atom_type, 0, NULL ); return 1; } static int sample_new_stream(void *info, int type ) { int i ; double v = 0.0; for(i = 0 ; stream_property_list[i].name != NULL ; i ++ ) vevo_property_set( info, stream_property_list[i].name, stream_property_list[i].atom_type, 0, NULL ); #ifdef STRICT_CHECKING assert( type != VJ_TAG_TYPE_NONE ); #endif switch(type) { case VJ_TAG_TYPE_PICTURE: for(i = 0 ; stream_picture_list[i].name != NULL ; i ++ ) vevo_property_set( info, stream_picture_list[i].name, stream_picture_list[i].atom_type, 0, NULL ); break; case VJ_TAG_TYPE_COLOR: for(i = 0 ; stream_color_list[i].name != NULL ; i ++ ) vevo_property_set( info, stream_color_list[i].name, stream_color_list[i].atom_type, 1, &v ); break; case VJ_TAG_TYPE_V4L: for( i = 0 ; stream_v4l_list[i].name != NULL; i ++ ) vevo_property_set( info, stream_v4l_list[i].name, stream_v4l_list[i].atom_type, 0, NULL ); break; case VJ_TAG_TYPE_YUV4MPEG: for( i = 0; stream_file_list[i].name != NULL; i ++ ) vevo_property_set( info, stream_file_list[i].name, stream_file_list[i].atom_type,0,NULL); break; case VJ_TAG_TYPE_NET: for( i = 0; stream_socket_list[i].name != NULL; i ++ ) vevo_property_set( info, stream_socket_list[i].name, stream_socket_list[i].atom_type,0,NULL); break; case VJ_TAG_TYPE_MCAST: for( i = 0; stream_mcast_list[i].name != NULL; i ++ ) vevo_property_set( info, stream_mcast_list[i].name, stream_mcast_list[i].atom_type,0,NULL); break; #ifdef HAVE_DV1394 case VJ_TAG_TYPE_DV1394: for( i = 0; stream_dv1394_list[i].name != NULL; i ++ ) vevo_property_set( info, stream_dv1394_list[i].name, stream_dv1394_list[i].atom_type,0,NULL); break; #endif default: #ifdef STRICT_CHECKING assert(0); #endif break; } return 1; } const char *sample_describe_type( int type ) { switch(type) { case VJ_TAG_TYPE_PICTURE: return "Picture"; break; case VJ_TAG_TYPE_COLOR: return "Solid Color stream"; break; case VJ_TAG_TYPE_V4L: return "Video4Linux stream"; break; case VJ_TAG_TYPE_YUV4MPEG: return "YUV4Mpeg stream"; break; case VJ_TAG_TYPE_NET: return "TCP unicast stream"; break; case VJ_TAG_TYPE_MCAST: return "UDP multicast stream"; break; case VJ_TAG_TYPE_NONE: return "AVI Sample"; break; #ifdef HAVE_DV1394 case VJ_TAG_TYPE_DV1394: break; #endif default: break; } return NULL; } static void sample_fx_entry_clean_up( void *sample, int id ) { char entry_key[KEY_LEN]; void *entry_port = NULL; sprintf(entry_key, "fx_%x", id ); int error = vevo_property_get( sample, entry_key,0, &entry_port ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif void *instance = NULL; error = vevo_property_get( entry_port, "fx_instance",0,&instance ); if(error == VEVO_NO_ERROR ) plug_deactivate( instance ); void *fxv = NULL; error = vevo_property_get( entry_port, "fx_values",0,&fxv ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif void *fxc = NULL; error = vevo_property_get(entry_port, "fx_channels",0,&fxc ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif vevo_port_free( fxv ); vevo_port_free( fxc ); vevo_port_free( entry_port ); error = vevo_property_set( sample, entry_key, VEVO_ATOM_TYPE_PORTPTR, 0, NULL ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif } static void sample_fx_clean_up( void *sample ) { int i; int error; for( i = 0 ; i < SAMPLE_CHAIN_LEN; i ++ ) { sample_fx_entry_clean_up( sample,i ); } } static void sample_new_fx_chain_entry( void *sample, int id ) { void *port = vevo_port_new( VEVO_FX_ENTRY_PORT ); char entry_key[KEY_LEN]; sprintf(entry_key, "fx_%x", id ); int dstatus = 0; int error = vevo_property_set( port, "fx_status", VEVO_ATOM_TYPE_INT,1,&dstatus ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif void *fx_values = vevo_port_new( VEVO_FX_VALUES_PORT ); void *fx_channels = vevo_port_new( VEVO_ANONYMOUS_PORT ); error = vevo_property_set( port, "fx_values", VEVO_ATOM_TYPE_PORTPTR,1,&fx_values); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif error = vevo_property_set( port, "fx_channels",VEVO_ATOM_TYPE_PORTPTR,1,&fx_channels ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif error = vevo_property_set( port, "fx_instance", VEVO_ATOM_TYPE_PORTPTR,0,NULL ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif error = vevo_property_set( sample, entry_key, VEVO_ATOM_TYPE_PORTPTR,1, &port ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif } static void sample_new_fx_chain(void *sample) { int i; int error; int dstatus = 0; for( i = 0 ; i < SAMPLE_CHAIN_LEN; i ++ ) { sample_new_fx_chain_entry( sample, i ); } } int sample_fx_chain_entry_clear(void *info, int id ) { sample_runtime_data *sample = (sample_runtime_data*) info; if( id >= 0 && id < SAMPLE_CHAIN_LEN ) { sample_fx_entry_clean_up( sample->info_port, id ); sample_new_fx_chain_entry( sample->info_port, id ); return 1; } return 0; } void *sample_new( int type ) { int i; sample_runtime_data *rtdata = (sample_runtime_data*) malloc(sizeof( sample_runtime_data ) ); memset( rtdata,0,sizeof(sample_runtime_data)); sampleinfo_t *sit = (sampleinfo_t*) vj_malloc(sizeof(sampleinfo_t)); memset( sit,0,sizeof(sampleinfo_t)); rtdata->info = sit; rtdata->type = type; rtdata->info_port = (void*) vevo_port_new( VEVO_SAMPLE_PORT ); for(i = 0 ; common_property_list[i].name != NULL ; i ++ ) vevo_property_set( rtdata->info_port, common_property_list[i].name, common_property_list[i].atom_type, 0, NULL ); void *res = NULL; sit->type = type; if( type == VJ_TAG_TYPE_NONE ) { if( sample_new_ext( rtdata->info_port )) res = (void*) rtdata; } else { if( sample_new_stream( rtdata->info_port, type )) res = (void*) rtdata; } sample_new_fx_chain( rtdata->info_port ); return res; } void samplebank_init() { sample_bank_ = (void*) vevo_port_new( VEVO_SAMPLE_BANK_PORT ); #ifdef STRICT_CHECKING veejay_msg(2,"VEVO Sampler initialized. (max=%d)", SAMPLE_LIMIT ); #endif } void samplebank_free() { int i = 0; #ifdef STRICT_CHECKING assert( sample_bank_ != NULL ); #endif char **props = (char**) vevo_list_properties( sample_bank_ ); if(!props) return; for( i = 0; props[i] != NULL;i ++ ) { if( props[i][0] == 's' ) { void *info = find_sample_by_key( props[i] ); if( info ) sample_delete_ptr( info ); } free(props[i]); } free(props); vevo_port_free( sample_bank_ ); /*#ifdef STRICT_CHECKING port_frees_ ++; #endif*/ num_samples_ = 0; veejay_msg(2, "Shutting down VEVO Sampler"); } int samplebank_add_sample( void *sample ) { char pri_key[20]; int error = 0; int pk = 0; sample_runtime_data *srd = (sample_runtime_data*) sample; void *port =srd->info_port; error = vevo_property_get( port, "primary_key", 0, &pk ); if( error != VEVO_NO_ERROR ) { int tslot = find_slot(); pk = (tslot >= 0 ? free_slots_[ tslot ] : num_samples_ + 1 ); } #ifdef STRICT_CHECKING assert( pk > 0 ); #endif vevo_property_set( port, "primary_key", VEVO_ATOM_TYPE_INT, 1, &pk ); sprintf(pri_key, "sample%04x", pk ); vevo_property_set( sample_bank_, pri_key, VEVO_ATOM_TYPE_VOIDPTR, 1, &sample ); num_samples_ += 1; return pk; } int samplebank_size() { return num_samples_; } void *sample_last(void) { int id = num_samples_; void *found = NULL; while(!found && id > 0) { found = find_sample( id ); id --; } return found; } //@ what pixelformat are we supposed to play, /// what pixel format is file openened in ? int sample_open( void *sample, const char *token, int extra_token , sample_video_info_t *project_settings ) { // void *info = find_sample(id); int res = 0; int my_palette = 0; if(!sample) return 0; sample_runtime_data *srd = (sample_runtime_data*) sample; switch(srd->type) { case VJ_TAG_TYPE_NONE: srd->data = (void*) vj_el_open_video_file( token ); if(!srd->data) { veejay_msg(0, "Unable to create sample from %s", token ); srd->data = NULL; return 0; } #ifdef STRICT_CHECKING assert( srd->data != NULL ); assert( project_settings != NULL ); #endif res = vj_el_match( (void*) project_settings, srd->data ); if(!res) { veejay_msg(0, "%s does not match current project properties", token ); // vj_el_free( srd->data ); // return 0; } vj_el_setup_cache( srd->data ); sampleinfo_t *sit = srd->info; sit->end_pos = vj_el_get_num_frames(srd->data); sit->looptype = 1; sit->speed = 1; sample_set_property_ptr( sample, "end_pos", VEVO_ATOM_TYPE_INT, &(sit->end_pos)); sample_set_property_ptr( sample, "looptype",VEVO_ATOM_TYPE_INT, &(sit->looptype)); sample_set_property_ptr( sample, "speed", VEVO_ATOM_TYPE_INT,&(sit->speed)); break; case VJ_TAG_TYPE_V4L: srd->data = (void*) vj_v4lvideo_alloc(); res = vj_v4lvideo_init( (v4l_video*) srd->data, token, extra_token, project_settings->norm, // NOTE: THIS IS PROBABLY CHAR 0, project_settings->w, project_settings->h, project_settings->fmt ); // NOTE THIS SHOULD BE PALETTE, convert to V4L palette in v4l componenet! // my_palette ); break; case VJ_TAG_TYPE_NET: srd->data = (void*) vj_client_alloc( project_settings->w,project_settings->h, project_settings->fmt ); break; case VJ_TAG_TYPE_YUV4MPEG: srd->data = vj_yuv4mpeg_alloc( project_settings->fps, project_settings->w, project_settings->h, project_settings->sar_w, project_settings->sar_h); res = vj_yuv_stream_start_read( srd->data, token, project_settings->w, project_settings->h ); if(!res) vj_yuv4mpeg_free( srd->data ); break; #ifdef HAVE_DV1394 case VJ_TAG_TYPE_DV1394: // srd->data = (void*) vj_dv1394_init( (void*)el, extra_token,1 ); // DV1394 componenet like YUV and V4L comp. break; #endif #ifdef USE_GDK_PIXBUF case VJ_TAG_TYPE_PICTURE: if( vj_picture_probe ( token ) ) srd->data = vj_picture_open( token,project_settings->w,project_settings->h,0 ); //@ fixme: project! break; #endif case VJ_TAG_TYPE_COLOR: break; } return res; } int sample_append_file( const char *filename, long n1, long n2, long n3 ) { /*end = el->video_frames; * * // create initial edit list for sample (is currently playing) if(!sample_edl) sample_edl = vj_el_init_with_args( files,1,info->preserve_pathnames,info->auto_deinterlace,0, info->edit_list->video_norm , info->pixel_format); // i el->frame_list = (uint64_t *) realloc(el->frame_list, (end + el->num_frames[n])*sizeof(uint64_t)); if (el->frame_list==NULL) { veejay_msg(VEEJAY_MSG_ERROR, "Insufficient memory to allocate frame_list"); vj_el_free(el); return 0; } for (i = 0; i < el->num_frames[n]; i++) { el->frame_list[c] = EL_ENTRY(n, i); c++; } el->video_frames = c; //@ set min and max frame num anew //@ update start/end positions */ return 1; } void sample_increase_frame( void *current_sample ) { sample_runtime_data *srd = (sample_runtime_data*) current_sample; sampleinfo_t *sit = srd->info; if(sit->type != VJ_TAG_TYPE_NONE) { sit->current_pos ++; return; } uint64_t cf = sit->current_pos + sit->speed; sit->current_pos = cf; if(sit->speed >= 0 ) { if( cf > sit->end_pos || cf < sit->start_pos ) { switch( sit->looptype ) { case 2: sit->current_pos = sit->end_pos; sit->speed *= -1; break; case 1: sit->current_pos = sit->start_pos; break; case 0: sit->current_pos = sit->end_pos; sit->speed = 0; break; default: #ifdef STRICT_CHECKING assert(0); #endif break; } } } else { if( cf < sit->start_pos || cf > sit->end_pos || cf <= 0 ) { switch(sit->looptype) { case 2: sit->speed *= -1; sit->current_pos = sit->start_pos; break; case 1: sit->current_pos = sit->end_pos; break; case 0: sit->current_pos = sit->start_pos; sit->speed = 0; break; default: #ifdef STRICT_CHECKING assert(0); #endif break; } } } #ifdef STRICT_CHECKING assert( sit->current_pos >= sit->start_pos ); assert( sit->current_pos <= sit->end_pos ); #endif } void sample_set_itu601( void *current_sample, int status ) { sample_runtime_data *srd = (sample_runtime_data*) current_sample; #ifdef STRICT_CHECKING assert( srd->info ); #endif if(srd->type == VJ_TAG_TYPE_NONE) { vj_el_set_itu601( srd->data, status ); } } static void sample_produce_frame( sample_runtime_data *srd, VJFrame *slot ) { double color[4] = {0.0,0.0,0.0,0.0}; int error = 0; error = vevo_property_get( srd->info_port, "red", 0, &color[0]); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif error = vevo_property_get( srd->info_port, "green",0, &color[1]); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif error = vevo_property_get( srd->info_port, "blue", 0, &color[2]); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif double eY = (0.299 * color[0] ) + (0.587 * color[1] ) + (0.114 * color[2] ); double eU = (-0.168736 * color[0] ) - (-0.331264 * color[1] ) + (0.500 * color[2] ) + 128.0; double eV = (0.500 * color[0]) - (0.418688 * color[1]) - (0.081312 * color[2]) + 128.0; uint8_t y = (uint8_t) eY; uint8_t u = (uint8_t) eU; uint8_t v = (uint8_t) eV; memset( slot->data[0], y, slot->len ); memset( slot->data[1], u, slot->uv_len ); memset( slot->data[2], v, slot->uv_len ); } int sample_get_frame( void *current_sample , VJFrame *slot ) { sample_runtime_data *srd = (sample_runtime_data*) current_sample; #ifdef STRICT_CHECKING assert( srd->info ); #endif long frame_num = srd->info->current_pos; void *ptr = NULL; //srd->type !! //@ assign function pointer at sample_open to kill this switch statement switch(srd->type) { case VJ_TAG_TYPE_NONE: #ifdef STRICT_CHECKING assert( srd->data != NULL ); #endif vj_el_get_video_frame ( srd->data, frame_num,slot); break; case VJ_TAG_TYPE_V4L: break; case VJ_TAG_TYPE_NET: break; case VJ_TAG_TYPE_YUV4MPEG: vj_yuv_get_frame( srd->data, slot->data ); break; case VJ_TAG_TYPE_COLOR: sample_produce_frame( srd,slot ); break; #ifdef STRICT_CHECKING default: assert(0); break; #endif } return VEVO_NO_ERROR; } static void sample_close( sample_runtime_data *srd ) { #ifdef STRICT_CHECKING assert( srd != NULL ); #endif switch(srd->type) { case VJ_TAG_TYPE_NONE: vj_el_free( srd->data ); break; case VJ_TAG_TYPE_V4L: vj_v4l_video_grab_stop( srd->data ); break; case VJ_TAG_TYPE_YUV4MPEG: vj_yuv_stream_stop_read( srd->data ); break; #ifdef HAVE_DV1394 case VJ_TAG_TYPE_DV1394: vj_dv1394_close( srd->data ); break; #endif #ifdef USE_GDK_PIXBUF case VJ_TAG_TYPE_PICTURE: //vj_picture_cleanup( break; #endif case VJ_TAG_TYPE_NET: case VJ_TAG_TYPE_MCAST: vj_client_close( srd->data ); break; case VJ_TAG_TYPE_COLOR: break; default: #ifdef STRICT_CHECKING assert(0); #endif break; } } int sample_delete( int id ) { void *info = find_sample(id); if(!info) return 0; sample_delete_ptr( info ); return 1; } //@ fixme: move / dup function static char *clone_str( void *port, const char *key ) { size_t len = vevo_property_element_size( port, key, 0 ); char *ret = NULL; if(len<=0) return NULL; ret = (char*) malloc(sizeof(char) * len ); vevo_property_get( port, key, 0, &ret ); return ret; } static void sample_write_property( void *port, const char *key, xmlNodePtr node ) { int atom_type = vevo_property_atom_type( port, key ); int int_val = 0; double dbl_val = 0.0; char *str_val = NULL; int error = 0; printf("%s: %p, %s type = %d\n", __FUNCTION__, port, key, atom_type ); switch( atom_type ) { case VEVO_ATOM_TYPE_INT: case VEVO_ATOM_TYPE_BOOL: error = vevo_property_get( port, key, 0, &int_val ); if(error ) null_as_property( node, key ); else int_as_value( node, int_val, key ); break; case VEVO_ATOM_TYPE_DOUBLE: error = vevo_property_get( port, key, 0, &dbl_val ); if( error ) null_as_property( node, key ); else double_as_value( node, dbl_val, key ); break; case VEVO_ATOM_TYPE_STRING: str_val = clone_str( port, key ); if(str_val == NULL ) null_as_property( node, key ); else cstr_as_value( node, str_val, key ); break; case VEVO_ATOM_TYPE_PORTPTR: case VEVO_ATOM_TYPE_VOIDPTR: // veejay_msg(0, "Not expanding type %d : '%s'", atom_type,key ); sample_expand_properties( port, key, node ); break; default: #ifdef STRICT_CHECKING assert(0); #endif break; } } static void sample_expand_port( void *port, xmlNodePtr node ) { char **props = (char**) vevo_list_properties( port ); int i; #ifdef STRICT_CHECKING assert( props != NULL ); #endif for( i = 0; props[i] != NULL; i ++ ) { sample_write_property( port, props[i], node ); free(props[i]); } free(props); } static void sample_expand_properties( void *sample, const char *key, xmlNodePtr root ) { int n = vevo_property_num_elements( sample, key ); char name[KEY_LEN]; void *port = NULL; int error; if( n > 1 ) { int i; for( i = 0; i < n ; i ++ ) { error = vevo_property_get( sample, key, i, &port ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif sprintf(name, "%s%x",key,i); xmlNodePtr node = xmlNewChild(root, NULL, (const xmlChar*) name, NULL ); sample_expand_port( port, node ); } } if( n == 1 ) { error = vevo_property_get( sample, key, 0, &port ); #ifdef STRICT_CHECKING assert( error == VEVO_NO_ERROR ); #endif sample_expand_port( port, root ); } } static void sample_write_properties( void *sample, xmlNodePtr node ) { char **props = (char**) vevo_list_properties( sample ); int i; #ifdef STRICT_CHECKING assert( props != NULL ); #endif for( i = 0; props[i] != NULL; i ++ ) sample_write_property( sample, props[i], node ); } int samplebank_xml_save( const char *filename ) { const char *encoding = "UTF-8"; int i,error; xmlNodePtr rootnode, childnode; xmlDocPtr doc = xmlNewDoc( "1.0" ); rootnode = xmlNewDocNode( doc, NULL, (const xmlChar*) XMLTAG_SAMPLES, NULL ); xmlDocSetRootElement( doc, rootnode ); for( i = 1; i < samplebank_size(); i ++ ) { void *sample = find_sample( i ); if(sample) { sample_runtime_data *srd = (sample_runtime_data*) sample; #ifdef STRICT_CHECKING assert( srd->info_port != NULL ); #endif //@ save editlist! childnode = xmlNewChild(rootnode, NULL, (const xmlChar*) XMLTAG_SAMPLE, NULL ); int_as_property( childnode, srd->type, "type"); sample_write_properties( srd->info_port, childnode ); } } int ret = xmlSaveFormatFileEnc( filename, doc, encoding, 1 ); xmlFreeDoc( doc ); if( ret < 0 ) ret = 0; else ret = 1; return ret; } static int sample_identify_xml_token( int sample_type, const unsigned char *name ) { int i = 0; for( i = 0; common_property_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, common_property_list[i].name ) == 0 ) return common_property_list[i].atom_type; } if(sample_type == VJ_TAG_TYPE_NONE) { for( i = 0; sample_property_list[i].name != NULL; i ++ ) { if( strcasecmp( (const char*) name, sample_property_list[i].name ) == 0 ) return sample_property_list[i].atom_type; } } else { for( i = 0; stream_property_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, stream_property_list[i].name ) == 0 ) return stream_property_list[i].atom_type; } if( sample_type == VJ_TAG_TYPE_V4L ) { for( i = 0; stream_v4l_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, stream_v4l_list[i].name ) == 0 ) return stream_v4l_list[i].atom_type; } } if( sample_type == VJ_TAG_TYPE_NET ) { for( i = 0; stream_socket_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, stream_socket_list[i].name ) == 0 ) return stream_socket_list[i].atom_type; } } if( sample_type == VJ_TAG_TYPE_MCAST ) { for( i = 0; stream_mcast_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, stream_mcast_list[i].name ) == 0 ) return stream_mcast_list[i].atom_type; } } #ifdef HAVE_DV1394 if( sample_type == VJ_TAG_TYPE_DV1394 ) { for( i = 0; stream_dv1394_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, stream_dv1394_list[i].name ) == 0 ) return stream_dv1394_list[i].atom_type; } } #endif if( sample_type == VJ_TAG_TYPE_COLOR ) { for( i = 0; stream_color_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, stream_color_list[i].name ) == 0 ) return stream_color_list[i].atom_type; } } if( sample_type == VJ_TAG_TYPE_YUV4MPEG ) { for( i = 0; stream_file_list[i].name != NULL ; i ++ ) { if( strcasecmp( (const char*) name, stream_file_list[i].name ) == 0 ) return stream_color_list[i].atom_type; } } } return 0; } static void sample_from_xml( void *samplebank, int sample_type, xmlDocPtr doc, xmlNodePtr cur ) { #ifdef STRICT_CHECKING assert( sample_type >= 0 && sample_type <= 15 ); #endif void *sample = sample_new( sample_type ); char key[20]; while( cur != NULL ) { //@ iterate through properties! int atom_type = sample_identify_xml_token( sample_type, cur->name ); int error = 0; char *str = NULL; int int_val = 0; double dbl_val = 0.0; switch(atom_type) { case VEVO_ATOM_TYPE_INT: int_val = value_as_int( doc, cur, cur->name ); vevo_property_set( sample, cur->name, atom_type, 1,&int_val ); break; case VEVO_ATOM_TYPE_DOUBLE: dbl_val = value_as_double( doc, cur, cur->name ); vevo_property_set( sample, cur->name, atom_type, 1, &dbl_val ); break; case VEVO_ATOM_TYPE_STRING: str = value_as_cstr( doc, cur, cur->name ); vevo_property_set( sample, cur->name, atom_type, 1, &str ); break; default: #ifdef STRICT_CHECKING assert(0); #endif break; } cur = cur->next; } samplebank_add_sample( sample ); } int sample_xml_load( const char *filename, void *samplebank ) { xmlDocPtr doc; xmlNodePtr cur; doc = xmlParseFile( filename ); if(!doc) return 0; cur = xmlDocGetRootElement( doc ); if(!cur) { xmlFreeDoc(doc); return 0; } if( xmlStrcmp( cur->name, (const xmlChar*)XMLTAG_SAMPLES) ) { xmlFreeDoc( doc ); return 0; } cur = cur->xmlChildrenNode; while( cur != NULL ) { if(! xmlStrcmp( cur->name, (const xmlChar*) XMLTAG_SAMPLE) ) { int type = property_as_int( doc, cur, "type" ); sample_from_xml(samplebank, type,doc, cur->xmlChildrenNode ); } cur = cur->next; } xmlFreeDoc( doc ); return 1; } int sample_set_param_from_str( void *srd, int fx_entry,int p, const char *str ) { void *port = sample_get_fx_port_ptr( srd, fx_entry ); if(port) { void *fx_instance = NULL; int error = vevo_property_get( port, "fx_instance",0,&fx_instance ); void *fx_values = NULL; veejay_msg(0, "Entry %d, Param %d, '%s'",fx_entry,p,str); if(error == VEVO_NO_ERROR) { void *fx_values = NULL; error = vevo_property_get( port, "fx_values",0,&fx_values ); return plug_set_param_from_str( fx_instance, p, str,fx_values ); } else veejay_msg(0 ,"No fx instance on entry %d", fx_entry ); } else veejay_msg(0, "Entry %d is invalid",fx_entry); return 0; } void sample_process_fx_chain( void *srd ) { int k = 0; for( k = 0; k < SAMPLE_CHAIN_LEN; k ++ ) { void *port = sample_get_fx_port_ptr( srd, k ); void *fx_instance = NULL; int fx_status = 0; int error = vevo_property_get( port, "fx_status", 0, &fx_status); #ifdef STRICT_CHECKING assert( error == 0 ); #endif //@TODO: Alpha fading if( fx_status ) { error = vevo_property_get( port, "fx_instance", 0, &fx_instance ); #ifdef STRICT_CHECKING assert( error == 0 ); #endif plug_process( fx_instance ); void *fx_values = NULL; error = vevo_property_get( port, "fx_values", 0, &fx_values ); #ifdef STRICT_CHECKING assert( error == 0 ); #endif plug_clone_from_parameters( fx_instance, fx_values ); } } } static void edl_copy( void *sample, uint64_t start, uint64_t end ) { } static void sample_get_position_info(void *port , uint64_t *start, uint64_t *end, int *loop, int *speed) { vevo_property_get( port, "start_pos", 0,start ); vevo_property_get( port, "end_pos", 0, end ); vevo_property_get( port, "looptype",0, loop ); vevo_property_get( port, "speed",0,speed ); } static void sample_get_position_loop(void *port, int start, int end) { double fps = 0.0; vevo_property_get( port, "fps",0,&fps ); } void sample_cache_data( void *info ) { #ifdef STRICT_CHECKING assert( info != NULL ); #endif sample_runtime_data *srd = (sample_runtime_data*) info; sampleinfo_t *sit = srd->info; vevo_property_get( srd->info_port, "start_pos",0, &(sit->start_pos)); vevo_property_get( srd->info_port, "end_pos",0,&(sit->end_pos)); vevo_property_get( srd->info_port, "speed",0,&(sit->speed)); vevo_property_get( srd->info_port, "looptype",0,&(sit->looptype)); vevo_property_get( srd->info_port, "current_pos",0,&(sit->current_pos)); vevo_property_get( srd->info_port, "in_point",0,&(sit->in_point)); vevo_property_get( srd->info_port, "out_point",0,&(sit->out_point)); // veejay_msg(0, "start %d - end %d - speed %d - loop %d - position %d - in %d - out %d", // sit->start_pos,sit->end_pos,sit->speed,sit->looptype,sit->current_pos, // sit->in_point, sit->out_point ); } void sample_save_cache_data( void *info) { #ifdef STRICT_CHECKING assert( info != NULL ); #endif sample_runtime_data *srd = (sample_runtime_data*) info; sampleinfo_t *sit = srd->info; // veejay_msg(0, "SAVE: start %d - end %d - speed %d - loop - %d position %d -in - %d -out %d", /// sit->start_pos,sit->end_pos,sit->speed,sit->looptype,sit->current_pos, // sit->in_point, sit->out_point ); vevo_property_set( srd->info_port, "start_pos",VEVO_ATOM_TYPE_UINT64,1,&(sit->start_pos )); vevo_property_set( srd->info_port, "end_pos", VEVO_ATOM_TYPE_UINT64,1,&(sit->end_pos)); vevo_property_set( srd->info_port, "speed", VEVO_ATOM_TYPE_INT,1,&(sit->speed )); vevo_property_set( srd->info_port, "looptype", VEVO_ATOM_TYPE_INT,1,&(sit->looptype )); vevo_property_set( srd->info_port, "current_pos", VEVO_ATOM_TYPE_UINT64,1,&(sit->current_pos)); vevo_property_set( srd->info_port, "in_point",VEVO_ATOM_TYPE_UINT64,1,&(sit->in_point)); vevo_property_set( srd->info_port, "out_point",VEVO_ATOM_TYPE_UINT64,1,&(sit->out_point)); } int sample_valid_speed(void *sample, int new_speed) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; int sample_len = sit->end_pos - sit->start_pos; if(new_speed < sample_len) return 1; return 0; } int sample_valid_pos(void *sample, uint64_t pos) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; if(pos >= sit->start_pos && pos <= sit->end_pos ) return 1; return 0; } uint64_t sample_get_start_pos( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; return sit->start_pos; } uint64_t sample_get_end_pos( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; return sit->end_pos; } int sample_get_speed( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; return sit->speed; } uint64_t sample_get_current_pos( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; return sit->current_pos; } int sample_get_looptype( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; return sit->looptype; } int sample_has_audio( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; return sit->has_audio; } void sample_set_current_pos( void *sample, uint64_t pos ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; sit->current_pos = pos; } void sample_set_end_pos( void *sample, uint64_t pos ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; sit->end_pos = pos; } void sample_set_start_pos( void *sample, uint64_t pos ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; sit->start_pos = pos; } void sample_set_looptype( void *sample, int pos ) { sample_runtime_data *srd = (sample_runtime_data*) sample; sampleinfo_t *sit = srd->info; sit->start_pos = pos; } int sample_fx_sscanf_port( void *sample, const char *s, const char *id ) { sample_runtime_data *srd = (sample_runtime_data*) sample; int entry_id = 0; int n = sscanf( id, "fx_%02d#", &entry_id); if( n <= 0 ) return 0; //@ fx_instance must be valid return 1; } int sample_sscanf_port( void *sample, const char *s ) { sample_runtime_data *srd = (sample_runtime_data*) sample; return vevo_sscanf_port( srd->info_port, s ); } char *sample_sprintf_port( void *sample ) { sample_runtime_data *srd = (sample_runtime_data*) sample; int k; int size = 0; char **test = vevo_sprintf_port( srd->info_port ); if( test == NULL ) return NULL; for( k = 0; test[k] != NULL; k ++ ) size += strlen(test[k]); char *buf = (char*) calloc( 1,size+1 ); for( k = 0; test[k] != NULL ; k ++ ) { strcat(buf,test[k]); free(test[k]); } free(test); return buf; }