Improved push capabilities

git-svn-id: https://mlt.svn.sourceforge.net/svnroot/mlt/trunk/mlt@476 d19143bc-622f-0410-bfdd-b5b2a6649095

diff --git a/src/miracle/miracle_connection.c b/src/miracle/miracle_connection.c
index 51b1a0b..30eef7a 100644 (file)
--- a/src/miracle/miracle_connection.c
+++ b/src/miracle/miracle_connection.c
@@ -247,10 +247,19 @@ void *parser_thread( void *arg )
                                }
                                buffer[ bytes ] = '\0';
                                if ( bytes > 0 && total == bytes )
-                                       service = ( mlt_service )mlt_factory_producer( "westley-xml", buffer );
-                               mlt_events_fire( owner, "push-received", &response, command, service, NULL );
-                               if ( response == NULL )
-                                       response = valerie_parser_push( parser, command, service );
+                               {
+                                       if ( mlt_properties_get( owner, "push-parser-off" ) == 0 )
+                                       {
+                                               service = ( mlt_service )mlt_factory_producer( "westley-xml", buffer );
+                                               mlt_events_fire( owner, "push-received", &response, command, service, NULL );
+                                               if ( response == NULL )
+                                                       response = valerie_parser_push( parser, command, service );
+                                       }
+                                       else
+                                       {
+                                               response = valerie_parser_received( parser, command, buffer );
+                                       }
+                               }
                                error = connection_send( fd, response );
                                valerie_response_close( response );
                                mlt_service_close( service );

diff --git a/src/miracle/miracle_local.c b/src/miracle/miracle_local.c
index 3056744..c0917f3 100644 (file)
--- a/src/miracle/miracle_local.c
+++ b/src/miracle/miracle_local.c
@@ -61,6 +61,7 @@ typedef struct
 static valerie_response miracle_local_connect( miracle_local );
 static valerie_response miracle_local_execute( miracle_local, char * );
 static valerie_response miracle_local_push( miracle_local, char *, mlt_service );
+static valerie_response miracle_local_receive( miracle_local, char *, char * );
 static void miracle_local_close( miracle_local );
 response_codes miracle_help( command_argument arg );
 response_codes miracle_run( command_argument arg );
@@ -81,6 +82,7 @@ valerie_parser miracle_parser_init_local( )
                parser->connect = (parser_connect)miracle_local_connect;
                parser->execute = (parser_execute)miracle_local_execute;
                parser->push = (parser_push)miracle_local_push;
+               parser->received = (parser_received)miracle_local_receive;
                parser->close = (parser_close)miracle_local_close;
                parser->real = local;
 
@@ -499,6 +501,46 @@ static valerie_response miracle_local_execute( miracle_local local, char *comman
        return cmd.response;
 }
 
