research.m1stereo.tv/gitweb/ - melted/blob - src/framework/mlt_producer.c

   1 /*
   2  * mlt_producer.c -- abstraction for all producer services
   3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
   4  * Author: Charles Yates <charles.yates@pandora.be>
   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 "config.h"
  22 #include "mlt_producer.h"
  23 #include "mlt_factory.h"
  24 #include "mlt_frame.h"
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <math.h>
  29
  30 /** Forward references.
  31 */
  32
  33 static int producer_get_frame( mlt_service this, mlt_frame_ptr frame, int index );
  34
  35 /** Constructor
  36 */
  37
  38 int mlt_producer_init( mlt_producer this, void *child )
  39 {
  40         // Check that we haven't received NULL
  41         int error = this == NULL;
  42
  43         // Continue if no error
  44         if ( error == 0 )
  45         {
  46                 // Initialise the producer
  47                 memset( this, 0, sizeof( struct mlt_producer_s ) );
  48
  49                 // Associate with the child
  50                 this->child = child;
  51
  52                 // Initialise the service
  53                 if ( mlt_service_init( &this->parent, this ) == 0 )
  54                 {
  55                         // Get the normalisation preference
  56                         char *normalisation = mlt_environment( "MLT_NORMALISATION" );
  57
  58                         // The parent is the service
  59                         mlt_service parent = &this->parent;
  60
  61                         // Get the properties of the parent
  62                         mlt_properties properties = mlt_service_properties( parent );
  63
  64                         // Set the default properties
  65                         mlt_properties_set( properties, "mlt_type", "mlt_producer" );
  66                         mlt_properties_set_position( properties, "_position", 0.0 );
  67                         mlt_properties_set_double( properties, "_frame", 0 );
  68                         if ( normalisation == NULL || strcmp( normalisation, "NTSC" ) )
  69                         {
  70                                 mlt_properties_set_double( properties, "fps", 25.0 );
  71                                 mlt_properties_set_double( properties, "aspect_ratio", 72.0 / 79.0 );
  72                         }
  73                         else
  74                         {
  75                                 mlt_properties_set_double( properties, "fps", 30000.0 / 1001.0 );
  76                                 mlt_properties_set_double( properties, "aspect_ratio", 128.0 / 117.0 );
  77                         }
  78                         mlt_properties_set_double( properties, "_speed", 1.0 );
  79                         mlt_properties_set_position( properties, "in", 0 );
  80                         mlt_properties_set_position( properties, "out", 14999 );
  81                         mlt_properties_set_position( properties, "length", 15000 );
  82                         mlt_properties_set( properties, "eof", "pause" );
  83                         mlt_properties_set( properties, "resource", "<producer>" );
  84
  85                         // Override service get_frame
  86                         parent->get_frame = producer_get_frame;
  87                 }
  88         }
  89
  90         return error;
  91 }
  92
  93 /** Get the parent service object.
  94 */
  95
  96 mlt_service mlt_producer_service( mlt_producer this )
  97 {
  98         return &this->parent;
  99 }
 100
 101 /** Get the producer properties.
 102 */
 103
 104 mlt_properties mlt_producer_properties( mlt_producer this )
 105 {
 106         return mlt_service_properties( &this->parent );
 107 }
 108
 109 /** Seek to a specified position.
 110 */
 111
 112 int mlt_producer_seek( mlt_producer this, mlt_position position )
 113 {
 114         // Determine eof handling
 115         char *eof = mlt_properties_get( mlt_producer_properties( this ), "eof" );
 116
 117         // Check bounds
 118         if ( position < 0 )
 119         {
 120                 position = 0;
 121         }
 122         else if ( !strcmp( eof, "pause" ) && position >= mlt_producer_get_playtime( this ) )
 123         {
 124                 mlt_producer_set_speed( this, 0 );
 125                 position = mlt_producer_get_playtime( this ) - 1;
 126         }
 127         else if ( !strcmp( eof, "loop" ) && position >= mlt_producer_get_playtime( this ) )
 128         {
 129                 position = position % mlt_producer_get_playtime( this );
 130         }
 131
 132         // Set the position
 133         mlt_properties_set_position( mlt_producer_properties( this ), "_position", position );
 134
 135         // Calculate the absolute frame
 136         mlt_properties_set_position( mlt_producer_properties( this ), "_frame", mlt_producer_get_in( this ) + position );
 137
 138         return 0;
 139 }
 140
 141 /** Get the current position (relative to in point).
 142 */
 143
 144 mlt_position mlt_producer_position( mlt_producer this )
 145 {
 146         return mlt_properties_get_position( mlt_producer_properties( this ), "_position" );
 147 }
 148
 149 /** Get the current position (relative to start of producer).
 150 */
 151
 152 mlt_position mlt_producer_frame( mlt_producer this )
 153 {
 154         return mlt_properties_get_position( mlt_producer_properties( this ), "_frame" );
 155 }
 156
 157 /** Set the playing speed.
 158 */
 159
 160 int mlt_producer_set_speed( mlt_producer this, double speed )
 161 {
 162         return mlt_properties_set_double( mlt_producer_properties( this ), "_speed", speed );
 163 }
 164
 165 /** Get the playing speed.
 166 */
 167
 168 double mlt_producer_get_speed( mlt_producer this )
 169 {
 170         return mlt_properties_get_double( mlt_producer_properties( this ), "_speed" );
 171 }
 172
 173 /** Get the frames per second.
 174 */
 175
 176 double mlt_producer_get_fps( mlt_producer this )
 177 {
 178         return mlt_properties_get_double( mlt_producer_properties( this ), "fps" );
 179 }
 180
 181 /** Set the in and out points.
 182 */
 183
 184 int mlt_producer_set_in_and_out( mlt_producer this, mlt_position in, mlt_position out )
 185 {
 186         // Correct ins and outs if necessary
 187         if ( in < 0 )
 188                 in = 0;
 189         else if ( in > mlt_producer_get_length( this ) )
 190                 in = mlt_producer_get_length( this );
 191
 192         if ( out < 0 )
 193                 out = 0;
 194         else if ( out > mlt_producer_get_length( this ) )
 195                 out = mlt_producer_get_length( this );
 196
 197         // Swap ins and outs if wrong
 198         if ( out < in )
 199         {
 200                 mlt_position t = in;
 201                 in = out;
 202                 out = t;
 203         }
 204
 205         // Set the values
 206         mlt_properties_set_position( mlt_producer_properties( this ), "in", in );
 207         mlt_properties_set_position( mlt_producer_properties( this ), "out", out );
 208
 209         return 0;
 210 }
 211
 212 /** Get the in point.
 213 */
 214
 215 mlt_position mlt_producer_get_in( mlt_producer this )
 216 {
 217         return mlt_properties_get_position( mlt_producer_properties( this ), "in" );
 218 }
 219
 220 /** Get the out point.
 221 */
 222
 223 mlt_position mlt_producer_get_out( mlt_producer this )
 224 {
 225         return mlt_properties_get_position( mlt_producer_properties( this ), "out" );
 226 }
 227
 228 /** Get the total play time.
 229 */
 230
 231 mlt_position mlt_producer_get_playtime( mlt_producer this )
 232 {
 233         return mlt_producer_get_out( this ) - mlt_producer_get_in( this ) + 1;
 234 }
 235
 236 /** Get the total length of the producer.
 237 */
 238
 239 mlt_position mlt_producer_get_length( mlt_producer this )
 240 {
 241         return mlt_properties_get_position( mlt_producer_properties( this ), "length" );
 242 }
 243
 244 /** Prepare for next frame.
 245 */
 246
 247 void mlt_producer_prepare_next( mlt_producer this )
 248 {
 249         mlt_producer_seek( this, mlt_producer_position( this ) + mlt_producer_get_speed( this ) );
 250 }
 251
 252 /** Get a frame.
 253 */
 254
 255 static int producer_get_frame( mlt_service service, mlt_frame_ptr frame, int index )
 256 {
 257         int result = 1;
 258         mlt_producer this = service->child;
 259
 260         // Determine eof handling
 261         char *eof = mlt_properties_get( mlt_producer_properties( this ), "eof" );
 262
 263         // A properly instatiated producer will have a get_frame method...
 264         if ( this->get_frame == NULL || ( !strcmp( eof, "continue" ) && mlt_producer_position( this ) > mlt_producer_get_out( this ) ) )
 265         {
 266                 // Generate a test frame
 267                 *frame = mlt_frame_init( );
 268
 269                 // Set the position
 270                 result = mlt_frame_set_position( *frame, mlt_producer_position( this ) );
 271
 272                 // Mark as a test card
 273                 mlt_properties_set_int( mlt_frame_properties( *frame ), "test_image", 1 );
 274                 mlt_properties_set_int( mlt_frame_properties( *frame ), "test_audio", 1 );
 275
 276                 // Calculate the next position
 277                 mlt_producer_prepare_next( this );
 278         }
 279         else
 280         {
 281                 // Get the frame from the implementation
 282                 result = this->get_frame( this, frame, index );
 283         }
 284
 285         // Copy the fps and speed of the producer onto the frame
 286         mlt_properties properties = mlt_frame_properties( *frame );
 287         mlt_properties_set_double( properties, "fps", mlt_producer_get_fps( this ) );
 288         double speed = mlt_producer_get_speed( this );
 289         mlt_properties_set_double( properties, "_speed", speed );
 290
 291         return 0;
 292 }
 293
 294 /** Close the producer.
 295 */
 296
 297 void mlt_producer_close( mlt_producer this )
 298 {
 299         if ( this->close != NULL )
 300                 this->close( this );
 301         else
 302                 mlt_service_close( &this->parent );
 303 }