git.sesse.net Git - mlt/blob - mlt/src/inigo/inigo.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include <framework/mlt.h>
   6
   7 #include "io.h"
   8
   9 mlt_producer create_producer( char *file )
  10 {
  11         mlt_producer result = NULL;
  12
  13         // 1st Line preferences
  14         if ( strstr( file, ".mpg" ) )
  15                 result = mlt_factory_producer( "mcmpeg", file );
  16         else if ( strstr( file, ".mpeg" ) )
  17                 result = mlt_factory_producer( "mcmpeg", file );
  18         else if ( strstr( file, ".dv" ) )
  19                 result = mlt_factory_producer( "mcdv", file );
  20         else if ( strstr( file, ".dif" ) )
  21                 result = mlt_factory_producer( "mcdv", file );
  22         else if ( strstr( file, ".jpg" ) )
  23                 result = mlt_factory_producer( "pixbuf", file );
  24         else if ( strstr( file, ".JPG" ) )
  25                 result = mlt_factory_producer( "pixbuf", file );
  26         else if ( strstr( file, ".jpeg" ) )
  27                 result = mlt_factory_producer( "pixbuf", file );
  28         else if ( strstr( file, ".png" ) )
  29                 result = mlt_factory_producer( "pixbuf", file );
  30
  31         // 2nd Line fallbacks
  32         if ( result == NULL && strstr( file, ".dv" ) )
  33                 result = mlt_factory_producer( "libdv", file );
  34         else if ( result == NULL && strstr( file, ".dif" ) )
  35                 result = mlt_factory_producer( "libdv", file );
  36
  37         // 3rd line fallbacks
  38         if ( result == NULL )
  39                 result = mlt_factory_producer( "ffmpeg", file );
  40
  41         return result;
  42 }
  43
  44 void transport_action( mlt_producer producer, char *value )
  45 {
  46         mlt_properties properties = mlt_producer_properties( producer );
  47         mlt_multitrack multitrack = mlt_properties_get_data( properties, "multitrack", NULL );
  48
  49         if ( strlen( value ) == 1 )
  50         {
  51                 switch( value[ 0 ] )
  52                 {
  53                         case 'q':
  54                                 mlt_properties_set_int( properties, "done", 1 );
  55                                 break;
  56                         case '0':
  57                                 mlt_producer_set_speed( producer, 1 );
  58                                 mlt_producer_seek( producer, 0 );
  59                                 break;
  60                         case '1':
  61                                 mlt_producer_set_speed( producer, -10 );
  62                                 break;
  63                         case '2':
  64                                 mlt_producer_set_speed( producer, -5 );
  65                                 break;
  66                         case '3':
  67                                 mlt_producer_set_speed( producer, -2 );
  68                                 break;
  69                         case '4':
  70                                 mlt_producer_set_speed( producer, -1 );
  71                                 break;
  72                         case '5':
  73                                 mlt_producer_set_speed( producer, 0 );
  74                                 break;
  75                         case '6':
  76                                 mlt_producer_set_speed( producer, 1 );
  77                                 break;
  78                         case '7':
  79                                 mlt_producer_set_speed( producer, 2 );
  80                                 break;
  81                         case '8':
  82                                 mlt_producer_set_speed( producer, 5 );
  83                                 break;
  84                         case '9':
  85                                 mlt_producer_set_speed( producer, 10 );
  86                                 break;
  87                         case 'j':
  88                                 if ( multitrack != NULL )
  89                                 {
  90                                         mlt_timecode time = mlt_multitrack_clip( multitrack, mlt_whence_relative_current, -1 );
  91                                         mlt_producer_seek( producer, time );
  92                                         mlt_producer_prepare_next( producer );
  93                                 }
  94                                 break;
  95                         case 'k':
  96                                 if ( multitrack != NULL )
  97                                 {
  98                                         mlt_timecode time = mlt_multitrack_clip( multitrack, mlt_whence_relative_current, 0 );
  99                                         mlt_producer_seek( producer, time );
 100                                         mlt_producer_prepare_next( producer );
 101                                 }
 102                                 break;
 103                         case 'l':
 104                                 if ( multitrack != NULL )
 105                                 {
 106                                         mlt_timecode time = mlt_multitrack_clip( multitrack, mlt_whence_relative_current, 1 );
 107                                         mlt_producer_seek( producer, time );
 108                                         mlt_producer_prepare_next( producer );
 109                                 }
 110                                 break;
 111                 }
 112         }
 113 }
 114
 115 mlt_consumer create_consumer( char *id, mlt_producer producer )
 116 {
 117         char *arg = strchr( id, ':' );
 118         if ( arg != NULL )
 119                 *arg ++ = '\0';
 120         mlt_consumer consumer = mlt_factory_consumer( id, arg );
 121         if ( consumer != NULL )
 122         {
 123                 mlt_properties properties = mlt_consumer_properties( consumer );
 124                 mlt_properties_set_data( properties, "transport_callback", transport_action, 0, NULL, NULL );
 125                 mlt_properties_set_data( properties, "transport_producer", producer, 0, NULL, NULL );
 126         }
 127         return consumer;
 128 }
 129
 130 void track_service( mlt_field field, void *service, mlt_destructor destructor )
 131 {
 132         mlt_properties properties = mlt_field_properties( field );
 133         int registered = mlt_properties_get_int( properties, "registered" );
 134         char *key = mlt_properties_get( properties, "registered" );
 135         mlt_properties_set_data( properties, key, service, 0, destructor, NULL );
 136         mlt_properties_set_int( properties, "registered", ++ registered );
 137 }
 138
 139 mlt_filter create_filter( mlt_field field, char *id, int track )
 140 {
 141         char *arg = strchr( id, ':' );
 142         if ( arg != NULL )
 143                 *arg ++ = '\0';
 144         mlt_filter filter = mlt_factory_filter( id, arg );
 145         if ( filter != NULL )
 146         {
 147                 mlt_field_plant_filter( field, filter, track );
 148                 track_service( field, filter, ( mlt_destructor )mlt_filter_close );
 149         }
 150         return filter;
 151 }
 152
 153 void set_properties( mlt_properties properties, char *namevalue )
 154 {
 155         mlt_properties_parse( properties, namevalue );
 156 }
 157
 158 void transport( mlt_producer producer )
 159 {
 160         mlt_properties properties = mlt_producer_properties( producer );
 161
 162         term_init( );
 163
 164         fprintf( stderr, "+-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+\n" );
 165         fprintf( stderr, "|1=-10| |2= -5| |3= -2| |4= -1| |5=  0| |6=  1| |7=  2| |8=  5| |9= 10|\n" );
 166         fprintf( stderr, "+-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+\n" );
 167
 168         fprintf( stderr, "+---------------------------------------------------------------------+\n" );
 169         fprintf( stderr, "|             j = previous, k = restart current, l = next             |\n" );
 170         fprintf( stderr, "|                       0 = restart, q = quit                         |\n" );
 171         fprintf( stderr, "+---------------------------------------------------------------------+\n" );
 172
 173         while( mlt_properties_get_int( properties, "done" ) == 0 )
 174         {
 175                 int value = term_read( );
 176                 if ( value != -1 )
 177                         transport_action( producer, ( char * )&value );
 178         }
 179 }
 180
 181 int main( int argc, char **argv )
 182 {
 183         int i;
 184         mlt_consumer consumer = NULL;
 185         mlt_multitrack multitrack = NULL;
 186         mlt_producer producer = NULL;
 187         mlt_playlist playlist = NULL;
 188         mlt_field field = NULL;
 189         mlt_properties group = mlt_properties_new( );
 190         mlt_properties properties = group;
 191
 192         // Construct the factory
 193         mlt_factory_init( getenv( "MLT_REPOSITORY" ) );
 194
 195         // Set up containers
 196         playlist = mlt_playlist_init( );
 197
 198         // Construct the field
 199         field = mlt_field_init( );
 200
 201         // We need to track the number of registered filters
 202         mlt_properties field_properties = mlt_field_properties( field );
 203         mlt_properties_set_int( field_properties, "registered", 0 );
 204
 205         // Get the multitrack from the field
 206         multitrack = mlt_field_multitrack( field );
 207
 208         // Parse the arguments
 209         for ( i = 1; i < argc; i ++ )
 210         {
 211                 if ( !strcmp( argv[ i ], "-consumer" ) )
 212                 {
 213                         consumer = create_consumer( argv[ ++ i ], mlt_multitrack_producer( multitrack ) );
 214                         if ( consumer != NULL )
 215                         {
 216                                 properties = mlt_consumer_properties( consumer );
 217                                 mlt_properties_inherit( properties, group );
 218                         }
 219                 }
 220                 else if ( !strcmp( argv[ i ], "-group" ) )
 221                 {
 222                         if ( mlt_properties_count( group ) != 0 )
 223                         {
 224                                 mlt_properties_close( group );
 225                                 group = mlt_properties_new( );
 226                         }
 227                         if ( group != NULL )
 228                                 properties = group;
 229                 }
 230                 else if ( !strcmp( argv[ i ], "-filter" ) )
 231                 {
 232                         mlt_filter filter = create_filter( field, argv[ ++ i ], 0 );
 233                         if ( filter != NULL )
 234                         {
 235                                 properties = mlt_filter_properties( filter );
 236                                 mlt_properties_inherit( properties, group );
 237                         }
 238                 }
 239                 else if ( !strstr( argv[ i ], "=" ) )
 240                 {
 241                         if ( producer != NULL )
 242                                 mlt_playlist_append( playlist, producer );
 243                         producer = create_producer( argv[ i ] );
 244                         if ( producer != NULL )
 245                         {
 246                                 properties = mlt_producer_properties( producer );
 247                                 mlt_properties_inherit( properties, group );
 248                         }
 249                 }
 250                 else
 251                 {
 252                         set_properties( properties, argv[ i ] );
 253                 }
 254         }
 255
 256         // We must have a producer at this point
 257         if ( producer != NULL )
 258         {
 259                 // If we have no consumer, default to sdl
 260                 if ( consumer == NULL )
 261                 {
 262                         consumer = create_consumer( "sdl", mlt_multitrack_producer( multitrack ) );
 263                         if ( consumer != NULL )
 264                         {
 265                                 properties = mlt_consumer_properties( consumer );
 266                                 mlt_properties_inherit( properties, group );
 267                         }
 268                 }
 269
 270                 // Connect producer to playlist
 271                 mlt_playlist_append( playlist, producer );
 272
 273                 // Connect multitrack to producer
 274                 mlt_multitrack_connect( multitrack, mlt_playlist_producer( playlist ), 0 );
 275
 276                 // Connect consumer to tractor
 277                 mlt_consumer_connect( consumer, mlt_field_service( field ) );
 278
 279                 // Transport functionality
 280                 transport( mlt_multitrack_producer( multitrack ) );
 281
 282                 // Close the services
 283                 mlt_consumer_close( consumer );
 284                 mlt_producer_close( producer );
 285         }
 286         else
 287         {
 288                 fprintf( stderr, "Usage: inigo [ -group [ name=value ]* ]\n"
 289                                                  "             [ -consumer id[:arg] [ name=value ]* ]\n"
 290                                          "             [ -filter id[:arg] [ name=value ] * ]\n"
 291                                          "             [ producer [ name=value ] * ]+\n" );
 292         }
 293
 294         // Close the field
 295         mlt_field_close( field );
 296
 297         // Close the group
 298         mlt_properties_close( group );
 299
 300         // Close the factory
 301         mlt_factory_close( );
 302
 303         return 0;
 304 }