+static valerie_response miracle_local_receive( miracle_local local, char *command, char *doc )
+{
+       command_argument_t cmd;
+       cmd.parser = local->parser;
+       cmd.response = valerie_response_init( );
+       cmd.tokeniser = valerie_tokeniser_init( );
+       cmd.command = command;
+       cmd.unit = -1;
+       cmd.argument = NULL;
+       cmd.root_dir = local->root_dir;
+
+       /* Set the default error */
+       miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
+
+       /* Parse the command */
+       if ( valerie_tokeniser_parse_new( cmd.tokeniser, command, " " ) > 0 )
+       {
+               int index = 0;
+               int position = 1;
+
+               /* Strip quotes from all tokens */
+               for ( index = 0; index < valerie_tokeniser_count( cmd.tokeniser ); index ++ )
+                       valerie_util_strip( valerie_tokeniser_get_string( cmd.tokeniser, index ), '\"' );
+
+               cmd.unit = miracle_command_parse_unit( &cmd, position );
+               if ( cmd.unit == -1 )
+                       miracle_command_set_error( &cmd, RESPONSE_MISSING_ARG );
+               position ++;
+
+               miracle_receive( &cmd, doc );
+               miracle_command_set_error( &cmd, RESPONSE_SUCCESS );
+
+               free( cmd.argument );
+       }
+
+       valerie_tokeniser_close( cmd.tokeniser );
+
+       return cmd.response;
+}
+
 static valerie_response miracle_local_push( miracle_local local, char *command, mlt_service service )
 {
        command_argument_t cmd;

diff --git a/src/miracle/miracle_server.c b/src/miracle/miracle_server.c
index 6d733de..652e533 100644 (file)
--- a/src/miracle/miracle_server.c
+++ b/src/miracle/miracle_server.c
@@ -52,6 +52,12 @@ static void miracle_command_received( mlt_listener listener, mlt_properties owne
                listener( owner, this, ( valerie_response ** )args[ 0 ], ( char * )args[ 1 ] );
 }
 
+static void miracle_doc_received( mlt_listener listener, mlt_properties owner, miracle_server this, void **args )
+{
+       if ( listener != NULL )
+               listener( owner, this, ( valerie_response ** )args[ 0 ], ( char * )args[ 1 ], ( char * )args[ 2 ] );
+}
+
 static void miracle_push_received( mlt_listener listener, mlt_properties owner, miracle_server this, void **args )
 {
        if ( listener != NULL )
@@ -73,6 +79,7 @@ miracle_server miracle_server_init( char *id )
                server->socket = -1;
                mlt_events_init( &server->parent );
                mlt_events_register( &server->parent, "command-received", ( mlt_transmitter )miracle_command_received );
+               mlt_events_register( &server->parent, "doc-received", ( mlt_transmitter )miracle_doc_received );
                mlt_events_register( &server->parent, "push-received", ( mlt_transmitter )miracle_push_received );
        }
        return server;

diff --git a/src/miracle/miracle_unit_commands.c b/src/miracle/miracle_unit_commands.c
index c810c0a..f0cbfd1 100644 (file)
--- a/src/miracle/miracle_unit_commands.c
+++ b/src/miracle/miracle_unit_commands.c
@@ -263,6 +263,22 @@ int miracle_push( command_argument cmd_arg, mlt_service service )
        return RESPONSE_BAD_FILE;
 }
 
+int miracle_receive( command_argument cmd_arg, char *doc )
+{
+       mlt_producer producer = mlt_factory_producer( "westley-xml", doc );
+       miracle_unit unit = miracle_get_unit(cmd_arg->unit);
+       if ( unit != NULL && producer != NULL )
+       {
+               if ( miracle_unit_append_service( unit, mlt_producer_service( producer ) ) == valerie_ok )
+               {
+                       mlt_producer_close( producer );
+                       return RESPONSE_SUCCESS;
+               }
+       }
+       mlt_producer_close( producer );
+       return RESPONSE_BAD_FILE;
+}
+
 int miracle_play( command_argument cmd_arg )
 {
        miracle_unit unit = miracle_get_unit(cmd_arg->unit);

diff --git a/src/miracle/miracle_unit_commands.h b/src/miracle/miracle_unit_commands.h
index 461c51a..ad1316c 100644 (file)
--- a/src/miracle/miracle_unit_commands.h
+++ b/src/miracle/miracle_unit_commands.h
@@ -51,6 +51,7 @@ extern response_codes miracle_set_unit_property( command_argument );
 extern response_codes miracle_get_unit_property( command_argument );
 extern response_codes miracle_transfer( command_argument );
 extern response_codes miracle_push( command_argument, mlt_service );
+extern response_codes miracle_receive( command_argument, char * );
 
 #ifdef __cplusplus
 }

diff --git a/src/modules/valerie/consumer_valerie.c b/src/modules/valerie/consumer_valerie.c
index 781238d..71a274c 100644 (file)
--- a/src/modules/valerie/consumer_valerie.c
+++ b/src/modules/valerie/consumer_valerie.c
@@ -93,7 +93,10 @@ static int consumer_start( mlt_consumer this )
        // If this is a reuse, then a valerie object will exist
        valerie connection = mlt_properties_get_data( properties, "connection", NULL );
 
