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

   1 /**
   2  * \file mlt_frame.c
   3  * \brief interface for all frame classes
   4  * \see mlt_frame_s
   5  *
   6  * Copyright (C) 2003-2009 Ushodaya Enterprises Limited
   7  * \author Charles Yates <charles.yates@pandora.be>
   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_frame.h"
  25 #include "mlt_producer.h"
  26 #include "mlt_factory.h"
  27 #include "mlt_profile.h"
  28 #include "mlt_log.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 /** Constructor for a frame.
  35 */
  36
  37 mlt_frame mlt_frame_init( mlt_service service )
  38 {
  39         // Allocate a frame
  40         mlt_frame this = calloc( sizeof( struct mlt_frame_s ), 1 );
  41
  42         if ( this != NULL )
  43         {
  44                 mlt_profile profile = mlt_service_profile( service );
  45
  46                 // Initialise the properties
  47                 mlt_properties properties = &this->parent;
  48                 mlt_properties_init( properties, this );
  49
  50                 // Set default properties on the frame
  51                 mlt_properties_set_position( properties, "_position", 0.0 );
  52                 mlt_properties_set_data( properties, "image", NULL, 0, NULL, NULL );
  53                 mlt_properties_set_int( properties, "width", profile? profile->width : 720 );
  54                 mlt_properties_set_int( properties, "height", profile? profile->height : 576 );
  55                 mlt_properties_set_int( properties, "normalised_width", profile? profile->width : 720 );
  56                 mlt_properties_set_int( properties, "normalised_height", profile? profile->height : 576 );
  57                 mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( NULL ) );
  58                 mlt_properties_set_data( properties, "audio", NULL, 0, NULL, NULL );
  59                 mlt_properties_set_data( properties, "alpha", NULL, 0, NULL, NULL );
  60
  61                 // Construct stacks for frames and methods
  62                 this->stack_image = mlt_deque_init( );
  63                 this->stack_audio = mlt_deque_init( );
  64                 this->stack_service = mlt_deque_init( );
  65         }
  66
  67         return this;
  68 }
  69
  70 /** Fetch the frames properties.
  71 */
  72
  73 mlt_properties mlt_frame_properties( mlt_frame this )
  74 {
  75         return this != NULL ? &this->parent : NULL;
  76 }
  77
  78 /** Check if we have a way to derive something other than a test card.
  79 */
  80
  81 int mlt_frame_is_test_card( mlt_frame this )
  82 {
  83         return mlt_deque_count( this->stack_image ) == 0 || mlt_properties_get_int( MLT_FRAME_PROPERTIES( this ), "test_image" );
  84 }
  85
  86 /** Check if we have a way to derive something other than test audio.
  87 */
  88
  89 int mlt_frame_is_test_audio( mlt_frame this )
  90 {
  91         return mlt_deque_count( this->stack_audio ) == 0 || mlt_properties_get_int( MLT_FRAME_PROPERTIES( this ), "test_audio" );
  92 }
  93
  94 /** Get the aspect ratio of the frame.
  95 */
  96
  97 double mlt_frame_get_aspect_ratio( mlt_frame this )
  98 {
  99         return mlt_properties_get_double( MLT_FRAME_PROPERTIES( this ), "aspect_ratio" );
 100 }
 101
 102 /** Set the aspect ratio of the frame.
 103 */
 104
 105 int mlt_frame_set_aspect_ratio( mlt_frame this, double value )
 106 {
 107         return mlt_properties_set_double( MLT_FRAME_PROPERTIES( this ), "aspect_ratio", value );
 108 }
 109
 110 /** Get the position of this frame.
 111 */
 112
 113 mlt_position mlt_frame_get_position( mlt_frame this )
 114 {
 115         int pos = mlt_properties_get_position( MLT_FRAME_PROPERTIES( this ), "_position" );
 116         return pos < 0 ? 0 : pos;
 117 }
 118
 119 /** Set the position of this frame.
 120 */
 121
 122 int mlt_frame_set_position( mlt_frame this, mlt_position value )
 123 {
 124         return mlt_properties_set_position( MLT_FRAME_PROPERTIES( this ), "_position", value );
 125 }
 126
 127 /** Stack a get_image callback.
 128 */
 129
 130 int mlt_frame_push_get_image( mlt_frame this, mlt_get_image get_image )
 131 {
 132         return mlt_deque_push_back( this->stack_image, get_image );
 133 }
 134
 135 /** Pop a get_image callback.
 136 */
 137
 138 mlt_get_image mlt_frame_pop_get_image( mlt_frame this )
 139 {
 140         return mlt_deque_pop_back( this->stack_image );
 141 }
 142
 143 /** Push a frame.
 144 */
 145
 146 int mlt_frame_push_frame( mlt_frame this, mlt_frame that )
 147 {
 148         return mlt_deque_push_back( this->stack_image, that );
 149 }
 150
 151 /** Pop a frame.
 152 */
 153
 154 mlt_frame mlt_frame_pop_frame( mlt_frame this )
 155 {
 156         return mlt_deque_pop_back( this->stack_image );
 157 }
 158
 159 /** Push a service.
 160 */
 161
 162 int mlt_frame_push_service( mlt_frame this, void *that )
 163 {
 164         return mlt_deque_push_back( this->stack_image, that );
 165 }
 166
 167 /** Pop a service.
 168 */
 169
 170 void *mlt_frame_pop_service( mlt_frame this )
 171 {
 172         return mlt_deque_pop_back( this->stack_image );
 173 }
 174
 175 /** Push a service.
 176 */
 177
 178 int mlt_frame_push_service_int( mlt_frame this, int that )
 179 {
 180         return mlt_deque_push_back_int( this->stack_image, that );
 181 }
 182
 183 /** Pop a service.
 184 */
 185
 186 int mlt_frame_pop_service_int( mlt_frame this )
 187 {
 188         return mlt_deque_pop_back_int( this->stack_image );
 189 }
 190
 191 /** Push an audio item on the stack.
 192 */
 193
 194 int mlt_frame_push_audio( mlt_frame this, void *that )
 195 {
 196         return mlt_deque_push_back( this->stack_audio, that );
 197 }
 198
 199 /** Pop an audio item from the stack
 200 */
 201
 202 void *mlt_frame_pop_audio( mlt_frame this )
 203 {
 204         return mlt_deque_pop_back( this->stack_audio );
 205 }
 206
 207 /** Return the service stack
 208 */
 209
 210 mlt_deque mlt_frame_service_stack( mlt_frame this )
 211 {
 212         return this->stack_service;
 213 }
 214
 215 /** Replace image stack with the information provided.
 216
 217         This might prove to be unreliable and restrictive - the idea is that a transition
 218         which normally uses two images may decide to only use the b frame (ie: in the case
 219         of a composite where the b frame completely obscures the a frame).
 220
 221         The image must be writable and the destructor for the image itself must be taken
 222         care of on another frame and that frame cannot have a replace applied to it...
 223         Further it assumes that no alpha mask is in use.
 224
 225         For these reasons, it can only be used in a specific situation - when you have
 226         multiple tracks each with their own transition and these transitions are applied
 227         in a strictly reversed order (ie: highest numbered [lowest track] is processed
 228         first).
 229
 230         More reliable approach - the cases should be detected during the process phase
 231         and the upper tracks should simply not be invited to stack...
 232 */
 233
 234 void mlt_frame_replace_image( mlt_frame this, uint8_t *image, mlt_image_format format, int width, int height )
 235 {
 236         // Remove all items from the stack
 237         while( mlt_deque_pop_back( this->stack_image ) ) ;
 238
 239         // Update the information
 240         mlt_properties_set_data( MLT_FRAME_PROPERTIES( this ), "image", image, 0, NULL, NULL );
 241         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "width", width );
 242         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "height", height );
 243         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "format", format );
 244         this->get_alpha_mask = NULL;
 245 }
 246
 247 const char * mlt_image_format_name( mlt_image_format format )
 248 {
 249         switch ( format )
 250         {
 251                 case mlt_image_none:    return "none";
 252                 case mlt_image_rgb24:   return "rgb24";
 253                 case mlt_image_rgb24a:  return "rgb24a";
 254                 case mlt_image_yuv422:  return "yuv422";
 255                 case mlt_image_yuv420p: return "yuv420p";
 256                 case mlt_image_opengl:  return "opengl";
 257         }
 258         return "invalid";
 259 }
 260
 261 /** Get the image associated to the frame.
 262 */
 263
 264 int mlt_frame_get_image( mlt_frame this, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
 265 {
 266         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 267         mlt_get_image get_image = mlt_frame_pop_get_image( this );
 268         mlt_producer producer = mlt_properties_get_data( properties, "test_card_producer", NULL );
 269         mlt_image_format requested_format = *format;
 270         int error = 0;
 271
 272         if ( get_image )
 273         {
 274                 mlt_properties_set_int( properties, "image_count", mlt_properties_get_int( properties, "image_count" ) - 1 );
 275                 mlt_position position = mlt_frame_get_position( this );
 276                 error = get_image( this, buffer, format, width, height, writable );
 277                 mlt_properties_set_int( properties, "width", *width );
 278                 mlt_properties_set_int( properties, "height", *height );
 279                 mlt_properties_set_int( properties, "format", *format );
 280                 mlt_frame_set_position( this, position );
 281                 if ( this->convert_image )
 282                         this->convert_image( this, buffer, format, requested_format );
 283         }
 284         else if ( mlt_properties_get_data( properties, "image", NULL ) )
 285         {
 286                 *format = mlt_properties_get_int( properties, "format" );
 287                 *buffer = mlt_properties_get_data( properties, "image", NULL );
 288                 *width = mlt_properties_get_int( properties, "width" );
 289                 *height = mlt_properties_get_int( properties, "height" );
 290                 if ( this->convert_image )
 291                         this->convert_image( this, buffer, format, requested_format );
 292         }
 293         else if ( producer )
 294         {
 295                 mlt_frame test_frame = NULL;
 296                 mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &test_frame, 0 );
 297                 if ( test_frame )
 298                 {
 299                         mlt_properties test_properties = MLT_FRAME_PROPERTIES( test_frame );
 300                         mlt_properties_set_double( test_properties, "consumer_aspect_ratio", mlt_properties_get_double( properties, "consumer_aspect_ratio" ) );
 301                         mlt_properties_set( test_properties, "rescale.interp", mlt_properties_get( properties, "rescale.interp" ) );
 302                         mlt_frame_get_image( test_frame, buffer, format, width, height, writable );
 303                         mlt_properties_set_data( properties, "test_card_frame", test_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
 304                         mlt_properties_set_double( properties, "aspect_ratio", mlt_frame_get_aspect_ratio( test_frame ) );
 305 //                      mlt_properties_set_data( properties, "image", *buffer, *width * *height * 2, NULL, NULL );
 306 //                      mlt_properties_set_int( properties, "width", *width );
 307 //                      mlt_properties_set_int( properties, "height", *height );
 308 //                      mlt_properties_set_int( properties, "format", *format );
 309                 }
 310                 else
 311                 {
 312                         mlt_properties_set_data( properties, "test_card_producer", NULL, 0, NULL, NULL );
 313                         mlt_frame_get_image( this, buffer, format, width, height, writable );
 314                 }
 315         }
 316         else
 317         {
 318                 register uint8_t *p;
 319                 register uint8_t *q;
 320                 int size = 0;
 321
 322                 *width = *width == 0 ? 720 : *width;
 323                 *height = *height == 0 ? 576 : *height;
 324                 size = *width * *height;
 325
 326                 mlt_properties_set_int( properties, "format", *format );
 327                 mlt_properties_set_int( properties, "width", *width );
 328                 mlt_properties_set_int( properties, "height", *height );
 329                 mlt_properties_set_int( properties, "aspect_ratio", 0 );
 330
 331                 switch( *format )
 332                 {
 333                         case mlt_image_none:
 334                                 size = 0;
 335                                 *buffer = NULL;
 336                                 break;
 337                         case mlt_image_rgb24:
 338                                 size *= 3;
 339                                 size += *width * 3;
 340                                 *buffer = mlt_pool_alloc( size );
 341                                 if ( *buffer )
 342                                         memset( *buffer, 255, size );
 343                                 break;
 344                         case mlt_image_rgb24a:
 345                         case mlt_image_opengl:
 346                                 size *= 4;
 347                                 size += *width * 4;
 348                                 *buffer = mlt_pool_alloc( size );
 349                                 if ( *buffer )
 350                                         memset( *buffer, 255, size );
 351                                 break;
 352                         case mlt_image_yuv422:
 353                                 size *= 2;
 354                                 size += *width * 2;
 355                                 *buffer = mlt_pool_alloc( size );
 356                                 p = *buffer;
 357                                 q = p + size;
 358                                 while ( p != NULL && p != q )
 359                                 {
 360                                         *p ++ = 235;
 361                                         *p ++ = 128;
 362                                 }
 363                                 break;
 364                         case mlt_image_yuv420p:
 365                                 size = size * 3 / 2;
 366                                 *buffer = mlt_pool_alloc( size );
 367                                 if ( *buffer )
 368                                         memset( *buffer, 255, size );
 369                                 break;
 370                 }
 371
 372                 mlt_properties_set_data( properties, "image", *buffer, size, ( mlt_destructor )mlt_pool_release, NULL );
 373                 mlt_properties_set_int( properties, "test_image", 1 );
 374         }
 375
 376         mlt_properties_set_int( properties, "scaled_width", *width );
 377         mlt_properties_set_int( properties, "scaled_height", *height );
 378
 379         return error;
 380 }
 381
 382 uint8_t *mlt_frame_get_alpha_mask( mlt_frame this )
 383 {
 384         uint8_t *alpha = NULL;
 385         if ( this != NULL )
 386         {
 387                 if ( this->get_alpha_mask != NULL )
 388                         alpha = this->get_alpha_mask( this );
 389                 if ( alpha == NULL )
 390                         alpha = mlt_properties_get_data( &this->parent, "alpha", NULL );
 391                 if ( alpha == NULL )
 392                 {
 393                         int size = mlt_properties_get_int( &this->parent, "scaled_width" ) * mlt_properties_get_int( &this->parent, "scaled_height" );
 394                         alpha = mlt_pool_alloc( size );
 395                         memset( alpha, 255, size );
 396                         mlt_properties_set_data( &this->parent, "alpha", alpha, size, mlt_pool_release, NULL );
 397                 }
 398         }
 399         return alpha;
 400 }
 401
 402 const char * mlt_audio_format_name( mlt_audio_format format )
 403 {
 404         switch ( format )
 405         {
 406                 case mlt_audio_none:   return "none";
 407                 case mlt_audio_s16:    return "s16";
 408                 case mlt_audio_s32:    return "s32";
 409                 case mlt_audio_float:  return "float";
 410         }
 411         return "invalid";
 412 }
 413
 414 int mlt_frame_get_audio( mlt_frame this, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
 415 {
 416         mlt_get_audio get_audio = mlt_frame_pop_audio( this );
 417         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 418         int hide = mlt_properties_get_int( properties, "test_audio" );
 419         mlt_audio_format requested_format = *format;
 420
 421         if ( hide == 0 && get_audio != NULL )
 422         {
 423                 mlt_position position = mlt_frame_get_position( this );
 424                 get_audio( this, buffer, format, frequency, channels, samples );
 425                 mlt_frame_set_position( this, position );
 426                 mlt_properties_set_int( properties, "audio_frequency", *frequency );
 427                 mlt_properties_set_int( properties, "audio_channels", *channels );
 428                 mlt_properties_set_int( properties, "audio_samples", *samples );
 429                 mlt_properties_set_int( properties, "audio_format", *format );
 430                 if ( this->convert_audio )
 431                         this->convert_audio( this, buffer, format, requested_format );
 432         }
 433         else if ( mlt_properties_get_data( properties, "audio", NULL ) )
 434         {
 435                 *buffer = mlt_properties_get_data( properties, "audio", NULL );
 436                 *format = mlt_properties_get_int( properties, "audio_format" );
 437                 *frequency = mlt_properties_get_int( properties, "audio_frequency" );
 438                 *channels = mlt_properties_get_int( properties, "audio_channels" );
 439                 *samples = mlt_properties_get_int( properties, "audio_samples" );
 440                 if ( this->convert_audio )
 441                         this->convert_audio( this, buffer, format, requested_format );
 442         }
 443         else
 444         {
 445                 int size = 0;
 446                 *samples = *samples <= 0 ? 1920 : *samples;
 447                 *channels = *channels <= 0 ? 2 : *channels;
 448                 *frequency = *frequency <= 0 ? 48000 : *frequency;
 449                 mlt_properties_set_int( properties, "audio_frequency", *frequency );
 450                 mlt_properties_set_int( properties, "audio_channels", *channels );
 451                 mlt_properties_set_int( properties, "audio_samples", *samples );
 452                 mlt_properties_set_int( properties, "audio_format", *format );
 453
 454                 switch( *format )
 455                 {
 456                         case mlt_image_none:
 457                                 size = 0;
 458                                 *buffer = NULL;
 459                                 break;
 460                         case mlt_audio_s16:
 461                                 size = *samples * *channels * sizeof( int16_t );
 462                                 break;
 463                         case mlt_audio_s32:
 464                                 size = *samples * *channels * sizeof( int32_t );
 465                                 break;
 466                         case mlt_audio_float:
 467                                 size = *samples * *channels * sizeof( float );
 468                                 break;
 469                 }
 470                 if ( size )
 471                         *buffer = mlt_pool_alloc( size );
 472                 if ( *buffer )
 473                         memset( *buffer, 0, size );
 474                 mlt_properties_set_data( properties, "audio", *buffer, size, ( mlt_destructor )mlt_pool_release, NULL );
 475                 mlt_properties_set_int( properties, "test_audio", 1 );
 476         }
 477
 478         // TODO: This does not belong here
 479         if ( *format == mlt_audio_s16 && mlt_properties_get( properties, "meta.volume" ) )
 480         {
 481                 double value = mlt_properties_get_double( properties, "meta.volume" );
 482
 483                 if ( value == 0.0 )
 484                 {
 485                         memset( *buffer, 0, *samples * *channels * 2 );
 486                 }
 487                 else if ( value != 1.0 )
 488                 {
 489                         int total = *samples * *channels;
 490                         int16_t *p = *buffer;
 491                         while ( total -- )
 492                         {
 493                                 *p = *p * value;
 494                                 p ++;
 495                         }
 496                 }
 497
 498                 mlt_properties_set( properties, "meta.volume", NULL );
 499         }
 500
 501         return 0;
 502 }
 503
 504 int mlt_frame_set_audio( mlt_frame this, void *buffer, mlt_audio_format format, int size, mlt_destructor destructor )
 505 {
 506         mlt_properties_set_int( MLT_FRAME_PROPERTIES( this ), "audio_format", format );
 507         return mlt_properties_set_data( MLT_FRAME_PROPERTIES( this ), "audio", buffer, size, destructor, NULL );
 508 }
 509
 510 unsigned char *mlt_frame_get_waveform( mlt_frame this, int w, int h )
 511 {
 512         int16_t *pcm = NULL;
 513         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 514         mlt_audio_format format = mlt_audio_s16;
 515         int frequency = 32000; // lower frequency available?
 516         int channels = 2;
 517         double fps = mlt_profile_fps( NULL );
 518         int samples = mlt_sample_calculator( fps, frequency, mlt_frame_get_position( this ) );
 519
 520         // Get the pcm data
 521         mlt_frame_get_audio( this, (void**)&pcm, &format, &frequency, &channels, &samples );
 522
 523         // Make an 8-bit buffer large enough to hold rendering
 524         int size = w * h;
 525         unsigned char *bitmap = ( unsigned char* )mlt_pool_alloc( size );
 526         if ( bitmap != NULL )
 527                 memset( bitmap, 0, size );
 528         mlt_properties_set_data( properties, "waveform", bitmap, size, ( mlt_destructor )mlt_pool_release, NULL );
 529
 530         // Render vertical lines
 531         int16_t *ubound = pcm + samples * channels;
 532         int skip = samples / w - 1;
 533         int i, j, k;
 534
 535         // Iterate sample stream and along x coordinate
 536         for ( i = 0; i < w && pcm < ubound; i++ )
 537         {
 538                 // pcm data has channels interleaved
 539                 for ( j = 0; j < channels; j++ )
 540                 {
 541                         // Determine sample's magnitude from 2s complement;
 542                         int pcm_magnitude = *pcm < 0 ? ~(*pcm) + 1 : *pcm;
 543                         // The height of a line is the ratio of the magnitude multiplied by
 544                         // half the vertical resolution
 545                         int height = ( int )( ( double )( pcm_magnitude ) / 32768 * h / 2 );
 546                         // Determine the starting y coordinate - left channel above center,
 547                         // right channel below - currently assumes 2 channels
 548                         int displacement = ( h / 2 ) - ( 1 - j ) * height;
 549                         // Position buffer pointer using y coordinate, stride, and x coordinate
 550                         unsigned char *p = &bitmap[ i + displacement * w ];
 551
 552                         // Draw vertical line
 553                         for ( k = 0; k < height; k++ )
 554                                 p[ w * k ] = 0xFF;
 555
 556                         pcm++;
 557                 }
 558                 pcm += skip * channels;
 559         }
 560
 561         return bitmap;
 562 }
 563
 564 mlt_producer mlt_frame_get_original_producer( mlt_frame this )
 565 {
 566         if ( this != NULL )
 567                 return mlt_properties_get_data( MLT_FRAME_PROPERTIES( this ), "_producer", NULL );
 568         return NULL;
 569 }
 570
 571 void mlt_frame_close( mlt_frame this )
 572 {
 573         if ( this != NULL && mlt_properties_dec_ref( MLT_FRAME_PROPERTIES( this ) ) <= 0 )
 574         {
 575                 mlt_deque_close( this->stack_image );
 576                 mlt_deque_close( this->stack_audio );
 577                 while( mlt_deque_peek_back( this->stack_service ) )
 578                         mlt_service_close( mlt_deque_pop_back( this->stack_service ) );
 579                 mlt_deque_close( this->stack_service );
 580                 mlt_properties_close( &this->parent );
 581                 free( this );
 582         }
 583 }
 584
 585 /***** convenience functions *****/
 586
 587 /* Will this break when mlt_position is converted to double? -Zach */
 588 int mlt_sample_calculator( float fps, int frequency, int64_t position )
 589 {
 590         int samples = 0;
 591
 592         if ( ( int )( fps * 100 ) == 2997 )
 593         {
 594                 samples = frequency / 30;
 595
 596                 switch ( frequency )
 597                 {
 598                         case 48000:
 599                                 if ( position % 5 != 0 )
 600                                         samples += 2;
 601                                 break;
 602                         case 44100:
 603                                 if ( position % 300 == 0 )
 604                                         samples = 1471;
 605                                 else if ( position % 30 == 0 )
 606                                         samples = 1470;
 607                                 else if ( position % 2 == 0 )
 608                                         samples = 1472;
 609                                 else
 610                                         samples = 1471;
 611                                 break;
 612                         case 32000:
 613                                 if ( position % 30 == 0 )
 614                                         samples = 1068;
 615                                 else if ( position % 29 == 0 )
 616                                         samples = 1067;
 617                                 else if ( position % 4 == 2 )
 618                                         samples = 1067;
 619                                 else
 620                                         samples = 1068;
 621                                 break;
 622                         default:
 623                                 samples = 0;
 624                 }
 625         }
 626         else if ( fps != 0 )
 627         {
 628                 samples = frequency / fps;
 629         }
 630
 631         return samples;
 632 }
 633
 634 int64_t mlt_sample_calculator_to_now( float fps, int frequency, int64_t frame )
 635 {
 636         int64_t samples = 0;
 637
 638         // TODO: Correct rules for NTSC and drop the * 100 hack
 639         if ( ( int )( fps * 100 ) == 2997 )
 640         {
 641                 samples = ( ( double )( frame * frequency ) / 30 );
 642                 switch( frequency )
 643                 {
 644                         case 48000:
 645                                 samples += 2 * ( frame / 5 );
 646                                 break;
 647                         case 44100:
 648                                 samples += frame + ( frame / 2 ) - ( frame / 30 ) + ( frame / 300 );
 649                                 break;
 650                         case 32000:
 651                                 samples += ( 2 * frame ) - ( frame / 4 ) - ( frame / 29 );
 652                                 break;
 653                 }
 654         }
 655         else if ( fps != 0 )
 656         {
 657                 samples = ( ( frame * frequency ) / ( int )fps );
 658         }
 659
 660         return samples;
 661 }