* \brief Property class definition
* \see mlt_property_s
*
- * Copyright (C) 2003-2009 Ushodaya Enterprises Limited
+ * Copyright (C) 2003-2013 Ushodaya Enterprises Limited
* \author Charles Yates <charles.yates@pandora.be>
+ * \author Dan Dennedy <dan@dennedy.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
/** Parse a SMIL clock value.
*
* \private \memberof mlt_property_s
+ * \param self a property
* \param s the string to parse
* \param fps frames per second
* \param locale the locale to use for parsing a real number value
* \return position in frames
*/
-static int time_clock_to_frames( const char *s, double fps, locale_t locale )
+static int time_clock_to_frames( mlt_property self, const char *s, double fps, locale_t locale )
{
char *pos, *copy = strdup( s );
int hours = 0, minutes = 0;
s = copy;
pos = strrchr( s, ':' );
+
+#if !defined(__GLIBC__) && !defined(__DARWIN__)
+ char *orig_localename = NULL;
+ if ( locale )
+ {
+ // Protect damaging the global locale from a temporary locale on another thread.
+ pthread_mutex_lock( &self->mutex );
+
+ // Get the current locale
+ orig_localename = strdup( setlocale( LC_NUMERIC, NULL ) );
+
+ // Set the new locale
+ setlocale( LC_NUMERIC, locale );
+ }
+#endif
+
if ( pos ) {
#if defined(__GLIBC__) || defined(__DARWIN__)
if ( locale )
#endif
seconds = strtod( s, NULL );
}
+
+#if !defined(__GLIBC__) && !defined(__DARWIN__)
+ if ( locale ) {
+ // Restore the current locale
+ setlocale( LC_NUMERIC, orig_localename );
+ free( orig_localename );
+ pthread_mutex_unlock( &self->mutex );
+ }
+#endif
+
free( copy );
return lrint( fps * ( (hours * 3600) + (minutes * 60) + seconds ) );
/** Parse a SMPTE timecode string.
*
* \private \memberof mlt_property_s
+ * \param self a property
* \param s the string to parse
* \param fps frames per second
* \return position in frames
*/
-static int time_code_to_frames( const char *s, double fps )
+static int time_code_to_frames( mlt_property self, const char *s, double fps )
{
char *pos, *copy = strdup( s );
int hours = 0, minutes = 0, seconds = 0, frames;
* contains a period or comma character, the string is parsed as a clock value:
* HH:MM:SS. Otherwise, the time value is parsed as a SMPTE timecode: HH:MM:SS:FF.
* \private \memberof mlt_property_s
- * \param value a string to convert
+ * \param self a property
* \param fps frames per second, used when converting from time value
* \param locale the locale to use when converting from time clock value
* \return the resultant integer
*/
-static int mlt_property_atoi( const char *value, double fps, locale_t locale )
+static int mlt_property_atoi( mlt_property self, double fps, locale_t locale )
{
+ const char *value = self->prop_string;
+
// Parse a hex color value as #RRGGBB or #AARRGGBB.
if ( value[0] == '#' )
{
else if ( fps > 0 && strchr( value, ':' ) )
{
if ( strchr( value, '.' ) || strchr( value, ',' ) )
- return time_clock_to_frames( value, fps, locale );
+ return time_clock_to_frames( self, value, fps, locale );
else
- return time_code_to_frames( value, fps );
+ return time_code_to_frames( self, value, fps );
}
else
{
else if ( self->types & mlt_prop_rect && self->data )
return ( int ) ( (mlt_rect*) self->data )->x;
else if ( ( self->types & mlt_prop_string ) && self->prop_string )
- return mlt_property_atoi( self->prop_string, fps, locale );
+ return mlt_property_atoi( self, fps, locale );
return 0;
}
* If the numeric string ends with '%' then the value is divided by 100 to convert
* it into a ratio.
* \private \memberof mlt_property_s
- * \param value the string to convert
+ * \param self a property
* \param fps frames per second, used when converting from time value
* \param locale the locale to use when converting from time clock value
* \return the resultant real number
*/
-static double mlt_property_atof( const char *value, double fps, locale_t locale )
+static double mlt_property_atof( mlt_property self, double fps, locale_t locale )
{
- if ( fps > 0 && strchr( value, ':' ) )
+ const char *value = self->prop_string;
+
+ if ( fps > 0 && strchr( value, ':' ) )
{
if ( strchr( value, '.' ) || strchr( value, ',' ) )
- return time_clock_to_frames( value, fps, locale );
+ return time_clock_to_frames( self, value, fps, locale );
else
- return time_code_to_frames( value, fps );
+ return time_code_to_frames( self, value, fps );
}
else
{
char *end = NULL;
double result;
+
#if defined(__GLIBC__) || defined(__DARWIN__)
if ( locale )
result = strtod_l( value, &end, locale );
-#endif
else
+#else
+ char *orig_localename = NULL;
+ if ( locale ) {
+ // Protect damaging the global locale from a temporary locale on another thread.
+ pthread_mutex_lock( &self->mutex );
+
+ // Get the current locale
+ orig_localename = strdup( setlocale( LC_NUMERIC, NULL ) );
+
+ // Set the new locale
+ setlocale( LC_NUMERIC, locale );
+ }
+#endif
+
result = strtod( value, &end );
if ( end && end[0] == '%' )
result /= 100.0;
+
+#if !defined(__GLIBC__) && !defined(__DARWIN__)
+ if ( locale ) {
+ // Restore the current locale
+ setlocale( LC_NUMERIC, orig_localename );
+ free( orig_localename );
+ pthread_mutex_unlock( &self->mutex );
+ }
+#endif
+
return result;
}
}
else if ( self->types & mlt_prop_rect && self->data )
return ( (mlt_rect*) self->data )->x;
else if ( ( self->types & mlt_prop_string ) && self->prop_string )
- return mlt_property_atof( self->prop_string, fps, locale );
+ return mlt_property_atof( self, fps, locale );
return 0;
}
else if ( self->types & mlt_prop_rect && self->data )
return ( mlt_position ) ( (mlt_rect*) self->data )->x;
else if ( ( self->types & mlt_prop_string ) && self->prop_string )
- return ( mlt_position )mlt_property_atoi( self->prop_string, fps, locale );
+ return ( mlt_position )mlt_property_atoi( self, fps, locale );
return 0;
}
#elif defined(__GLIBC__)
const char *localename = locale->__names[ LC_NUMERIC ];
#else
- // TODO: not yet sure what to do on other platforms
- const char *localename = "";
+ const char *localename = locale;
#endif
// Protect damaging the global locale from a temporary locale on another thread.
pthread_mutex_lock( &self->mutex );
self->destructor = free;
self->serialiser = that->serialiser;
}
- else if ( self->types & mlt_prop_data && self->serialiser != NULL )
+ else if ( self->types & mlt_prop_data && that->serialiser != NULL )
{
self->types = mlt_prop_string;
- self->prop_string = self->serialiser( self->data, self->length );
+ self->prop_string = that->serialiser( that->data, that->length );
}
pthread_mutex_unlock( &self->mutex );
}
char *mlt_property_get_time( mlt_property self, mlt_time_format format, double fps, locale_t locale )
{
char *orig_localename = NULL;
- const char *localename = "";
+ const char *localename = "C";
// Optimization for mlt_time_frames
if ( format == mlt_time_frames )
return self->prop_string;
}
+/** Determine if the property holds a numeric or numeric string value.
+ *
+ * \private \memberof mlt_property_s
+ * \param self a property
+ * \param locale the locale to use for string evaluation
+ * \return true if it is numeric
+ */
+
static int is_property_numeric( mlt_property self, locale_t locale )
{
int result = ( self->types & mlt_prop_int ) ||
{
double temp;
char *p = NULL;
+
#if defined(__GLIBC__) || defined(__DARWIN__)
if ( locale )
temp = strtod_l( self->prop_string, &p, locale );
else
+#else
+ char *orig_localename = NULL;
+ if ( locale ) {
+ // Protect damaging the global locale from a temporary locale on another thread.
+ pthread_mutex_lock( &self->mutex );
+
+ // Get the current locale
+ orig_localename = strdup( setlocale( LC_NUMERIC, NULL ) );
+
+ // Set the new locale
+ setlocale( LC_NUMERIC, locale );
+ }
#endif
+
temp = strtod( self->prop_string, &p );
+
+#if !defined(__GLIBC__) && !defined(__DARWIN__)
+ if ( locale ) {
+ // Restore the current locale
+ setlocale( LC_NUMERIC, orig_localename );
+ free( orig_localename );
+ pthread_mutex_unlock( &self->mutex );
+ }
+#endif
+
result = ( p != self->prop_string );
}
return result;
}
+/** A linear interpolation function for animation.
+ *
+ * \private \memberof mlt_property_s
+ */
+
static inline double linear_interpolate( double y1, double y2, double t )
{
return y1 + ( y2 - y1 ) * t;
}
-// For non-closed curves, you need to also supply the tangent vector at the first and last control point.
-// This is commonly done: T(P[0]) = P[1] - P[0] and T(P[n]) = P[n] - P[n-1].
+/** A smooth spline interpolation for animation.
+ *
+ * For non-closed curves, you need to also supply the tangent vector at the first and last control point.
+ * This is commonly done: T(P[0]) = P[1] - P[0] and T(P[n]) = P[n] - P[n-1].
+ * \private \memberof mlt_property_s
+ */
+
static inline double catmull_rom_interpolate( double y0, double y1, double y2, double y3, double t )
{
double t2 = t * t;
return a0 * t * t2 + a1 * t2 + a2 * t + a3;
}
+/** Interpolate a new property value given a set of other properties.
+ *
+ * \public \memberof mlt_property_s
+ * \param self the property onto which to set the computed value
+ * \param p an array of at least 1 value in p[1] if \p interp is discrete,
+ * 2 values in p[1] and p[2] if \p interp is linear, or
+ * 4 values in p[0] - p[3] if \p interp is smooth
+ * \param progress a ratio in the range [0, 1] to indicate how far between p[1] and p[2]
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param interp the interpolation method to use
+ * \return true if there was an error
+ */
+
int mlt_property_interpolate( mlt_property self, mlt_property p[],
double progress, double fps, locale_t locale, mlt_keyframe_type interp )
{
}
else
{
- double value;
+ double value = 0.0;
if ( interp == mlt_keyframe_linear )
{
double points[2];
return error;
}
+/** Create a new animation or refresh an existing one.
+ *
+ * \private \memberof mlt_property_s
+ * \param self a property
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ */
+
static void refresh_animation( mlt_property self, double fps, locale_t locale, int length )
{
if ( !self->animation )
else
{
mlt_animation_set_length( self->animation, length );
+ pthread_mutex_lock( &self->mutex );
self->types |= mlt_prop_data;
self->data = self->animation;
self->serialiser = (mlt_serialiser) mlt_animation_serialize;
+ pthread_mutex_unlock( &self->mutex );
}
}
else if ( self->prop_string )
}
}
+/** Get the real number at a frame position.
+ *
+ * \public \memberof mlt_property_s
+ * \param self a property
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \return the real number
+ */
+
double mlt_property_anim_get_double( mlt_property self, double fps, locale_t locale, int position, int length )
{
+ pthread_mutex_lock( &self->mutex );
double result;
if ( self->animation || ( ( self->types & mlt_prop_string ) && self->prop_string ) )
{
{
result = mlt_property_get_double( self, fps, locale );
}
+ pthread_mutex_unlock( &self->mutex );
return result;
}
+/** Get the property as an integer number at a frame position.
+ *
+ * \public \memberof mlt_property_s
+ * \param self a property
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \return an integer value
+ */
+
int mlt_property_anim_get_int( mlt_property self, double fps, locale_t locale, int position, int length )
{
+ pthread_mutex_lock( &self->mutex );
int result;
if ( self->animation || ( ( self->types & mlt_prop_string ) && self->prop_string ) )
{
{
result = mlt_property_get_int( self, fps, locale );
}
+ pthread_mutex_unlock( &self->mutex );
return result;
}
+/** Get the string at certain a frame position.
+ *
+ * \public \memberof mlt_property_s
+ * \param self a property
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \return the string representation of the property or NULL if failed
+ */
+
char* mlt_property_anim_get_string( mlt_property self, double fps, locale_t locale, int position, int length )
{
+ pthread_mutex_lock( &self->mutex );
char *result;
if ( self->animation || ( ( self->types & mlt_prop_string ) && self->prop_string ) )
{
refresh_animation( self, fps, locale, length );
mlt_animation_get_item( self->animation, &item, position );
- pthread_mutex_lock( &self->mutex );
if ( self->prop_string )
free( self->prop_string );
self->prop_string = mlt_property_get_string_l( item.property, locale );
if ( self->prop_string )
self->prop_string = strdup( self->prop_string );
self->types |= mlt_prop_string;
- pthread_mutex_unlock( &self->mutex );
result = self->prop_string;
mlt_property_close( item.property );
{
result = mlt_property_get_string_l( self, locale );
}
+ pthread_mutex_unlock( &self->mutex );
return result;
}
* \public \memberof mlt_property_s
* \param self a property
* \param value a double precision floating point value
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \param keyframe_type the interpolation method for this keyframe
* \return false if successful, true to indicate error
*/
*
* \public \memberof mlt_property_s
* \param self a property
- * \param value a double precision floating point value
+ * \param value an integer
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \param keyframe_type the interpolation method for this keyframe
* \return false if successful, true to indicate error
*/
return result;
}
+/** Set a property animation keyframe to a string.
+ *
+ * Strings only support discrete animation. Do not use this to set a property's
+ * animation string that contains a semicolon-delimited set of values; use
+ * mlt_property_set() for that.
+ * \public \memberof mlt_property_s
+ * \param self a property
+ * \param value a string
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \return false if successful, true to indicate error
+ */
+
int mlt_property_anim_set_string( mlt_property self, const char *value, double fps, locale_t locale, int position, int length )
{
int result;
return result;
}
+/** Get an object's animation object.
+ *
+ * You might need to call another mlt_property_anim_ function to actually construct
+ * the animation, as this is a simple accessor function.
+ * \public \memberof mlt_property_s
+ * \param self a property
+ * \return the animation object or NULL if there is no animation
+ */
+
mlt_animation mlt_property_get_animation( mlt_property self )
{
- return self->animation;
+ return self->animation;
}
+/** Convert a rectangle value into a string.
+ *
+ * Unlike the deprecated mlt_geometry API, the canonical form of a mlt_rect
+ * is a space delimited "x y w h o" even though many kinds of field delimiters
+ * may be used to convert a string to a rectangle.
+ * \private \memberof mlt_property_s
+ * \param rect the rectangle to convert
+ * \param length not used
+ * \return the string representation of a rectangle
+ */
+
static char* serialise_mlt_rect( mlt_rect *rect, int length )
{
char* result = calloc( 1, 100 );
*
* \public \memberof mlt_property_s
* \param self a property
- * \param value a mlt_rect
+ * \param value a rectangle
* \return false
*/
return 0;
}
-/** Get the property as a floating point.
+/** Get the property as a rectangle.
*
+ * You can use any non-numeric character(s) as a field delimiter.
+ * If the number has a '%' immediately following it, the number is divided by
+ * 100 to convert it into a real number.
* \public \memberof mlt_property_s
* \param self a property
- * \param fps frames per second, used when converting from time value
- * \param locale the locale to use for this conversion
+ * \param locale the locale to use for when converting from a string
* \return a rectangle value
*/
rect.x = ( double )self->prop_int64;
else if ( ( self->types & mlt_prop_string ) && self->prop_string )
{
- //return mlt_property_atof( self->prop_string, fps, locale );
char *value = self->prop_string;
char *p = NULL;
int count = 0;
+
+#if !defined(__GLIBC__) && !defined(__DARWIN__)
+ char *orig_localename = NULL;
+ if ( locale ) {
+ // Protect damaging the global locale from a temporary locale on another thread.
+ pthread_mutex_lock( &self->mutex );
+
+ // Get the current locale
+ orig_localename = strdup( setlocale( LC_NUMERIC, NULL ) );
+
+ // Set the new locale
+ setlocale( LC_NUMERIC, locale );
+ }
+#endif
+
while ( *value )
{
double temp;
#if defined(__GLIBC__) || defined(__DARWIN__)
if ( locale )
temp = strtod_l( value, &p, locale );
+ else
#endif
- else
temp = strtod( value, &p );
if ( p != value )
{
if ( p[0] == '%' )
+ {
temp /= 100.0;
+ p ++;
+ }
+
+ // Chomp the delimiter.
if ( *p ) p ++;
+
+ // Assign the value to appropriate field.
switch( count )
{
case 0: rect.x = temp; break;
value = p;
count ++;
}
- }
+
+#if !defined(__GLIBC__) && !defined(__DARWIN__)
+ if ( locale ) {
+ // Restore the current locale
+ setlocale( LC_NUMERIC, orig_localename );
+ free( orig_localename );
+ pthread_mutex_unlock( &self->mutex );
+ }
+#endif
+ }
return rect;
}
* \public \memberof mlt_property_s
* \param self a property
* \param value a rectangle
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \param keyframe_type the interpolation method for this keyframe
* \return false if successful, true to indicate error
*/
return result;
}
+/** Get a rectangle at a frame position.
+ *
+ * \public \memberof mlt_property_s
+ * \param self a property
+ * \param fps the frame rate, which may be needed for converting a time string to frame units
+ * \param locale the locale, which may be needed for converting a string to a real number
+ * \param position the frame number
+ * \param length the maximum number of frames when interpreting negative keyframe times,
+ * <=0 if you don't care or need that
+ * \return the rectangle
+ */
+
mlt_rect mlt_property_anim_get_rect( mlt_property self, double fps, locale_t locale, int position, int length )
{
+ pthread_mutex_lock( &self->mutex );
mlt_rect result;
if ( self->animation || ( ( self->types & mlt_prop_string ) && self->prop_string ) )
{
{
result = mlt_property_get_rect( self, locale );
}
+ pthread_mutex_unlock( &self->mutex );
return result;
}
projects / mlt / blobdiff