-       if ( service != NULL )
+       // Special case - we can get a doc too...
+       char *doc = mlt_properties_get( properties, "westley" );
+
+       if ( service != NULL || doc != NULL )
        {
                // Initiate the connection if required
                if ( connection == NULL )
@@ -117,20 +120,32 @@ static int consumer_start( mlt_consumer this )
                // If we have connection, push the service over
                if ( connection != NULL )
                {
-                       int error;
+                       if ( doc == NULL )
+                       {
+                               int error;
 
-                       // Set the title if provided
-                       if ( title != NULL )
-                               mlt_properties_set( mlt_service_properties( service ), "title", title );
-                       else if ( mlt_properties_get( mlt_service_properties( service ), "title" ) == NULL )
-                               mlt_properties_set( mlt_service_properties( service ), "title", "Anonymous Submission" );
+                               // Set the title if provided
+                               if ( title != NULL )
+                                       mlt_properties_set( mlt_service_properties( service ), "title", title );
+                               else if ( mlt_properties_get( mlt_service_properties( service ), "title" ) == NULL )
+                                       mlt_properties_set( mlt_service_properties( service ), "title", "Anonymous Submission" );
 
-                       // Push the service
-                       error = valerie_unit_push( connection, unit, command, service );
+                               // Push the service
+                               error = valerie_unit_push( connection, unit, command, service );
 
-                       // Report error
-                       if ( error != valerie_ok )
-                               fprintf( stderr, "Push failed on %s:%d %s u%d (%d)\n", server, port, command, unit, error );
+                               // Report error
+                               if ( error != valerie_ok )
+                                       fprintf( stderr, "Push failed on %s:%d %s u%d (%d)\n", server, port, command, unit, error );
+                       }
+                       else
+                       {
+                               // Push the service
+                               int error = valerie_unit_receive( connection, unit, command, doc );
+
+                               // Report error
+                               if ( error != valerie_ok )
+                                       fprintf( stderr, "Send failed on %s:%d %s u%d (%d)\n", server, port, command, unit, error );
+                       }
                }
        }
        

