]> git.sesse.net Git - mlt/blob - src/modules/westley/consumer_westley.c
Consumer valerie, pushes, and assorted modifications
[mlt] / src / modules / westley / consumer_westley.c
1 /*
2  * consumer_westley.c -- a libxml2 serialiser of mlt service networks
3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4  * Author: Dan Dennedy <dan@dennedy.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program 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
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  */
20
21 #include "consumer_westley.h"
22 #include <framework/mlt.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <pthread.h>
27 #include <unistd.h>
28 #include <libxml/tree.h>
29
30 #define ID_SIZE 128
31
32 // This maintains counters for adding ids to elements
33 struct serialise_context_s
34 {
35         mlt_properties id_map;
36         int producer_count;
37         int multitrack_count;
38         int playlist_count;
39         int tractor_count;
40         int filter_count;
41         int transition_count;
42         int pass;
43         mlt_properties hide_map;
44         char *root;
45 };
46 typedef struct serialise_context_s* serialise_context;
47
48 /** Forward references to static functions.
49 */
50
51 static int consumer_start( mlt_consumer parent );
52 static int consumer_is_stopped( mlt_consumer this );
53 static void serialise_service( serialise_context context, mlt_service service, xmlNode *node );
54
55 typedef enum 
56 {
57         westley_existing,
58         westley_producer,
59         westley_multitrack,
60         westley_playlist,
61         westley_tractor,
62         westley_filter,
63         westley_transition
64 }
65 westley_type;
66
67 /** Create or retrieve an id associated to this service.
68 */
69
70 static char *westley_get_id( serialise_context context, mlt_service service, westley_type type )
71 {
72         char *id = NULL;
73         int i = 0;
74         mlt_properties map = context->id_map;
75
76         // Search the map for the service
77         for ( i = 0; i < mlt_properties_count( map ); i ++ )
78                 if ( mlt_properties_get_data_at( map, i, NULL ) == service )
79                         break;
80
81         // If the service is not in the map, and the type indicates a new id is needed...
82         if ( i >= mlt_properties_count( map ) && type != westley_existing )
83         {
84                 // Attempt to reuse existing id
85                 id = mlt_properties_get( mlt_service_properties( service ), "id" );
86
87                 // If no id, or the id is used in the map (for another service), then 
88                 // create a new one.
89                 if ( id == NULL || mlt_properties_get_data( map, id, NULL ) != NULL )
90                 {
91                         char temp[ ID_SIZE ];
92                         do
93                         {
94                                 switch( type )
95                                 {
96                                         case westley_producer:
97                                                 sprintf( temp, "producer%d", context->producer_count ++ );
98                                                 break;
99                                         case westley_multitrack:
100                                                 sprintf( temp, "multitrack%d", context->multitrack_count ++ );
101                                                 break;
102                                         case westley_playlist:
103                                                 sprintf( temp, "playlist%d", context->playlist_count ++ );
104                                                 break;
105                                         case westley_tractor:
106                                                 sprintf( temp, "tractor%d", context->tractor_count ++ );
107                                                 break;
108                                         case westley_filter:
109                                                 sprintf( temp, "filter%d", context->filter_count ++ );
110                                                 break;
111                                         case westley_transition:
112                                                 sprintf( temp, "transition%d", context->transition_count ++ );
113                                                 break;
114                                         case westley_existing:
115                                                 // Never gets here
116                                                 break;
117                                 }
118                         }
119                         while( mlt_properties_get_data( map, temp, NULL ) != NULL );
120
121                         // Set the data at the generated name
122                         mlt_properties_set_data( map, temp, service, 0, NULL, NULL );
123
124                         // Get the pointer to the name (i is the end of the list)
125                         id = mlt_properties_get_name( map, i );
126                 }
127                 else
128                 {
129                         // Store the existing id in the map
130                         mlt_properties_set_data( map, id, service, 0, NULL, NULL );
131                 }
132         }
133         else if ( type == westley_existing )
134         {
135                 id = mlt_properties_get_name( map, i );
136         }
137
138         return id;
139 }
140
141 /** This is what will be called by the factory - anything can be passed in
142         via the argument, but keep it simple.
143 */
144
145 mlt_consumer consumer_westley_init( char *arg )
146 {
147         // Create the consumer object
148         mlt_consumer this = calloc( sizeof( struct mlt_consumer_s ), 1 );
149
150         // If no malloc'd and consumer init ok
151         if ( this != NULL && mlt_consumer_init( this, NULL ) == 0 )
152         {
153                 // Allow thread to be started/stopped
154                 this->start = consumer_start;
155                 this->is_stopped = consumer_is_stopped;
156
157                 mlt_properties_set( mlt_consumer_properties( this ), "resource", arg );
158
159                 // Return the consumer produced
160                 return this;
161         }
162
163         // malloc or consumer init failed
164         free( this );
165
166         // Indicate failure
167         return NULL;
168 }
169
170 static inline void serialise_properties( serialise_context context, mlt_properties properties, xmlNode *node )
171 {
172         int i;
173         xmlNode *p;
174         
175         // Enumerate the properties
176         for ( i = 0; i < mlt_properties_count( properties ); i++ )
177         {
178                 char *name = mlt_properties_get_name( properties, i );
179                 if ( name != NULL &&
180                          name[ 0 ] != '_' &&
181                          mlt_properties_get_value( properties, i ) != NULL &&
182                          strcmp( name, "westley" ) != 0 &&
183                          strcmp( name, "in" ) != 0 &&
184                          strcmp( name, "out" ) != 0 && 
185                          strcmp( name, "id" ) != 0 && 
186                          strcmp( name, "root" ) != 0 && 
187                          strcmp( name, "width" ) != 0 &&
188                          strcmp( name, "height" ) != 0 )
189                 {
190                         char *value = mlt_properties_get_value( properties, i );
191                         p = xmlNewChild( node, NULL, "property", NULL );
192                         xmlNewProp( p, "name", mlt_properties_get_name( properties, i ) );
193                         if ( strcmp( context->root, "" ) && !strncmp( value, context->root, strlen( context->root ) ) )
194                                 xmlNodeSetContent( p, value + strlen( context->root ) + 1 );
195                         else
196                                 xmlNodeSetContent( p, value );
197                 }
198         }
199 }
200
201 static inline void serialise_service_filters( serialise_context context, mlt_service service, xmlNode *node )
202 {
203         int i;
204         xmlNode *p;
205         mlt_filter filter = NULL;
206         
207         // Enumerate the filters
208         for ( i = 0; ( filter = mlt_producer_filter( MLT_PRODUCER( service ), i ) ) != NULL; i ++ )
209         {
210                 mlt_properties properties = mlt_filter_properties( filter );
211                 if ( mlt_properties_get_int( properties, "_fezzik" ) == 0 )
212                 {
213                         // Get a new id - if already allocated, do nothing
214                         char *id = westley_get_id( context, mlt_filter_service( filter ), westley_filter );
215                         if ( id != NULL )
216                         {
217                                 int in = mlt_properties_get_position( properties, "in" );
218                                 int out = mlt_properties_get_position( properties, "out" );
219                                 p = xmlNewChild( node, NULL, "filter", NULL );
220                                 xmlNewProp( p, "id", id );
221                                 if ( in != 0 || out != 0 )
222                                 {
223                                         char temp[ 20 ];
224                                         sprintf( temp, "%d", in );
225                                         xmlNewProp( p, "in", temp );
226                                         sprintf( temp, "%d", out );
227                                         xmlNewProp( p, "out", temp );
228                                 }
229                                 serialise_properties( context, properties, p );
230                                 serialise_service_filters( context, mlt_filter_service( filter ), p );
231                         }
232                 }
233         }
234 }
235
236 static void serialise_producer( serialise_context context, mlt_service service, xmlNode *node )
237 {
238         xmlNode *child = node;
239         mlt_properties properties = mlt_service_properties( service );
240         
241         if ( context->pass == 0 )
242         {
243                 // Get a new id - if already allocated, do nothing
244                 char *id = westley_get_id( context, service, westley_producer );
245                 if ( id == NULL )
246                         return;
247
248                 child = xmlNewChild( node, NULL, "producer", NULL );
249
250                 // Set the id
251                 xmlNewProp( child, "id", id );
252                 serialise_properties( context, properties, child );
253                 serialise_service_filters( context, service, child );
254
255                 // Add producer to the map
256                 mlt_properties_set_int( context->hide_map, id, mlt_properties_get_int( properties, "hide" ) );
257         }
258         else
259         {
260                 // Get a new id - if already allocated, do nothing
261                 char *id = westley_get_id( context, service, westley_existing );
262                 xmlNewProp( node, "producer", id );
263         }
264 }
265
266 static void serialise_multitrack( serialise_context context, mlt_service service, xmlNode *node )
267 {
268         int i;
269         
270         if ( context->pass == 0 )
271         {
272                 // Iterate over the tracks to collect the producers
273                 for ( i = 0; i < mlt_multitrack_count( MLT_MULTITRACK( service ) ); i++ )
274                         serialise_service( context, MLT_SERVICE( mlt_multitrack_track( MLT_MULTITRACK( service ), i ) ), node );
275         }
276         else
277         {
278                 // Get a new id - if already allocated, do nothing
279                 char *id = westley_get_id( context, service, westley_multitrack );
280                 if ( id == NULL )
281                         return;
282
283                 // Serialise the tracks
284                 for ( i = 0; i < mlt_multitrack_count( MLT_MULTITRACK( service ) ); i++ )
285                 {
286                         xmlNode *track = xmlNewChild( node, NULL, "track", NULL );
287                         int hide = 0;
288                         mlt_producer producer = mlt_multitrack_track( MLT_MULTITRACK( service ), i );
289
290                         char *id = westley_get_id( context, MLT_SERVICE( producer ), westley_existing );
291                         xmlNewProp( track, "producer", id );
292                         
293                         hide = mlt_properties_get_int( context->hide_map, id );
294                         if ( hide )
295                                 xmlNewProp( track, "hide", hide == 1 ? "video" : ( hide == 2 ? "audio" : "both" ) );
296                 }
297                 serialise_service_filters( context, service, node );
298         }
299 }
300
301 static void serialise_tractor( serialise_context context, mlt_service service, xmlNode *node );
302
303 static void serialise_playlist( serialise_context context, mlt_service service, xmlNode *node )
304 {
305         int i;
306         xmlNode *child = node;
307         mlt_playlist_clip_info info;
308         mlt_properties properties = mlt_service_properties( service );
309         
310         if ( context->pass == 0 )
311         {
312                 // Get a new id - if already allocated, do nothing
313                 char *id = westley_get_id( context, service, westley_playlist );
314                 if ( id == NULL )
315                         return;
316
317                 // Iterate over the playlist entries to collect the producers
318                 for ( i = 0; i < mlt_playlist_count( MLT_PLAYLIST( service ) ); i++ )
319                 {
320                         if ( ! mlt_playlist_get_clip_info( MLT_PLAYLIST( service ), &info, i ) )
321                         {
322                                 if ( info.producer != NULL )
323                                 {
324                                         char *service_s = mlt_properties_get( mlt_producer_properties( info.producer ), "mlt_service" );
325                                         char *resource_s = mlt_properties_get( mlt_producer_properties( info.producer ), "resource" );
326                                         if ( resource_s != NULL && !strcmp( resource_s, "<tractor>" ) )
327                                         {
328                                                 serialise_tractor( context, MLT_SERVICE( info.producer ), node );
329                                                 context->pass ++;
330                                                 serialise_tractor( context, MLT_SERVICE( info.producer ), node );
331                                                 context->pass --;
332                                         }
333                                         else if ( service_s != NULL && strcmp( service_s, "blank" ) != 0 )
334                                                 serialise_service( context, MLT_SERVICE( info.producer ), node );
335                                         else if ( resource_s != NULL && !strcmp( resource_s, "<playlist>" ) )
336                                                 serialise_playlist( context, MLT_SERVICE( info.producer ), node );
337                                 }
338                         }
339                 }
340                 
341                 child = xmlNewChild( node, NULL, "playlist", NULL );
342
343                 // Set the id
344                 xmlNewProp( child, "id", id );
345
346                 // Add producer to the map
347                 mlt_properties_set_int( context->hide_map, id, mlt_properties_get_int( properties, "hide" ) );
348         
349                 // Iterate over the playlist entries
350                 for ( i = 0; i < mlt_playlist_count( MLT_PLAYLIST( service ) ); i++ )
351                 {
352                         if ( ! mlt_playlist_get_clip_info( MLT_PLAYLIST( service ), &info, i ) )
353                         {
354                                 char *service_s = mlt_properties_get( mlt_producer_properties( info.producer ), "mlt_service" );
355                                 if ( service_s != NULL && strcmp( service_s, "blank" ) == 0 )
356                                 {
357                                         char length[ 20 ];
358                                         length[ 19 ] = '\0';
359                                         xmlNode *entry = xmlNewChild( child, NULL, "blank", NULL );
360                                         snprintf( length, 19, "%d", info.frame_count );
361                                         xmlNewProp( entry, "length", length );
362                                 }
363                                 else
364                                 {
365                                         char temp[ 20 ];
366                                         xmlNode *entry = xmlNewChild( child, NULL, "entry", NULL );
367                                         id = westley_get_id( context, MLT_SERVICE( info.producer ), westley_existing );
368                                         xmlNewProp( entry, "producer", id );
369                                         sprintf( temp, "%d", info.frame_in );
370                                         xmlNewProp( entry, "in", temp );
371                                         sprintf( temp, "%d", info.frame_out );
372                                         xmlNewProp( entry, "out", temp );
373                                 }
374                         }
375                 }
376
377                 serialise_service_filters( context, service, child );
378         }
379         else if ( strcmp( (const char*) node->name, "tractor" ) != 0 )
380         {
381                 char *id = westley_get_id( context, service, westley_existing );
382                 xmlNewProp( node, "producer", id );
383         }
384 }
385
386 static void serialise_tractor( serialise_context context, mlt_service service, xmlNode *node )
387 {
388         xmlNode *child = node;
389         mlt_properties properties = mlt_service_properties( service );
390         
391         if ( context->pass == 0 )
392         {
393                 // Recurse on connected producer
394                 serialise_service( context, mlt_service_producer( service ), node );
395         }
396         else
397         {
398                 // Get a new id - if already allocated, do nothing
399                 char *id = westley_get_id( context, service, westley_tractor );
400                 if ( id == NULL )
401                         return;
402
403                 child = xmlNewChild( node, NULL, "tractor", NULL );
404
405                 // Set the id
406                 xmlNewProp( child, "id", id );
407                 xmlNewProp( child, "in", mlt_properties_get( properties, "in" ) );
408                 xmlNewProp( child, "out", mlt_properties_get( properties, "out" ) );
409
410                 // Recurse on connected producer
411                 serialise_service( context, mlt_service_producer( service ), child );
412                 serialise_service_filters( context, service, child );
413         }
414 }
415
416 static void serialise_filter( serialise_context context, mlt_service service, xmlNode *node )
417 {
418         xmlNode *child = node;
419         mlt_properties properties = mlt_service_properties( service );
420         
421         // Recurse on connected producer
422         serialise_service( context, mlt_service_producer( service ), node );
423
424         if ( context->pass == 1 )
425         {
426                 // Get a new id - if already allocated, do nothing
427                 char *id = westley_get_id( context, service, westley_filter );
428                 if ( id == NULL )
429                         return;
430
431                 child = xmlNewChild( node, NULL, "filter", NULL );
432
433                 // Set the id
434                 xmlNewProp( child, "id", id );
435                 xmlNewProp( child, "in", mlt_properties_get( properties, "in" ) );
436                 xmlNewProp( child, "out", mlt_properties_get( properties, "out" ) );
437
438                 serialise_properties( context, properties, child );
439                 serialise_service_filters( context, service, child );
440         }
441 }
442
443 static void serialise_transition( serialise_context context, mlt_service service, xmlNode *node )
444 {
445         xmlNode *child = node;
446         mlt_properties properties = mlt_service_properties( service );
447         
448         // Recurse on connected producer
449         serialise_service( context, MLT_SERVICE( MLT_TRANSITION( service )->producer ), node );
450
451         if ( context->pass == 1 )
452         {
453                 // Get a new id - if already allocated, do nothing
454                 char *id = westley_get_id( context, service, westley_transition );
455                 if ( id == NULL )
456                         return;
457
458                 child = xmlNewChild( node, NULL, "transition", NULL );
459         
460                 // Set the id
461                 xmlNewProp( child, "id", id );
462                 xmlNewProp( child, "in", mlt_properties_get( properties, "in" ) );
463                 xmlNewProp( child, "out", mlt_properties_get( properties, "out" ) );
464
465                 serialise_properties( context, properties, child );
466                 serialise_service_filters( context, service, child );
467         }
468 }
469
470 static void serialise_service( serialise_context context, mlt_service service, xmlNode *node )
471 {
472         // Iterate over consumer/producer connections
473         while ( service != NULL )
474         {
475                 mlt_properties properties = mlt_service_properties( service );
476                 char *mlt_type = mlt_properties_get( properties, "mlt_type" );
477                 
478                 // Tell about the producer
479                 if ( strcmp( mlt_type, "producer" ) == 0 )
480                 {
481                         serialise_producer( context, service, node );
482                         if ( mlt_properties_get( properties, "westley" ) != NULL )
483                                 break;
484                 }
485
486                 // Tell about the framework container producers
487                 else if ( strcmp( mlt_type, "mlt_producer" ) == 0 )
488                 {
489                         char *resource = mlt_properties_get( properties, "resource" );
490                         
491                         // Recurse on multitrack's tracks
492                         if ( strcmp( resource, "<multitrack>" ) == 0 )
493                         {
494                                 serialise_multitrack( context, service, node );
495                                 break;
496                         }
497                         
498                         // Recurse on playlist's clips
499                         else if ( strcmp( resource, "<playlist>" ) == 0 )
500                         {
501                                 serialise_playlist( context, service, node );
502                         }
503                         
504                         // Recurse on tractor's producer
505                         else if ( strcmp( resource, "<tractor>" ) == 0 )
506                         {
507                                 serialise_tractor( context, service, node );
508                                 break;
509                         }
510
511                         // Treat it as a normal producer
512                         else
513                         {
514                                 serialise_producer( context, service, node );
515                         }
516                 }
517                 
518                 // Tell about a filter
519                 else if ( strcmp( mlt_type, "filter" ) == 0 )
520                 {
521                         serialise_filter( context, service, node );
522                         break;
523                 }
524                 
525                 // Tell about a transition
526                 else if ( strcmp( mlt_type, "transition" ) == 0 )
527                 {
528                         serialise_transition( context, service, node );
529                         break;
530                 }
531                 
532                 // Get the next connected service
533                 service = mlt_service_producer( service );
534         }
535 }
536
537 xmlDocPtr westley_make_doc( mlt_service service )
538 {
539         mlt_properties properties = mlt_service_properties( service );
540         xmlDocPtr doc = xmlNewDoc( "1.0" );
541         xmlNodePtr root = xmlNewNode( NULL, "westley" );
542         struct serialise_context_s *context = calloc( 1, sizeof( struct serialise_context_s ) );
543         
544         xmlDocSetRootElement( doc, root );
545
546         // If we have root, then deal with it now
547         if ( mlt_properties_get( properties, "root" ) != NULL )
548         {
549                 xmlNewProp( root, "root", mlt_properties_get( properties, "root" ) );
550                 context->root = strdup( mlt_properties_get( properties, "root" ) );
551         }
552         else
553         {
554                 context->root = strdup( "" );
555         }
556
557         // Assign a title property
558         if ( mlt_properties_get( properties, "title" ) != NULL )
559                 xmlNewProp( root, "title", mlt_properties_get( properties, "title" ) );
560
561         // Construct the context maps
562         context->id_map = mlt_properties_new();
563         context->hide_map = mlt_properties_new();
564         
565         // Ensure producer is a framework producer
566         mlt_properties_set( mlt_service_properties( service ), "mlt_type", "mlt_producer" );
567
568         // In pass one, we serialise the end producers and playlists,
569         // adding them to a map keyed by address.
570         serialise_service( context, service, root );
571
572         // In pass two, we serialise the tractor and reference the
573         // producers and playlists
574         context->pass++;
575         serialise_service( context, service, root );
576
577         // Cleanup resource
578         mlt_properties_close( context->id_map );
579         mlt_properties_close( context->hide_map );
580         free( context->root );
581         free( context );
582         
583         return doc;
584 }
585
586 static int consumer_start( mlt_consumer this )
587 {
588         xmlDocPtr doc = NULL;
589         
590         // Get the producer service
591         mlt_service service = mlt_service_producer( mlt_consumer_service( this ) );
592         if ( service != NULL )
593         {
594                 mlt_properties properties = mlt_consumer_properties( this );
595                 char *resource =  mlt_properties_get( properties, "resource" );
596
597                 // Set the title if provided
598                 if ( mlt_properties_get( properties, "title" ) )
599                         mlt_properties_set( mlt_service_properties( service ), "title", mlt_properties_get( properties, "title" ) );
600                 else if ( mlt_properties_get( mlt_service_properties( service ), "title" ) == NULL )
601                         mlt_properties_set( mlt_service_properties( service ), "title", "Anonymous Submission" );
602
603                 // Check for a root on the consumer properties and pass to service
604                 if ( mlt_properties_get( properties, "root" ) )
605                         mlt_properties_set( mlt_service_properties( service ), "root", mlt_properties_get( properties, "root" ) );
606
607                 // Specify roots in other cases...
608                 if ( resource != NULL && mlt_properties_get( properties, "root" ) == NULL )
609                 {
610                         // Get the current working directory
611                         char *cwd = getcwd( NULL, 0 );
612                         mlt_properties_set( mlt_service_properties( service ), "root", cwd );
613                         free( cwd );
614                 }
615
616                 // Make the document
617                 doc = westley_make_doc( service );
618
619                 // Handle the output
620                 if ( resource == NULL || !strcmp( resource, "" ) )
621                 {
622                         xmlDocFormatDump( stdout, doc, 1 );
623                 }
624                 else if ( !strcmp( resource, "buffer" ) )
625                 {
626                         xmlChar *buffer = NULL;
627                         int length = 0;
628                         xmlDocDumpMemory( doc, &buffer, &length );
629                         mlt_properties_set_data( properties, "buffer", buffer, length, xmlFree, NULL );
630                 }
631                 else
632                 {
633                         xmlSaveFormatFile( resource, doc, 1 );
634                 }
635                 
636                 // Close the document
637                 xmlFreeDoc( doc );
638         }
639         
640         mlt_consumer_stop( this );
641
642         mlt_consumer_stopped( this );
643
644         return 0;
645 }
646
647 static int consumer_is_stopped( mlt_consumer this )
648 {
649         return 1;
650 }