2 * filter_data_show.c -- data feed filter
3 * Copyright (C) 2004-2005 Ushodaya Enterprises Limited
4 * Author: Charles Yates <charles.yates@pandora.be>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <framework/mlt.h>
25 /** Handle the profile.
28 static mlt_filter
obtain_filter( mlt_filter filter
, char *type
)
31 mlt_filter result
= NULL
;
33 // Miscelaneous variable
35 int type_len
= strlen( type
);
37 // Get the properties of the data show filter
38 mlt_properties filter_properties
= MLT_FILTER_PROPERTIES( filter
);
40 // Get the profile properties
41 mlt_properties profile_properties
= mlt_properties_get_data( filter_properties
, "profile_properties", NULL
);
43 // Obtain the profile_properties if we haven't already
44 if ( profile_properties
== NULL
)
48 // Get the profile requested
49 char *profile
= mlt_properties_get( filter_properties
, "resource" );
51 // If none is specified, pick up the default for this normalisation
52 if ( profile
== NULL
)
53 sprintf( temp
, "%s/feeds/%s/data_fx.properties", mlt_environment( "MLT_DATA" ), mlt_environment( "MLT_NORMALISATION" ) );
54 else if ( strchr( profile
, '%' ) )
55 sprintf( temp
, "%s/feeds/%s/%s", mlt_environment( "MLT_DATA" ), mlt_environment( "MLT_NORMALISATION" ), strchr( profile
, '%' ) + 1 );
57 strcpy( temp
, profile
);
59 // Load the specified profile or use the default
60 profile_properties
= mlt_properties_load( temp
);
62 // Store for later retrieval
63 mlt_properties_set_data( filter_properties
, "profile_properties", profile_properties
, 0, ( mlt_destructor
)mlt_properties_close
, NULL
);
66 if ( profile_properties
!= NULL
)
68 for ( i
= 0; i
< mlt_properties_count( profile_properties
); i
++ )
70 char *name
= mlt_properties_get_name( profile_properties
, i
);
71 char *value
= mlt_properties_get_value( profile_properties
, i
);
73 if ( result
== NULL
&& !strcmp( name
, type
) && result
== NULL
)
74 result
= mlt_factory_filter( mlt_service_profile( MLT_FILTER_SERVICE( filter
) ), value
, NULL
);
75 else if ( result
!= NULL
&& !strncmp( name
, type
, type_len
) && name
[ type_len
] == '.' )
76 mlt_properties_set( MLT_FILTER_PROPERTIES( result
), name
+ type_len
+ 1, value
);
77 else if ( result
!= NULL
)
85 /** Retrieve medatata value
88 char* metadata_value(mlt_properties properties
, char* name
)
90 if (name
== NULL
) return NULL
;
91 char *meta
= malloc( strlen(name
) + 18 );
92 sprintf( meta
, "meta.attr.%s.markup", name
);
93 char *result
= mlt_properties_get( properties
, meta
);
98 /** Convert frames to Timecode
101 char* frame_to_timecode( int frames
, int fps
)
103 if (fps
== 0) return strdup("-");
104 char *res
= malloc(12);
105 int seconds
= frames
/ (int) fps
;
106 frames
= frames
% ((int) fps
);
107 int minutes
= seconds
/ 60;
108 seconds
= seconds
% 60;
109 int hours
= minutes
/ 60;
110 minutes
= minutes
% 60;
111 sprintf(res
, "%.2d:%.2d:%.2d:%.2d", hours
, minutes
, seconds
, frames
);
115 /** Process the frame for the requested type
118 static int process_feed( mlt_properties feed
, mlt_filter filter
, mlt_frame frame
)
123 // Get the properties of the data show filter
124 mlt_properties filter_properties
= MLT_FILTER_PROPERTIES( filter
);
126 // Get the type requested by the feeding filter
127 char *type
= mlt_properties_get( feed
, "type" );
129 // Fetch the filter associated to this type
130 mlt_filter requested
= mlt_properties_get_data( filter_properties
, type
, NULL
);
132 // If it doesn't exist, then create it now
133 if ( requested
== NULL
)
135 // Source filter from profile
136 requested
= obtain_filter( filter
, type
);
138 // Store it on the properties for subsequent retrieval/destruction
139 mlt_properties_set_data( filter_properties
, type
, requested
, 0, ( mlt_destructor
)mlt_filter_close
, NULL
);
142 // If we have one, then process it now...
143 if ( requested
!= NULL
)
146 mlt_properties properties
= MLT_FILTER_PROPERTIES( requested
);
147 static const char *prefix
= "properties.";
148 int len
= strlen( prefix
);
150 // Determine if this is an absolute or relative feed
151 int absolute
= mlt_properties_get_int( feed
, "absolute" );
153 // Make do with what we have
154 int length
= !absolute ?
155 mlt_properties_get_int( feed
, "out" ) - mlt_properties_get_int( feed
, "in" ) + 1 :
156 mlt_properties_get_int( feed
, "out" ) + 1;
159 int period
= mlt_properties_get_int( properties
, "period" );
160 period
= period
== 0 ?
1 : period
;
162 // Pass properties from feed into requested
163 for ( i
= 0; i
< mlt_properties_count( properties
); i
++ )
165 char *name
= mlt_properties_get_name( properties
, i
);
166 char *key
= mlt_properties_get_value( properties
, i
);
167 if ( !strncmp( name
, prefix
, len
) )
169 if ( !strncmp( name
+ len
, "length[", 7 ) )
171 mlt_properties_set_position( properties
, key
, ( length
- period
) / period
);
175 char *value
= mlt_properties_get( feed
, name
+ len
);
178 // check for metadata keywords in metadata markup if user requested so
179 if ( mlt_properties_get_int( filter_properties
, "dynamic" ) == 1 && !strcmp( name
+ strlen( name
) - 6, "markup") )
181 // Find keywords which should be surrounded by '#', like: #title#
182 char* keywords
= strtok( value
, "#" );
183 char result
[512] = ""; // XXX: how much is enough?
185 int fromStart
= ( value
[0] == '#' ) ?
1 : 0;
187 while ( keywords
!= NULL
)
189 if ( ct
% 2 == fromStart
)
191 // backslash in front of # suppresses substitution
192 if ( keywords
[ strlen( keywords
) -1 ] == '\\' )
194 // keep characters except backslash
195 strncat( result
, keywords
, strlen( keywords
) -1 );
196 strcat( result
, "#" );
201 strcat( result
, keywords
);
204 else if ( !strcmp( keywords
, "timecode" ) )
206 // special case: replace #timecode# with current frame timecode
207 int pos
= mlt_properties_get_int( feed
, "position" );
208 char *tc
= frame_to_timecode( pos
, mlt_profile_fps( mlt_service_profile( MLT_FILTER_SERVICE( filter
) ) ) );
209 strcat( result
, tc
);
214 // replace keyword with metadata value
215 char *metavalue
= metadata_value( MLT_FRAME_PROPERTIES( frame
), keywords
);
216 strcat( result
, metavalue ? metavalue
: "-" );
218 keywords
= strtok( NULL
, "#" );
221 mlt_properties_set( properties
, key
, (char*) result
);
223 else mlt_properties_set( properties
, key
, value
);
229 // Set the original position on the frame
231 mlt_frame_set_position( frame
, mlt_properties_get_int( feed
, "position" ) - mlt_properties_get_int( feed
, "in" ) );
233 mlt_frame_set_position( frame
, mlt_properties_get_int( feed
, "position" ) );
235 // Process the filter
236 mlt_filter_process( requested
, frame
);
245 void process_queue( mlt_deque data_queue
, mlt_frame frame
, mlt_filter filter
)
247 if ( data_queue
!= NULL
)
249 // Create a new queue for those that we can't handle
250 mlt_deque temp_queue
= mlt_deque_init( );
252 // Iterate through each entry on the queue
253 while ( mlt_deque_peek_front( data_queue
) != NULL
)
256 mlt_properties feed
= mlt_deque_pop_front( data_queue
);
258 if ( mlt_properties_get( MLT_FILTER_PROPERTIES( filter
), "debug" ) != NULL
)
259 mlt_properties_debug( feed
, mlt_properties_get( MLT_FILTER_PROPERTIES( filter
), "debug" ), stderr
);
261 // Process the data feed...
262 if ( process_feed( feed
, filter
, frame
) == 0 )
263 mlt_properties_close( feed
);
265 mlt_deque_push_back( temp_queue
, feed
);
268 // Now put the unprocessed feeds back on the stack
269 while ( mlt_deque_peek_front( temp_queue
) )
272 mlt_properties feed
= mlt_deque_pop_front( temp_queue
);
274 // Put it back on the data queue
275 mlt_deque_push_back( data_queue
, feed
);
278 // Close the temporary queue
279 mlt_deque_close( temp_queue
);
286 static int filter_get_image( mlt_frame frame
, uint8_t **image
, mlt_image_format
*format
, int *width
, int *height
, int writable
)
289 mlt_filter filter
= mlt_frame_pop_service( frame
);
291 // Get the frame properties
292 mlt_properties frame_properties
= MLT_FRAME_PROPERTIES( frame
);
295 process_queue( mlt_properties_get_data( frame_properties
, "data_queue", NULL
), frame
, filter
);
298 process_queue( mlt_properties_get_data( frame_properties
, "global_queue", NULL
), frame
, filter
);
300 // Need to get the image
301 return mlt_frame_get_image( frame
, image
, format
, width
, height
, 1 );
305 /** Filter processing.
308 static mlt_frame
filter_process( mlt_filter
this, mlt_frame frame
)
311 mlt_frame_push_service( frame
, this );
313 // Register the get image method
314 mlt_frame_push_get_image( frame
, filter_get_image
);
320 /** Constructor for the filter.
323 mlt_filter
filter_data_show_init( mlt_profile profile
, mlt_service_type type
, const char *id
, void *arg
)
326 mlt_filter
this = mlt_filter_new( );
331 // Get the properties
332 mlt_properties properties
= MLT_FILTER_PROPERTIES( this );
334 // Assign the argument (default to titles)
335 mlt_properties_set( properties
, "resource", arg
== NULL ? NULL
: arg
);
337 // Specify the processing method
338 this->process
= filter_process
;