git.sesse.net Git - mlt/blob - src/framework/mlt_profile.c

   1 /**
   2  * \file mlt_profile.c
   3  * \brief video output definition
   4  * \see mlt_profile_s
   5  *
   6  * Copyright (C) 2007-2009 Ushodaya Enterprises Limited
   7  * \author Dan Dennedy <dan@dennedy.org>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "mlt_profile.h"
  25 #include "mlt_factory.h"
  26 #include "mlt_properties.h"
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <libgen.h>
  31
  32
  33 /** the default subdirectory of the prefix for holding profiles */
  34 #define PROFILES_DIR "/share/mlt/profiles/"
  35
  36 /** Load a profile from the system folder.
  37  *
  38  * The environment variable MLT_PROFILES_PATH overrides the default \p PROFILES_DIR.
  39  *
  40  * \private \memberof mlt_profile_s
  41  * \param name the name of a profile settings file located in the standard location or
  42  * the full path name to a profile settings file
  43  * \return a profile or NULL on error
  44  */
  45
  46 static mlt_profile mlt_profile_select( const char *name )
  47 {
  48         char *filename = NULL;
  49         const char *prefix = getenv( "MLT_PROFILES_PATH" );
  50         mlt_properties properties = mlt_properties_load( name );
  51         mlt_profile profile = NULL;
  52
  53         // Try to load from file specification
  54         if ( properties && mlt_properties_get_int( properties, "width" ) )
  55         {
  56                 filename = calloc( 1, strlen( name ) + 1 );
  57         }
  58         // Load from $prefix/share/mlt/profiles
  59         else if ( prefix == NULL )
  60         {
  61                 prefix = PREFIX;
  62                 filename = calloc( 1, strlen( prefix ) + strlen( PROFILES_DIR ) + strlen( name ) + 2 );
  63                 strcpy( filename, prefix );
  64                 if ( filename[ strlen( filename ) - 1 ] != '/' )
  65                         filename[ strlen( filename ) ] = '/';
  66                 strcat( filename, PROFILES_DIR );
  67         }
  68         // Use environment variable instead
  69         else
  70         {
  71                 filename = calloc( 1, strlen( prefix ) + strlen( name ) + 2 );
  72                 strcpy( filename, prefix );
  73                 if ( filename[ strlen( filename ) - 1 ] != '/' )
  74                         filename[ strlen( filename ) ] = '/';
  75         }
  76
  77         // Finish loading
  78         strcat( filename, name );
  79         profile = mlt_profile_load_file( filename );
  80
  81         // Cleanup
  82         mlt_properties_close( properties );
  83         free( filename );
  84
  85         return profile;
  86 }
  87
  88 /** Construct a profile.
  89  *
  90  * This will never return NULL as it uses the dv_pal settings as hard-coded fallback default.
  91  *
  92  * \public \memberof mlt_profile_s
  93  * @param name the name of a profile settings file located in the standard location or
  94  * the full path name to a profile settings file
  95  * @return a profile
  96  */
  97
  98 mlt_profile mlt_profile_init( const char *name )
  99 {
 100         mlt_profile profile = NULL;
 101
 102         // Explicit profile by name gets priority over environment variables
 103         if ( name )
 104                 profile = mlt_profile_select( name );
 105
 106         // Try to load by environment variable
 107         if ( profile == NULL )
 108         {
 109                 // MLT_PROFILE is preferred environment variable
 110                 if ( getenv( "MLT_PROFILE" ) )
 111                         profile = mlt_profile_select( getenv( "MLT_PROFILE" ) );
 112                 // MLT_NORMALISATION backwards compatibility
 113                 else if ( getenv( "MLT_NORMALISATION" ) && strcmp( getenv( "MLT_NORMALISATION" ), "PAL" ) )
 114                         profile = mlt_profile_select( "dv_ntsc" );
 115                 else
 116                         profile = mlt_profile_select( "dv_pal" );
 117
 118                 // If still not loaded (no profile files), default to PAL
 119                 if ( profile == NULL )
 120                 {
 121                         profile = calloc( 1, sizeof( struct mlt_profile_s ) );
 122                         if ( profile )
 123                         {
 124                                 mlt_environment_set( "MLT_PROFILE", "dv_pal" );
 125                                 profile->description = strdup( "PAL 4:3 DV or DVD" );
 126                                 profile->frame_rate_num = 25;
 127                                 profile->frame_rate_den = 1;
 128                                 profile->width = 720;
 129                                 profile->height = 576;
 130                                 profile->progressive = 0;
 131                                 profile->sample_aspect_num = 16;
 132                                 profile->sample_aspect_den = 15;
 133                                 profile->display_aspect_num = 4;
 134                                 profile->display_aspect_den = 3;
 135                         }
 136                 }
 137         }
 138         return profile;
 139 }
 140
 141 static void set_mlt_normalisation( const char *profile_name )
 142 {
 143         if ( profile_name )
 144         {
 145                 if ( strstr( profile_name, "_ntsc" ) ||
 146                      strstr( profile_name, "_60" ) ||
 147                      strstr( profile_name, "_5994" ) ||
 148                      strstr( profile_name, "_2997" ) ||
 149                      strstr( profile_name, "_30" ) )
 150                 {
 151                         mlt_environment_set( "MLT_NORMALISATION", "NTSC" );
 152                 }
 153                 else if ( strstr( profile_name, "_pal" ) ||
 154                           strstr( profile_name, "_50" ) ||
 155                           strstr( profile_name, "_25" ) )
 156                 {
 157                         mlt_environment_set( "MLT_NORMALISATION", "PAL" );
 158                 }
 159         }
 160 }
 161
 162 /** Load a profile from specific file.
 163  *
 164  * \public \memberof mlt_profile_s
 165  * @param file the full path name to a properties file
 166  * @return a profile or NULL on error
 167  */
 168
 169 mlt_profile mlt_profile_load_file( const char *file )
 170 {
 171         mlt_profile profile = NULL;
 172
 173         // Load the profile as properties
 174         mlt_properties properties = mlt_properties_load( file );
 175         if ( properties )
 176         {
 177                 // Simple check if the profile is valid
 178                 if ( mlt_properties_get_int( properties, "width" ) )
 179                 {
 180                         profile = mlt_profile_load_properties( properties );
 181
 182                         // Set MLT_PROFILE to basename
 183                         char *filename = strdup( file );
 184                         mlt_environment_set( "MLT_PROFILE", basename( filename ) );
 185                         set_mlt_normalisation( basename( filename ) );
 186                         free( filename );
 187                 }
 188                 mlt_properties_close( properties );
 189         }
 190
 191         // Set MLT_NORMALISATION to appease legacy modules
 192         char *profile_name = mlt_environment( "MLT_PROFILE" );
 193         set_mlt_normalisation( profile_name );
 194         return profile;
 195 }
 196
 197 /** Load a profile from a properties object.
 198  *
 199  * \public \memberof mlt_profile_s
 200  * @param properties a properties list
 201  * @return a profile or NULL if out of memory
 202  */
 203
 204 mlt_profile mlt_profile_load_properties( mlt_properties properties )
 205 {
 206         mlt_profile profile = calloc( 1, sizeof( struct mlt_profile_s ) );
 207         if ( profile )
 208         {
 209                 if ( mlt_properties_get( properties, "name" ) )
 210                         mlt_environment_set( "MLT_PROFILE", mlt_properties_get( properties, "name" ) );
 211                 if ( mlt_properties_get( properties, "description" ) )
 212                         profile->description = strdup( mlt_properties_get( properties, "description" ) );
 213                 profile->frame_rate_num = mlt_properties_get_int( properties, "frame_rate_num" );
 214                 profile->frame_rate_den = mlt_properties_get_int( properties, "frame_rate_den" );
 215                 profile->width = mlt_properties_get_int( properties, "width" );
 216                 profile->height = mlt_properties_get_int( properties, "height" );
 217                 profile->progressive = mlt_properties_get_int( properties, "progressive" );
 218                 profile->sample_aspect_num = mlt_properties_get_int( properties, "sample_aspect_num" );
 219                 profile->sample_aspect_den = mlt_properties_get_int( properties, "sample_aspect_den" );
 220                 profile->display_aspect_num = mlt_properties_get_int( properties, "display_aspect_num" );
 221                 profile->display_aspect_den = mlt_properties_get_int( properties, "display_aspect_den" );
 222         }
 223         return profile;
 224 }
 225
 226 /** Load an anonymous profile from string.
 227  *
 228  * \public \memberof mlt_profile_s
 229  * @param string a newline-delimited list of properties as name=value pairs
 230  * @return a profile or NULL if out of memory
 231  */
 232
 233 mlt_profile mlt_profile_load_string( const char *string )
 234 {
 235         mlt_properties properties = mlt_properties_new();
 236         if ( properties )
 237         {
 238                 const char *p = string;
 239                 while ( p )
 240                 {
 241                         if ( strcmp( p, "" ) && p[ 0 ] != '#' )
 242                                 mlt_properties_parse( properties, p );
 243                         p = strchr( p, '\n' );
 244                         if ( p ) p++;
 245                 }
 246         }
 247         return mlt_profile_load_properties( properties );
 248 }
 249
 250 /** Get the video frame rate as a floating point value.
 251  *
 252  * \public \memberof mlt_profile_s
 253  * @param aprofile a profile
 254  * @return the frame rate
 255  */
 256
 257 double mlt_profile_fps( mlt_profile aprofile )
 258 {
 259         if ( aprofile )
 260                 return ( double ) aprofile->frame_rate_num / aprofile->frame_rate_den;
 261         else
 262                 return 0;
 263 }
 264
 265 /** Get the sample aspect ratio as a floating point value.
 266  *
 267  * \public \memberof mlt_profile_s
 268  * @param aprofile a profile
 269  * @return the pixel aspect ratio
 270  */
 271
 272 double mlt_profile_sar( mlt_profile aprofile )
 273 {
 274         if ( aprofile )
 275                 return ( double ) aprofile->sample_aspect_num / aprofile->sample_aspect_den;
 276         else
 277                 return 0;
 278 }
 279
 280 /** Get the display aspect ratio as floating point value.
 281  *
 282  * \public \memberof mlt_profile_s
 283  * @param aprofile a profile
 284  * @return the image aspect ratio
 285  */
 286
 287 double mlt_profile_dar( mlt_profile aprofile )
 288 {
 289         if ( aprofile )
 290                 return ( double ) aprofile->display_aspect_num / aprofile->display_aspect_den;
 291         else
 292                 return 0;
 293 }
 294
 295 /** Free up the global profile resources.
 296  *
 297  * \public \memberof mlt_profile_s
 298  * @param profile a profile
 299  */
 300
 301 void mlt_profile_close( mlt_profile profile )
 302 {
 303         if ( profile )
 304         {
 305                 if ( profile->description )
 306                         free( profile->description );
 307                 profile->description = NULL;
 308                 free( profile );
 309                 profile = NULL;
 310         }
 311 }