diff --git a/src/modules/westley/producer_westley.c b/src/modules/westley/producer_westley.c
index 18aa86b..1d42754 100644 (file)
--- a/src/modules/westley/producer_westley.c
+++ b/src/modules/westley/producer_westley.c
@@ -726,12 +726,12 @@ static void on_end_track( deserialise_context context, const xmlChar *name )
 
                if ( multitrack != NULL )
                {
-                       // Set the track on the multitrack
-
                        // Set producer i/o if specified
-                       if ( mlt_properties_get( track_props, "in" ) != NULL &&
+                       if ( mlt_properties_get( track_props, "in" ) != NULL ||
                                 mlt_properties_get( track_props, "out" ) != NULL )
                        {
+                               if ( mlt_properties_get( track_props, "out" ) == NULL )
+                                       mlt_properties_set_position( track_props, "out", mlt_properties_get_position( track_props, "length" ) - 1 );
                                mlt_producer cut = mlt_producer_cut( MLT_PRODUCER( producer ),
                                        mlt_properties_get_position( track_props, "in" ),
                                        mlt_properties_get_position( track_props, "out" ) );
@@ -891,6 +891,8 @@ static void on_end_transition( deserialise_context context, const xmlChar *name
                        if ( parent_type == mlt_tractor_type )
                        {
                                mlt_field field = mlt_tractor_field( MLT_TRACTOR( parent ) );
+                               if ( mlt_properties_get_int( properties, "a_track" ) == mlt_properties_get_int( properties, "b_track" ) )
+                                       mlt_properties_set_int( properties, "b_track", mlt_properties_get_int( properties, "a_track" ) + 1 );
                                mlt_field_plant_transition( field, MLT_TRANSITION( effect ), 
                                                                                        mlt_properties_get_int( properties, "a_track" ),
                                                                                        mlt_properties_get_int( properties, "b_track" ) );

diff --git a/src/valerie/valerie.c b/src/valerie/valerie.c
index 8499f44..c76112d 100644 (file)
--- a/src/valerie/valerie.c
+++ b/src/valerie/valerie.c
@@ -148,6 +148,37 @@ valerie_error_code valerie_execute( valerie this, size_t size, char *format, ...
 /** Execute a command.
 */
 
+valerie_error_code valerie_receive( valerie this, char *doc, size_t size, char *format, ... )
+{
+       valerie_error_code error = valerie_server_unavailable;
+       char *command = malloc( size );
+       if ( this != NULL && command != NULL )
+       {
+               va_list list;
+               va_start( list, format );
+               if ( vsnprintf( command, size, format, list ) != 0 )
+               {
+                       valerie_response response = valerie_parser_received( this->parser, command, doc );
+                       valerie_set_last_response( this, response );
+                       error = valerie_get_error_code( this, response );
+               }
+               else
+               {
+                       error = valerie_invalid_command;
+               }
+               va_end( list );
+       }
+       else
+       {
+               error = valerie_malloc_failed;
+       }
+       free( command );
+       return error;
+}
+
+/** Execute a command.
+*/
+
 valerie_error_code valerie_push( valerie this, mlt_service service, size_t size, char *format, ... )
 {
        valerie_error_code error = valerie_server_unavailable;
@@ -286,6 +317,14 @@ valerie_error_code valerie_unit_append( valerie this, int unit, char *file, int3
 /** Push a service on to a unit.
 */
 
+valerie_error_code valerie_unit_receive( valerie this, int unit, char *command, char *doc )
+{
+       return valerie_receive( this, doc, 10240, "PUSH U%d %s", unit, command );
+}
+
+/** Push a service on to a unit.
+*/
+
 valerie_error_code valerie_unit_push( valerie this, int unit, char *command, mlt_service service )
 {
        return valerie_push( this, service, 10240, "PUSH U%d %s", unit, command );

diff --git a/src/valerie/valerie.h b/src/valerie/valerie.h
index eb3c9bf..29d4fd3 100644 (file)
--- a/src/valerie/valerie.h
+++ b/src/valerie/valerie.h
@@ -97,6 +97,7 @@ extern valerie_error_code valerie_unit_load_clipped( valerie, int, char *, int32
 extern valerie_error_code valerie_unit_load_back( valerie, int, char * );
 extern valerie_error_code valerie_unit_load_back_clipped( valerie, int, char *, int32_t, int32_t );
 extern valerie_error_code valerie_unit_append( valerie, int, char *, int32_t, int32_t );
+extern valerie_error_code valerie_unit_receive( valerie, int, char *, char * );
 extern valerie_error_code valerie_unit_push( valerie, int, char *, mlt_service );
 extern valerie_error_code valerie_unit_clean( valerie, int );
 extern valerie_error_code valerie_unit_clear( valerie, int );

diff --git a/src/valerie/valerie_parser.c b/src/valerie/valerie_parser.c
index 2b90fed..7d6e6d3 100644 (file)
--- a/src/valerie/valerie_parser.c
+++ b/src/valerie/valerie_parser.c
@@ -47,6 +47,14 @@ valerie_response valerie_parser_execute( valerie_parser parser, char *command )
 /** Push a service via the parser.
 */
 
+valerie_response valerie_parser_received( valerie_parser parser, char *command, char *doc )
+{
+       return parser->received != NULL ? parser->received( parser->real, command, doc ) : NULL;
+}
+
+/** Push a service via the parser.
+*/
+
 valerie_response valerie_parser_push( valerie_parser parser, char *command, mlt_service service )
 {
        return parser->push( parser->real, command, service );

diff --git a/src/valerie/valerie_parser.h b/src/valerie/valerie_parser.h
index 3e1a17b..7d9d8a5 100644 (file)
--- a/src/valerie/valerie_parser.h
+++ b/src/valerie/valerie_parser.h
@@ -38,6 +38,7 @@ extern "C"
 
 typedef valerie_response (*parser_connect)( void * );
 typedef valerie_response (*parser_execute)( void *, char * );
+typedef valerie_response (*parser_received)( void *, char *, char * );
 typedef valerie_response (*parser_push)( void *, char *, mlt_service );
 typedef void (*parser_close)( void * );
 
@@ -49,6 +50,7 @@ typedef struct
        parser_connect connect;
        parser_execute execute;
        parser_push push;
+       parser_received received;
        parser_close close;
        void *real;
        valerie_notifier notifier;
@@ -60,6 +62,7 @@ typedef struct
 
 extern valerie_response valerie_parser_connect( valerie_parser );
 extern valerie_response valerie_parser_push( valerie_parser, char *, mlt_service );
+extern valerie_response valerie_parser_received( valerie_parser, char *, char * );
 extern valerie_response valerie_parser_execute( valerie_parser, char * );
 extern valerie_response valerie_parser_executef( valerie_parser, char *, ... );
 extern valerie_response valerie_parser_run( valerie_parser, char * );

diff --git a/src/valerie/valerie_remote.c b/src/valerie/valerie_remote.c
index f770035..d05f79b 100644 (file)
--- a/src/valerie/valerie_remote.c
+++ b/src/valerie/valerie_remote.c
@@ -55,6 +55,7 @@ typedef struct
 
 static valerie_response valerie_remote_connect( valerie_remote );
 static valerie_response valerie_remote_execute( valerie_remote, char * );
+static valerie_response valerie_remote_receive( valerie_remote, char *, char * );
 static valerie_response valerie_remote_push( valerie_remote, char *, mlt_service );
 static void valerie_remote_close( valerie_remote );
 static int valerie_remote_read_response( valerie_socket, valerie_response );
@@ -72,6 +73,7 @@ valerie_parser valerie_parser_init_remote( char *server, int port )
                parser->connect = (parser_connect)valerie_remote_connect;
                parser->execute = (parser_execute)valerie_remote_execute;
                parser->push = (parser_push)valerie_remote_push;
+               parser->received = (parser_received)valerie_remote_receive;
                parser->close = (parser_close)valerie_remote_close;
                parser->real = remote;
 
@@ -194,37 +196,50 @@ static valerie_response valerie_remote_execute( valerie_remote remote, char *com
        return response;
 }
 
-/** Push a producer to the server.
+/** Push a westley document to the server.
 */
 
-static valerie_response valerie_remote_push( valerie_remote remote, char *command, mlt_service service )
+static valerie_response valerie_remote_receive( valerie_remote remote, char *command, char *buffer )
 {
        valerie_response response = NULL;
        pthread_mutex_lock( &remote->mutex );
        if ( valerie_socket_write_data( remote->socket, command, strlen( command ) ) == strlen( command ) )
        {
-               mlt_consumer consumer = mlt_factory_consumer( "westley", "buffer" );
-               mlt_properties properties = mlt_consumer_properties( consumer );
                char temp[ 20 ];
-               char *buffer = NULL;
-               int length = 0;
-               mlt_consumer_connect( consumer, service );
+               int length = strlen( buffer );
                response = valerie_response_init( );
                valerie_socket_write_data( remote->socket, "\r\n", 2 );
-               mlt_consumer_start( consumer );
-               buffer = mlt_properties_get_data( properties, "buffer", &length );
                sprintf( temp, "%d", length );
                valerie_socket_write_data( remote->socket, temp, strlen( temp ) );
                valerie_socket_write_data( remote->socket, "\r\n", 2 );
                valerie_socket_write_data( remote->socket, buffer, length );
                valerie_socket_write_data( remote->socket, "\r\n", 2 );
                valerie_remote_read_response( remote->socket, response );
-               mlt_consumer_close( consumer );
        }
        pthread_mutex_unlock( &remote->mutex );
        return response;
 }
 
+/** Push a producer to the server.
+*/
+
+static valerie_response valerie_remote_push( valerie_remote remote, char *command, mlt_service service )
+{
+       valerie_response response = NULL;
+       if ( service != NULL )
+       {
+               mlt_consumer consumer = mlt_factory_consumer( "westley", "buffer" );
+               mlt_properties properties = mlt_consumer_properties( consumer );
+               char *buffer = NULL;
+               mlt_consumer_connect( consumer, service );
+               mlt_consumer_start( consumer );
+               buffer = mlt_properties_get_data( properties, "buffer", NULL );
+               response = valerie_remote_receive( remote, command, buffer );
+               mlt_consumer_close( consumer );
+       }
+       return response;
+}
+
 /** Disconnect.
 */