X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fframework%2Fmlt_consumer.c;h=93afe447d6a13c81ea9b00cb98c29d4799aa6d76;hb=3902731cb8a9622204d584c4962c74e2a5a35428;hp=1aab394c9d6c21bef9ff7754280dfb893d6a0809;hpb=bf3264b9e340ba5c11cbf59835a8af3db94e0cc2;p=melted diff --git a/src/framework/mlt_consumer.c b/src/framework/mlt_consumer.c index 1aab394..93afe44 100644 --- a/src/framework/mlt_consumer.c +++ b/src/framework/mlt_consumer.c @@ -1,7 +1,10 @@ -/* - * mlt_consumer.c -- abstraction for all consumer services - * Copyright (C) 2003-2004 Ushodaya Enterprises Limited - * Author: Charles Yates +/** + * \file mlt_consumer.c + * \brief abstraction for all consumer services + * \see mlt_consumer_s + * + * Copyright (C) 2003-2009 Ushodaya Enterprises Limited + * \author Charles Yates * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -18,23 +21,39 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include "config.h" #include "mlt_consumer.h" #include "mlt_factory.h" #include "mlt_producer.h" #include "mlt_frame.h" +#include "mlt_profile.h" +#include "mlt_log.h" + #include #include #include #include +/** Define this if you want an automatic deinterlace (if necessary) when the + * consumer's producer is not running at normal speed. + */ +#undef DEINTERLACE_ON_NOT_NORMAL_SPEED + static void mlt_consumer_frame_render( mlt_listener listener, mlt_properties owner, mlt_service this, void **args ); static void mlt_consumer_frame_show( mlt_listener listener, mlt_properties owner, mlt_service this, void **args ); +static void mlt_consumer_property_changed( mlt_service owner, mlt_consumer this, char *name ); +static void apply_profile_properties( mlt_consumer this, mlt_profile profile, mlt_properties properties ); -/** Public final methods -*/ +/** Initialize a consumer service. + * + * \public \memberof mlt_consumer_s + * \param this the consumer to initialize + * \param child a pointer to the object for the subclass + * \param profile the \p mlt_profile_s to use (optional but recommended, + * uses the environment variable MLT if this is NULL) + * \return true if there was an error + */ -int mlt_consumer_init( mlt_consumer this, void *child ) +int mlt_consumer_init( mlt_consumer this, void *child, mlt_profile profile ) { int error = 0; memset( this, 0, sizeof( struct mlt_consumer_s ) ); @@ -45,42 +64,16 @@ int mlt_consumer_init( mlt_consumer this, void *child ) // Get the properties from the service mlt_properties properties = MLT_SERVICE_PROPERTIES( &this->parent ); - // Get the normalisation preference - char *normalisation = mlt_environment( "MLT_NORMALISATION" ); - - // Deal with normalisation - if ( normalisation == NULL || strcmp( normalisation, "NTSC" ) ) + // Apply profile to properties + if ( profile == NULL ) { - mlt_properties_set( properties, "normalisation", "PAL" ); - mlt_properties_set_double( properties, "fps", 25.0 ); - mlt_properties_set_int( properties, "frame_rate_num", 25 ); - mlt_properties_set_int( properties, "frame_rate_den", 1 ); - mlt_properties_set_int( properties, "width", 720 ); - mlt_properties_set_int( properties, "height", 576 ); - mlt_properties_set_int( properties, "progressive", 0 ); - mlt_properties_set_double( properties, "aspect_ratio", 59.0 / 54.0 ); - mlt_properties_set_int( properties, "aspect_ratio_num", 59 ); - mlt_properties_set_int( properties, "aspect_ratio_den", 54 ); - mlt_properties_set_double( properties, "display_ratio", 4.0 / 3.0 ); - mlt_properties_set_int( properties, "display_ratio_num", 4 ); - mlt_properties_set_int( properties, "display_ratio_den", 3 ); - } - else - { - mlt_properties_set( properties, "normalisation", "NTSC" ); - mlt_properties_set_double( properties, "fps", 30000.0 / 1001.0 ); - mlt_properties_set_int( properties, "frame_rate_num", 30000 ); - mlt_properties_set_int( properties, "frame_rate_den", 1001 ); - mlt_properties_set_int( properties, "width", 720 ); - mlt_properties_set_int( properties, "height", 480 ); - mlt_properties_set_int( properties, "progressive", 0 ); - mlt_properties_set_double( properties, "aspect_ratio", 10.0 / 11.0 ); - mlt_properties_set_int( properties, "aspect_ratio_num", 10 ); - mlt_properties_set_int( properties, "aspect_ratio_den", 11 ); - mlt_properties_set_double( properties, "display_ratio", 4.0 / 3.0 ); - mlt_properties_set_int( properties, "display_ratio_num", 4 ); - mlt_properties_set_int( properties, "display_ratio_den", 3 ); + // Normally the application creates the profile and controls its lifetime + // This is the fallback exception handling + profile = mlt_profile_init( NULL ); + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_properties_set_data( properties, "_profile", profile, 0, (mlt_destructor)mlt_profile_close, NULL ); } + apply_profile_properties( this, profile, properties ); // Default rescaler for all consumers mlt_properties_set( properties, "rescale", "bilinear" ); @@ -105,6 +98,10 @@ int mlt_consumer_init( mlt_consumer this, void *child ) mlt_events_register( properties, "consumer-frame-render", ( mlt_transmitter )mlt_consumer_frame_render ); mlt_events_register( properties, "consumer-stopped", NULL ); + // Register a property-changed listener to handle the profile property - + // subsequent properties can override the profile + this->event_listener = mlt_events_listen( properties, this, "property-changed", ( mlt_listener )mlt_consumer_property_changed ); + // Create the push mutex and condition pthread_mutex_init( &this->put_mutex, NULL ); pthread_cond_init( &this->put_cond, NULL ); @@ -113,12 +110,179 @@ int mlt_consumer_init( mlt_consumer this, void *child ) return error; } +/** Convert the profile into properties on the consumer. + * + * \private \memberof mlt_consumer_s + * \param this a consumer + * \param profile a profile + * \param properties a properties list (typically, the consumer's) + */ + +static void apply_profile_properties( mlt_consumer this, mlt_profile profile, mlt_properties properties ) +{ + mlt_event_block( this->event_listener ); + mlt_properties_set_double( properties, "fps", mlt_profile_fps( profile ) ); + mlt_properties_set_int( properties, "frame_rate_num", profile->frame_rate_num ); + mlt_properties_set_int( properties, "frame_rate_den", profile->frame_rate_den ); + mlt_properties_set_int( properties, "width", profile->width ); + mlt_properties_set_int( properties, "height", profile->height ); + mlt_properties_set_int( properties, "progressive", profile->progressive ); + mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) ); + mlt_properties_set_int( properties, "sample_aspect_num", profile->sample_aspect_num ); + mlt_properties_set_int( properties, "sample_aspect_den", profile->sample_aspect_den ); + mlt_properties_set_double( properties, "display_ratio", mlt_profile_dar( profile ) ); + mlt_properties_set_int( properties, "display_aspect_num", profile->display_aspect_num ); + mlt_properties_set_int( properties, "display_aspect_num", profile->display_aspect_num ); + mlt_event_unblock( this->event_listener ); +} + +/** The property-changed event listener + * + * \private \memberof mlt_consumer_s + * \param owner the service a service (ignored) + * \param this the consumer + * \param name the name of the property that changed + */ + +static void mlt_consumer_property_changed( mlt_service owner, mlt_consumer this, char *name ) +{ + if ( !strcmp( name, "profile" ) ) + { + // Get the properies + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + + // Get the current profile + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + + // Load the new profile + mlt_profile new_profile = mlt_profile_init( mlt_properties_get( properties, name ) ); + + if ( new_profile ) + { + // Copy the profile + if ( profile != NULL ) + { + free( profile->description ); + memcpy( profile, new_profile, sizeof( struct mlt_profile_s ) ); + profile->description = strdup( new_profile->description ); + mlt_profile_close( new_profile ); + } + else + { + profile = new_profile; + } + + // Apply to properties + apply_profile_properties( this, profile, properties ); + } + } + else if ( !strcmp( name, "frame_rate_num" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + if ( profile ) + { + profile->frame_rate_num = mlt_properties_get_int( properties, "frame_rate_num" ); + mlt_properties_set_double( properties, "fps", mlt_profile_fps( profile ) ); + } + } + else if ( !strcmp( name, "frame_rate_den" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + if ( profile ) + { + profile->frame_rate_den = mlt_properties_get_int( properties, "frame_rate_den" ); + mlt_properties_set_double( properties, "fps", mlt_profile_fps( profile ) ); + } + } + else if ( !strcmp( name, "width" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + if ( profile ) + profile->width = mlt_properties_get_int( properties, "width" ); + } + else if ( !strcmp( name, "height" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + if ( profile ) + profile->height = mlt_properties_get_int( properties, "height" ); + } + else if ( !strcmp( name, "progressive" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + if ( profile ) + profile->progressive = mlt_properties_get_int( properties, "progressive" ); + } + else if ( !strcmp( name, "sample_aspect_num" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + profile->sample_aspect_num = mlt_properties_get_int( properties, "sample_aspect_num" ); + if ( profile ) + mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) ); + } + else if ( !strcmp( name, "sample_aspect_den" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + profile->sample_aspect_den = mlt_properties_get_int( properties, "sample_aspect_den" ); + if ( profile ) + mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) ); + } + else if ( !strcmp( name, "display_aspect_num" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + if ( profile ) + { + profile->display_aspect_num = mlt_properties_get_int( properties, "display_aspect_num" ); + mlt_properties_set_double( properties, "display_ratio", mlt_profile_dar( profile ) ); + } + } + else if ( !strcmp( name, "display_aspect_den" ) ) + { + mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + if ( profile ) + { + profile->display_aspect_den = mlt_properties_get_int( properties, "display_aspect_den" ); + mlt_properties_set_double( properties, "display_ratio", mlt_profile_dar( profile ) ); + } + } +} + +/** The transmitter for the consumer-frame-show event + * + * Invokes the listener. + * + * \private \memberof mlt_consumer_s + * \param listener a function pointer that will be invoked + * \param owner a properties list that will be passed to \p listener + * \param this a service that will be passed to \p listener + * \param args an array of pointers - the first entry is passed as a string to \p listener + */ + static void mlt_consumer_frame_show( mlt_listener listener, mlt_properties owner, mlt_service this, void **args ) { if ( listener != NULL ) listener( owner, this, ( mlt_frame )args[ 0 ] ); } +/** The transmitter for the consumer-frame-render event + * + * Invokes the listener. + * + * \private \memberof mlt_consumer_s + * \param listener a function pointer that will be invoked + * \param owner a properties list that will be passed to \p listener + * \param this a service that will be passed to \p listener + * \param args an array of pointers - the first entry is passed as a string to \p listener + */ + static void mlt_consumer_frame_render( mlt_listener listener, mlt_properties owner, mlt_service this, void **args ) { if ( listener != NULL ) @@ -126,23 +290,32 @@ static void mlt_consumer_frame_render( mlt_listener listener, mlt_properties own } /** Create a new consumer. -*/ + * + * \public \memberof mlt_consumer_s + * \param profile a profile (optional, but recommended) + * \return a new consumer + */ -mlt_consumer mlt_consumer_new( ) +mlt_consumer mlt_consumer_new( mlt_profile profile ) { // Create the memory for the structure mlt_consumer this = malloc( sizeof( struct mlt_consumer_s ) ); // Initialise it if ( this != NULL ) - mlt_consumer_init( this, NULL ); + mlt_consumer_init( this, NULL, profile ); // Return it return this; } /** Get the parent service object. -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \return the parent service class + * \see MLT_CONSUMER_SERVICE + */ mlt_service mlt_consumer_service( mlt_consumer this ) { @@ -150,7 +323,12 @@ mlt_service mlt_consumer_service( mlt_consumer this ) } /** Get the consumer properties. -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \return the consumer's properties list + * \see MLT_CONSUMER_PROPERTIES + */ mlt_properties mlt_consumer_properties( mlt_consumer this ) { @@ -158,7 +336,15 @@ mlt_properties mlt_consumer_properties( mlt_consumer this ) } /** Connect the consumer to the producer. -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \param producer a producer + * \return > 0 warning, == 0 success, < 0 serious error, + * 1 = this service does not accept input, + * 2 = the producer is invalid, + * 3 = the producer is already registered with this consumer + */ int mlt_consumer_connect( mlt_consumer this, mlt_service producer ) { @@ -166,26 +352,23 @@ int mlt_consumer_connect( mlt_consumer this, mlt_service producer ) } /** Start the consumer. -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \return true if there was an error + */ int mlt_consumer_start( mlt_consumer this ) { + // Stop listening to the property-changed event + mlt_event_block( this->event_listener ); + // Get the properies mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); // Determine if there's a test card producer char *test_card = mlt_properties_get( properties, "test_card" ); - // Handle profiles - char *profile = mlt_properties_get( properties, "profile" ); - int profile_ok = mlt_consumer_profile( properties, profile ); - - // Check that everything is OK - if ( !profile_ok ) - fprintf( stderr, "Unrecognised profile %s - continuing with defaults.\n", mlt_properties_get( properties, "profile" ) ); - else if ( profile_ok < 0 ) - fprintf( stderr, "Recognised profile %s with warnings - trying to continue with some defaults.\n", mlt_properties_get( properties, "profile" ) ); - // Just to make sure nothing is hanging around... mlt_frame_close( this->put ); this->put = NULL; @@ -197,7 +380,8 @@ int mlt_consumer_start( mlt_consumer this ) if ( mlt_properties_get_data( properties, "test_card_producer", NULL ) == NULL ) { // Create a test card producer - mlt_producer producer = mlt_factory_producer( NULL, test_card ); + mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( this ) ); + mlt_producer producer = mlt_factory_producer( profile, NULL, test_card ); // Do we have a producer if ( producer != NULL ) @@ -218,9 +402,15 @@ int mlt_consumer_start( mlt_consumer this ) mlt_properties_set_data( properties, "test_card_producer", NULL, 0, NULL, NULL ); } + // Set the frame duration in microseconds for the frame-dropping heuristic + int frame_duration = 1000000 / mlt_properties_get_int( properties, "frame_rate_num" ) * + mlt_properties_get_int( properties, "frame_rate_den" ); + mlt_properties_set_int( properties, "frame_duration", frame_duration ); + // Check and run an ante command if ( mlt_properties_get( properties, "ante" ) ) - system( mlt_properties_get( properties, "ante" ) ); + if ( system( mlt_properties_get( properties, "ante" ) ) == -1 ) + mlt_log( MLT_CONSUMER_SERVICE( this ), MLT_LOG_ERROR, "system(%s) failed!\n", mlt_properties_get( properties, "ante" ) ); // Set the real_time preference this->real_time = mlt_properties_get_int( properties, "real_time" ); @@ -232,9 +422,15 @@ int mlt_consumer_start( mlt_consumer this ) return 0; } -/** An alternative method to feed frames into the consumer - only valid if - the consumer itself is not connected. -*/ +/** An alternative method to feed frames into the consumer. + * + * Only valid if the consumer itself is not connected. + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \param frame a frame + * \return true (ignore this for now) + */ int mlt_consumer_put_frame( mlt_consumer this, mlt_frame frame ) { @@ -271,7 +467,11 @@ int mlt_consumer_put_frame( mlt_consumer this, mlt_frame frame ) } /** Protected method for consumer to get frames from connected service -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \return a frame + */ mlt_frame mlt_consumer_get_frame( mlt_consumer this ) { @@ -310,7 +510,7 @@ mlt_frame mlt_consumer_get_frame( mlt_consumer this ) } else { - frame = mlt_frame_init( ); + frame = mlt_frame_init( service ); } if ( frame != NULL ) @@ -338,6 +538,13 @@ mlt_frame mlt_consumer_get_frame( mlt_consumer this ) return frame; } +/** Compute the time difference between now and a time value. + * + * \private \memberof mlt_consumer_s + * \param time1 a time value to be compared against now + * \return the difference in microseconds + */ + static inline long time_difference( struct timeval *time1 ) { struct timeval time2; @@ -347,167 +554,12 @@ static inline long time_difference( struct timeval *time1 ) return time1->tv_sec * 1000000 + time1->tv_usec - time2.tv_sec * 1000000 - time2.tv_usec; } -int mlt_consumer_profile( mlt_properties properties, char *profile ) -{ - double fps = mlt_properties_get_double( properties, "fps" ); - int recognised = 1; - double display_num = 0; - double display_den = 0; - double pixel_num = 0; - double pixel_den = 0; - int width = 0; - int height = 0; - - if ( fps == 25.0 && profile != NULL ) - { - width = 720; - height = 576; - display_num = 4; - display_den = 3; - pixel_num = 59; - pixel_den = 54; - - if ( !strcmp( profile, "dv_wide" ) ) - { - display_num = 16; - display_den = 9; - pixel_num = 118; - pixel_den = 81; - } - else if ( !strncmp( profile, "square_wide", 11 ) ) - { - display_num = 16; - display_den = 9; - pixel_num = 1; - pixel_den = 1; - width = 1024; - height = 576; - } - else if ( !strncmp( profile, "square", 6 ) ) - { - pixel_num = 1; - pixel_den = 1; - width = 768; - height = 576; - } - else if ( !strncmp( profile, "vcd", 3 ) ) - { - width = 352; - height = 288; - } - else if ( !strncmp( profile, "cvd", 3 ) ) - { - width = 352; - height = 576; - pixel_num = 59; - pixel_den = 27; - } - else if ( !strncmp( profile, "svcd_wide", 9 ) ) - { - width = 480; - height = 576; - pixel_num = 59; - pixel_den = 27; - display_num = 16; - display_den = 9; - } - else if ( !strncmp( profile, "svcd", 4 ) ) - { - width = 480; - height = 576; - pixel_num = 59; - pixel_den = 36; - } - else if ( strncmp( profile, "frame", 5 ) && strcmp( profile, "dv" ) ) - { - recognised = 0; - } - } - else if ( profile != NULL ) - { - width = 720; - height = 480; - display_num = 4; - display_den = 3; - pixel_num = 10; - pixel_den = 11; - - if ( !strcmp( profile, "dv_wide" ) ) - { - display_num = 16; - display_den = 9; - pixel_num = 40; - pixel_den = 33; - } - else if ( !strncmp( profile, "square_wide", 11 ) ) - { - display_num = 16; - display_den = 9; - pixel_num = 1; - pixel_den = 1; - width = 854; - height = 480; - } - else if ( !strncmp( profile, "square", 6 ) ) - { - pixel_num = 1; - pixel_den = 1; - width = 640; - height = 480; - } - else if ( !strncmp( profile, "vcd", 3 ) ) - { - width = 352; - height = 240; - } - else if ( !strncmp( profile, "cvd", 3 ) ) - { - width = 352; - height = 480; - pixel_num = 20; - pixel_den = 11; - } - else if ( !strncmp( profile, "svcd_wide", 9 ) ) - { - width = 480; - height = 480; - pixel_num = 20; - pixel_den = 11; - display_num = 16; - display_den = 9; - } - else if ( !strncmp( profile, "svcd", 4 ) ) - { - width = 480; - height = 480; - pixel_num = 15; - pixel_den = 11; - } - else if ( strncmp( profile, "frame", 5 ) && strcmp( profile, "dv" ) ) - { - recognised = 0; - } - } - - // If width (or any of the above are 0), we use defaults otherwise we switch to recognised - if ( width != 0 && recognised ) - { - if ( recognised && strchr( profile, ':' ) ) - if ( sscanf( strchr( profile, ':' ) + 1, "%dx%d", &width, &height ) != 2 ) - recognised = -1; - - mlt_properties_set_int( properties, "width", width ); - mlt_properties_set_int( properties, "height", height ); - mlt_properties_set_double( properties, "aspect_ratio", pixel_num / pixel_den ); - mlt_properties_set_int( properties, "aspect_ratio_num", pixel_num ); - mlt_properties_set_int( properties, "aspect_ratio_den", pixel_den ); - mlt_properties_set_double( properties, "display_ratio", display_num / display_den ); - mlt_properties_set_int( properties, "display_ratio_num", display_num ); - mlt_properties_set_int( properties, "display_ratio_den", display_den ); - } - - return recognised; -} +/** The thread procedure for asynchronously pulling frames through the service + * network connected to a consumer. + * + * \private \memberof mlt_consumer_s + * \param arg a consumer + */ static void *consumer_read_ahead_thread( void *arg ) { @@ -628,7 +680,9 @@ static void *consumer_read_ahead_thread( void *arg ) // All non normal playback frames should be shown if ( mlt_properties_get_int( MLT_FRAME_PROPERTIES( frame ), "_speed" ) != 1 ) { +#ifdef DEINTERLACE_ON_NOT_NORMAL_SPEED mlt_properties_set_int( MLT_FRAME_PROPERTIES( frame ), "consumer_deinterlace", 1 ); +#endif skipped = 0; time_frame = 0; time_process = 0; @@ -638,7 +692,7 @@ static void *consumer_read_ahead_thread( void *arg ) } // Get the image - if ( !skip_next ) + if ( !skip_next || this->real_time == -1 ) { // Get the image, mark as rendered and time it if ( !video_off ) @@ -676,8 +730,12 @@ static void *consumer_read_ahead_thread( void *arg ) time_process += time_difference( &ante ); // Determine if the next frame should be skipped - if ( mlt_deque_count( this->queue ) <= 5 && ( ( time_wait + time_frame + time_process ) / count ) > 40000 ) - skip_next = 1; + if ( mlt_deque_count( this->queue ) <= 5 ) + { + int frame_duration = mlt_properties_get_int( properties, "frame_duration" ); + if ( ( ( time_wait + time_frame + time_process ) / count ) > frame_duration ) + skip_next = 1; + } // Unlock if there's a lock object if ( lock_object ) mlt_service_unlock( lock_object ); @@ -689,6 +747,12 @@ static void *consumer_read_ahead_thread( void *arg ) return NULL; } +/** Start the read/render thread. + * + * \private \memberof mlt_consumer_s + * \param this a consumer + */ + static void consumer_read_ahead_start( mlt_consumer this ) { // We're running now @@ -703,10 +767,33 @@ static void consumer_read_ahead_start( mlt_consumer this ) // Create the condition pthread_cond_init( &this->cond, NULL ); - // Create the read ahead - pthread_create( &this->ahead_thread, NULL, consumer_read_ahead_thread, this ); + // Create the read ahead + if ( mlt_properties_get( MLT_CONSUMER_PROPERTIES( this ), "priority" ) ) + { + struct sched_param priority; + priority.sched_priority = mlt_properties_get_int( MLT_CONSUMER_PROPERTIES( this ), "priority" ); + pthread_attr_t thread_attributes; + pthread_attr_init( &thread_attributes ); + pthread_attr_setschedpolicy( &thread_attributes, SCHED_OTHER ); + pthread_attr_setschedparam( &thread_attributes, &priority ); + pthread_attr_setinheritsched( &thread_attributes, PTHREAD_EXPLICIT_SCHED ); + pthread_attr_setscope( &thread_attributes, PTHREAD_SCOPE_SYSTEM ); + if ( pthread_create( &this->ahead_thread, &thread_attributes, consumer_read_ahead_thread, this ) < 0 ) + pthread_create( &this->ahead_thread, NULL, consumer_read_ahead_thread, this ); + pthread_attr_destroy( &thread_attributes ); + } + else + { + pthread_create( &this->ahead_thread, NULL, consumer_read_ahead_thread, this ); + } } +/** Stop the read/render thread. + * + * \private \memberof mlt_consumer_s + * \param this a consumer + */ + static void consumer_read_ahead_stop( mlt_consumer this ) { // Make sure we're running @@ -743,6 +830,12 @@ static void consumer_read_ahead_stop( mlt_consumer this ) } } +/** Flush the read/render thread's buffer. + * + * \public \memberof mlt_consumer_s + * \param this a consumer + */ + void mlt_consumer_purge( mlt_consumer this ) { if ( this->ahead ) @@ -755,6 +848,17 @@ void mlt_consumer_purge( mlt_consumer this ) } } +/** Get the next frame from the producer connected to a consumer. + * + * Typically, one uses this instead of \p mlt_consumer_get_frame to make + * the asynchronous/real-time behavior configurable at runtime. + * You should close the frame returned from this when you are done with it. + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \return a frame + */ + mlt_frame mlt_consumer_rt_frame( mlt_consumer this ) { // Frame to return @@ -777,7 +881,7 @@ mlt_frame mlt_consumer_rt_frame( mlt_consumer this ) if ( buffer > 1 ) size = prefill > 0 && prefill < buffer ? prefill : buffer; } - + // Get frame from queue pthread_mutex_lock( &this->mutex ); while( this->ahead && mlt_deque_count( this->queue ) < size ) @@ -800,37 +904,44 @@ mlt_frame mlt_consumer_rt_frame( mlt_consumer this ) } /** Callback for the implementation to indicate a stopped condition. -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + */ void mlt_consumer_stopped( mlt_consumer this ) { mlt_properties_set_int( MLT_CONSUMER_PROPERTIES( this ), "running", 0 ); mlt_events_fire( MLT_CONSUMER_PROPERTIES( this ), "consumer-stopped", NULL ); + mlt_event_unblock( this->event_listener ); } /** Stop the consumer. -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \return true if there was an error + */ int mlt_consumer_stop( mlt_consumer this ) { // Get the properies mlt_properties properties = MLT_CONSUMER_PROPERTIES( this ); - char *debug = mlt_properties_get( MLT_CONSUMER_PROPERTIES( this ), "debug" ); // Just in case... - if ( debug ) fprintf( stderr, "%s: stopping put waiting\n", debug ); + mlt_log( MLT_CONSUMER_SERVICE( this ), MLT_LOG_DEBUG, "stopping put waiting\n" ); pthread_mutex_lock( &this->put_mutex ); this->put_active = 0; pthread_cond_broadcast( &this->put_cond ); pthread_mutex_unlock( &this->put_mutex ); // Stop the consumer - if ( debug ) fprintf( stderr, "%s: stopping consumer\n", debug ); + mlt_log( MLT_CONSUMER_SERVICE( this ), MLT_LOG_DEBUG, "stopping consumer\n" ); if ( this->stop != NULL ) this->stop( this ); // Check if the user has requested real time or not and stop if necessary - if ( debug ) fprintf( stderr, "%s: stopping read_ahead\n", debug ); + mlt_log( MLT_CONSUMER_SERVICE( this ), MLT_LOG_DEBUG, "stopping read_ahead\n" ); if ( mlt_properties_get_int( properties, "real_time" ) ) consumer_read_ahead_stop( this ); @@ -839,15 +950,20 @@ int mlt_consumer_stop( mlt_consumer this ) // Check and run a post command if ( mlt_properties_get( properties, "post" ) ) - system( mlt_properties_get( properties, "post" ) ); + if (system( mlt_properties_get( properties, "post" ) ) == -1 ) + mlt_log( MLT_CONSUMER_SERVICE( this ), MLT_LOG_ERROR, "system(%s) failed!\n", mlt_properties_get( properties, "post" ) ); - if ( debug ) fprintf( stderr, "%s: stopped\n", debug ); + mlt_log( MLT_CONSUMER_SERVICE( this ), MLT_LOG_DEBUG, "stopped\n" ); return 0; } /** Determine if the consumer is stopped. -*/ + * + * \public \memberof mlt_consumer_s + * \param this a consumer + * \return true if the consumer is stopped + */ int mlt_consumer_is_stopped( mlt_consumer this ) { @@ -858,8 +974,11 @@ int mlt_consumer_is_stopped( mlt_consumer this ) return 0; } -/** Close the consumer. -*/ +/** Close and destroy the consumer. + * + * \public \memberof mlt_consumer_s + * \param this a consumer + */ void mlt_consumer_close( mlt_consumer this ) {