git.sesse.net Git - mlt/blob - src/modules/dv/producer_libdv.c

   1 /*
   2  * producer_libdv.c -- simple libdv test case
   3  * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
   4  * Author: Charles Yates <charles.yates@pandora.be>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <framework/mlt_producer.h>
  22 #include <framework/mlt_frame.h>
  23 #include <framework/mlt_deque.h>
  24 #include <framework/mlt_factory.h>
  25 #include <framework/mlt_profile.h>
  26
  27 #include <pthread.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <libdv/dv.h>
  32 #include <unistd.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36
  37 #define FRAME_SIZE_525_60       10 * 150 * 80
  38 #define FRAME_SIZE_625_50       12 * 150 * 80
  39
  40 /** To conserve resources, we maintain a stack of dv decoders.
  41 */
  42
  43 static pthread_mutex_t decoder_lock = PTHREAD_MUTEX_INITIALIZER;
  44 static mlt_properties dv_decoders = NULL;
  45
  46 dv_decoder_t *dv_decoder_alloc( )
  47 {
  48         // We'll return a dv_decoder
  49         dv_decoder_t *this = NULL;
  50
  51         // Lock the mutex
  52         pthread_mutex_lock( &decoder_lock );
  53
  54         // Create the properties if necessary
  55         if ( dv_decoders == NULL )
  56         {
  57                 // Create the properties
  58                 dv_decoders = mlt_properties_new( );
  59
  60                 // Create the stack
  61                 mlt_properties_set_data( dv_decoders, "stack", mlt_deque_init( ), 0, ( mlt_destructor )mlt_deque_close, NULL );
  62
  63                 // Register the properties for clean up
  64                 mlt_factory_register_for_clean_up( dv_decoders, ( mlt_destructor )mlt_properties_close );
  65         }
  66
  67         // Now try to obtain a decoder
  68         if ( dv_decoders != NULL )
  69         {
  70                 // Obtain the stack
  71                 mlt_deque stack = mlt_properties_get_data( dv_decoders, "stack", NULL );
  72
  73                 // Pop the top of the stack
  74                 this = mlt_deque_pop_back( stack );
  75
  76                 // Create a new decoder if none available
  77                 if ( this == NULL )
  78                 {
  79                         // We'll need a unique property ID for this
  80                         char label[ 256 ];
  81
  82                         // Configure the decoder
  83                         this = dv_decoder_new( FALSE, FALSE, FALSE );
  84                         this->quality = DV_QUALITY_COLOR | DV_QUALITY_AC_2;
  85                         this->audio->arg_audio_emphasis = 2;
  86                         dv_set_audio_correction( this, DV_AUDIO_CORRECT_AVERAGE );
  87                         dv_set_error_log( this, NULL );
  88
  89                         // Register it with the properties to ensure clean up
  90                         sprintf( label, "%p", this );
  91                         mlt_properties_set_data( dv_decoders, label, this, 0, ( mlt_destructor )dv_decoder_free, NULL );
  92                 }
  93         }
  94
  95         // Unlock the mutex
  96         pthread_mutex_unlock( &decoder_lock );
  97
  98         return this;
  99 }
 100
 101 void dv_decoder_return( dv_decoder_t *this )
 102 {
 103         // Lock the mutex
 104         pthread_mutex_lock( &decoder_lock );
 105
 106         // Now try to return the decoder
 107         if ( dv_decoders != NULL )
 108         {
 109                 // Obtain the stack
 110                 mlt_deque stack = mlt_properties_get_data( dv_decoders, "stack", NULL );
 111
 112                 // Push it back
 113                 mlt_deque_push_back( stack, this );
 114         }
 115
 116         // Unlock the mutex
 117         pthread_mutex_unlock( &decoder_lock );
 118 }
 119
 120
 121 typedef struct producer_libdv_s *producer_libdv;
 122
 123 struct producer_libdv_s
 124 {
 125         struct mlt_producer_s parent;
 126         int fd;
 127         int is_pal;
 128         uint64_t file_size;
 129         int frame_size;
 130         long frames_in_file;
 131         mlt_producer alternative;
 132 };
 133
 134 static int producer_get_frame( mlt_producer parent, mlt_frame_ptr frame, int index );
 135 static void producer_close( mlt_producer parent );
 136
 137 static int producer_collect_info( producer_libdv this, mlt_profile profile );
 138
 139 mlt_producer producer_libdv_init( mlt_profile profile, mlt_service_type type, const char *id, char *filename )
 140 {
 141         producer_libdv this = calloc( sizeof( struct producer_libdv_s ), 1 );
 142
 143         if ( filename != NULL && this != NULL && mlt_producer_init( &this->parent, this ) == 0 )
 144         {
 145                 int destroy = 0;
 146                 mlt_producer producer = &this->parent;
 147                 mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
 148
 149                 // Set the resource property (required for all producers)
 150                 mlt_properties_set( properties, "resource", filename );
 151
 152                 // Register transport implementation with the producer
 153                 producer->close = ( mlt_destructor )producer_close;
 154
 155                 // Register our get_frame implementation with the producer
 156                 producer->get_frame = producer_get_frame;
 157
 158                 // If we have mov or dv, then we'll use an alternative producer
 159                 if ( strchr( filename, '.' ) != NULL && (
 160                          strncasecmp( strrchr( filename, '.' ), ".avi", 4 ) == 0 ||
 161                          strncasecmp( strrchr( filename, '.' ), ".mov", 4 ) == 0 ) )
 162                 {
 163                         // Load via an alternative mechanism
 164                         mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
 165                         this->alternative = mlt_factory_producer( profile, "kino", filename );
 166
 167                         // If it's unavailable, then clean up
 168                         if ( this->alternative == NULL )
 169                                 destroy = 1;
 170                         else
 171                                 mlt_properties_pass( properties, MLT_PRODUCER_PROPERTIES( this->alternative ), "" );
 172                         this->is_pal = ( ( int ) mlt_producer_get_fps( producer ) ) == 25;
 173                 }
 174                 else
 175                 {
 176                         // Open the file if specified
 177                         this->fd = open( filename, O_RDONLY );
 178
 179                         // Collect info
 180                         if ( this->fd == -1 || !producer_collect_info( this, profile ) )
 181                                 destroy = 1;
 182                 }
 183
 184                 // If we couldn't open the file, then destroy it now
 185                 if ( destroy )
 186                 {
 187                         mlt_producer_close( producer );
 188                         producer = NULL;
 189                 }
 190
 191                 // Return the producer
 192                 return producer;
 193         }
 194         free( this );
 195         return NULL;
 196 }
 197
 198 static int read_frame( int fd, uint8_t* frame_buf, int *isPAL )
 199 {
 200         int result = read( fd, frame_buf, FRAME_SIZE_525_60 ) == FRAME_SIZE_525_60;
 201         if ( result )
 202         {
 203                 *isPAL = ( frame_buf[3] & 0x80 );
 204                 if ( *isPAL )
 205                 {
 206                         int diff = FRAME_SIZE_625_50 - FRAME_SIZE_525_60;
 207                         result = read( fd, frame_buf + FRAME_SIZE_525_60, diff ) == diff;
 208                 }
 209         }
 210
 211         return result;
 212 }
 213
 214 static int producer_collect_info( producer_libdv this, mlt_profile profile )
 215 {
 216         int valid = 0;
 217
 218         uint8_t *dv_data = mlt_pool_alloc( FRAME_SIZE_625_50 );
 219
 220         if ( dv_data != NULL )
 221         {
 222                 // Read the first frame
 223                 valid = read_frame( this->fd, dv_data, &this->is_pal );
 224
 225                 // If it looks like a valid frame, the get stats
 226                 if ( valid )
 227                 {
 228                         double aspect_ratio;
 229
 230                         // Get the properties
 231                         mlt_properties properties = MLT_PRODUCER_PROPERTIES( &this->parent );
 232
 233                         // Get a dv_decoder
 234                         dv_decoder_t *dv_decoder = dv_decoder_alloc( );
 235
 236                         // Determine the file size
 237                         struct stat buf;
 238                         fstat( this->fd, &buf );
 239
 240                         // Store the file size
 241                         this->file_size = buf.st_size;
 242
 243                         // Determine the frame size
 244                         this->frame_size = this->is_pal ? FRAME_SIZE_625_50 : FRAME_SIZE_525_60;
 245
 246                         // Determine the number of frames in the file
 247                         this->frames_in_file = this->file_size / this->frame_size;
 248
 249                         // Calculate default in/out points
 250                         int fps = 1000 * ( this->is_pal ? 25 : ( 30000.0 / 1001.0 ) );
 251                         if ( ( int )( mlt_profile_fps( profile ) * 1000 ) == fps )
 252                         {
 253                                 if ( this->frames_in_file > 0 )
 254                                 {
 255                                         mlt_properties_set_position( properties, "length", this->frames_in_file );
 256                                         mlt_properties_set_position( properties, "in", 0 );
 257                                         mlt_properties_set_position( properties, "out", this->frames_in_file - 1 );
 258                                 }
 259                         }
 260                         else
 261                         {
 262                                 valid = 0;
 263                         }
 264
 265                         // Parse the header for meta info
 266                         dv_parse_header( dv_decoder, dv_data );
 267                         if ( this->is_pal )
 268                         {
 269                                 if ( dv_format_wide( dv_decoder ) )
 270                                         aspect_ratio = 64.0 / 45.0;
 271                                 else
 272                                         aspect_ratio = 16.0 / 15.0;
 273                         }
 274                         else
 275                         {
 276                                 if ( dv_format_wide( dv_decoder ) )
 277                                         aspect_ratio = 32.0 / 27.0;
 278                                 else
 279                                         aspect_ratio = 8 / 9;
 280                         }
 281                         mlt_properties_set_double( properties, "aspect_ratio", aspect_ratio);
 282                         mlt_properties_set_double( properties, "source_fps", this->is_pal ? 25 : ( 30000.0 / 1001.0 ) );
 283                         mlt_properties_set_int( properties, "meta.media.nb_streams", 2 );
 284                         mlt_properties_set_int( properties, "video_index", 0 );
 285                         mlt_properties_set( properties, "meta.media.0.stream.type", "video" );
 286                         mlt_properties_set( properties, "meta.media.0.codec.name", "dvvideo" );
 287                         mlt_properties_set( properties, "meta.media.0.codec.long_name", "DV (Digital Video)" );
 288                         mlt_properties_set_int( properties, "audio_index", 1 );
 289                         mlt_properties_set( properties, "meta.media.1.stream.type", "audio" );
 290                         mlt_properties_set( properties, "meta.media.1.codec.name", "pcm_s16le" );
 291                         mlt_properties_set( properties, "meta.media.1.codec.long_name", "signed 16-bit little-endian PCM" );
 292
 293                         // Return the decoder
 294                         dv_decoder_return( dv_decoder );
 295                 }
 296
 297                 mlt_pool_release( dv_data );
 298         }
 299
 300         return valid;
 301 }
 302
 303 static int producer_get_image( mlt_frame this, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
 304 {
 305         int pitches[3] = { 0, 0, 0 };
 306         uint8_t *pixels[3] = { NULL, NULL, NULL };
 307
 308         // Get the frames properties
 309         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 310
 311         // Get a dv_decoder
 312         dv_decoder_t *decoder = dv_decoder_alloc( );
 313
 314         // Get the dv data
 315         uint8_t *dv_data = mlt_properties_get_data( properties, "dv_data", NULL );
 316
 317         // Get and set the quality request
 318         char *quality = mlt_frame_pop_service( this );
 319
 320         if ( quality != NULL )
 321         {
 322                 if ( strncmp( quality, "fast", 4 ) == 0 )
 323                         decoder->quality = ( DV_QUALITY_COLOR | DV_QUALITY_DC );
 324                 else if ( strncmp( quality, "best", 4 ) == 0 )
 325                         decoder->quality = ( DV_QUALITY_COLOR | DV_QUALITY_AC_2 );
 326                 else
 327                         decoder->quality = ( DV_QUALITY_COLOR | DV_QUALITY_AC_1 );
 328         }
 329
 330         // Parse the header for meta info
 331         dv_parse_header( decoder, dv_data );
 332
 333         // Assign width and height according to the frame
 334         *width = 720;
 335         *height = dv_data[ 3 ] & 0x80 ? 576 : 480;
 336
 337         // Extract an image of the format requested
 338         if ( *format == mlt_image_yuv422 || *format == mlt_image_yuv420p )
 339         {
 340                 // Allocate an image
 341                 uint8_t *image = mlt_pool_alloc( *width * ( *height + 1 ) * 2 );
 342
 343                 // Pass to properties for clean up
 344                 mlt_frame_set_image( this, image, *width * ( *height + 1 ) * 2, mlt_pool_release );
 345
 346                 // Decode the image
 347                 pitches[ 0 ] = *width * 2;
 348                 pixels[ 0 ] = image;
 349                 dv_decode_full_frame( decoder, dv_data, e_dv_color_yuv, pixels, pitches );
 350
 351                 // Assign result
 352                 *buffer = image;
 353                 *format = mlt_image_yuv422;
 354         }
 355         else
 356         {
 357                 // Allocate an image
 358                 uint8_t *image = mlt_pool_alloc( *width * ( *height + 1 ) * 3 );
 359
 360                 // Pass to properties for clean up
 361                 mlt_frame_set_image( this, image, *width * ( *height + 1 ) * 3, mlt_pool_release );
 362
 363                 // Decode the frame
 364                 pitches[ 0 ] = 720 * 3;
 365                 pixels[ 0 ] = image;
 366                 dv_decode_full_frame( decoder, dv_data, e_dv_color_rgb, pixels, pitches );
 367
 368                 // Assign result
 369                 *buffer = image;
 370                 *format = mlt_image_rgb24;
 371         }
 372
 373         // Return the decoder
 374         dv_decoder_return( decoder );
 375
 376         return 0;
 377 }
 378
 379 static int producer_get_audio( mlt_frame this, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
 380 {
 381         int16_t *p;
 382         int i, j;
 383         int16_t *audio_channels[ 4 ];
 384
 385         // Get the frames properties
 386         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 387
 388         // Get a dv_decoder
 389         dv_decoder_t *decoder = dv_decoder_alloc( );
 390
 391         // Get the dv data
 392         uint8_t *dv_data = mlt_properties_get_data( properties, "dv_data", NULL );
 393
 394         // Parse the header for meta info
 395         dv_parse_header( decoder, dv_data );
 396
 397         // Check that we have audio
 398         if ( decoder->audio->num_channels > 0 )
 399         {
 400                 int size = *channels * DV_AUDIO_MAX_SAMPLES * sizeof( int16_t );
 401
 402                 // Obtain required values
 403                 *frequency = decoder->audio->frequency;
 404                 *samples = decoder->audio->samples_this_frame;
 405                 *channels = decoder->audio->num_channels;
 406                 *format = mlt_audio_s16;
 407
 408                 // Create a temporary workspace
 409                 for ( i = 0; i < 4; i++ )
 410                         audio_channels[ i ] = mlt_pool_alloc( DV_AUDIO_MAX_SAMPLES * sizeof( int16_t ) );
 411
 412                 // Create a workspace for the result
 413                 *buffer = mlt_pool_alloc( size );
 414
 415                 // Pass the allocated audio buffer as a property
 416                 mlt_frame_set_audio( this, *buffer, *format, size, mlt_pool_release );
 417
 418                 // Decode the audio
 419                 dv_decode_full_audio( decoder, dv_data, audio_channels );
 420
 421                 // Interleave the audio
 422                 p = *buffer;
 423                 for ( i = 0; i < *samples; i++ )
 424                         for ( j = 0; j < *channels; j++ )
 425                                 *p++ = audio_channels[ j ][ i ];
 426
 427                 // Free the temporary work space
 428                 for ( i = 0; i < 4; i++ )
 429                         mlt_pool_release( audio_channels[ i ] );
 430         }
 431         else
 432         {
 433                 // No audio available on the frame, so get test audio (silence)
 434                 mlt_frame_get_audio( this, buffer, format, frequency, channels, samples );
 435         }
 436
 437         // Return the decoder
 438         dv_decoder_return( decoder );
 439
 440         return 0;
 441 }
 442
 443 static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
 444 {
 445         // Access the private data
 446         producer_libdv this = producer->child;
 447
 448         // Will carry the frame data
 449         uint8_t *data = NULL;
 450
 451         // Obtain the current frame number
 452         uint64_t position = mlt_producer_frame( producer );
 453
 454         if ( this->alternative == NULL )
 455         {
 456                 // Convert timecode to a file position (ensuring that we're on a frame boundary)
 457                 uint64_t offset = position * this->frame_size;
 458
 459                 // Allocate space
 460                 data = mlt_pool_alloc( FRAME_SIZE_625_50 );
 461
 462                 // Create an empty frame
 463                 *frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
 464
 465                 // Seek and fetch
 466                 if ( this->fd != 0 &&
 467                          lseek( this->fd, offset, SEEK_SET ) == offset &&
 468                          read_frame( this->fd, data, &this->is_pal ) )
 469                 {
 470                         // Pass the dv data
 471                         mlt_properties_set_data( MLT_FRAME_PROPERTIES( *frame ), "dv_data", data, FRAME_SIZE_625_50, ( mlt_destructor )mlt_pool_release, NULL );
 472                 }
 473                 else
 474                 {
 475                         mlt_pool_release( data );
 476                         data = NULL;
 477                 }
 478         }
 479         else
 480         {
 481                 // Seek
 482                 mlt_producer_seek( this->alternative, position );
 483
 484                 // Fetch
 485                 mlt_service_get_frame( MLT_PRODUCER_SERVICE( this->alternative ), frame, 0 );
 486
 487                 // Verify
 488                 if ( *frame != NULL )
 489                         data = mlt_properties_get_data( MLT_FRAME_PROPERTIES( *frame ), "dv_data", NULL );
 490         }
 491
 492         if ( data != NULL )
 493         {
 494                 // Get the frames properties
 495                 mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
 496
 497                 // Get a dv_decoder
 498                 dv_decoder_t *dv_decoder = dv_decoder_alloc( );
 499
 500                 mlt_properties_set_int( properties, "test_image", 0 );
 501                 mlt_properties_set_int( properties, "test_audio", 0 );
 502
 503                 // Update other info on the frame
 504                 mlt_properties_set_int( properties, "width", 720 );
 505                 mlt_properties_set_int( properties, "height", this->is_pal ? 576 : 480 );
 506                 mlt_properties_set_int( properties, "real_width", 720 );
 507                 mlt_properties_set_int( properties, "real_height", this->is_pal ? 576 : 480 );
 508                 mlt_properties_set_int( properties, "top_field_first", !this->is_pal ? 0 : ( data[ 5 ] & 0x07 ) == 0 ? 0 : 1 );
 509                 mlt_properties_set_int( properties, "colorspace", 601 );
 510
 511                 // Parse the header for meta info
 512                 dv_parse_header( dv_decoder, data );
 513                 //mlt_properties_set_int( properties, "progressive", dv_is_progressive( dv_decoder ) );
 514                 mlt_properties_set_double( properties, "aspect_ratio",
 515                                 dv_format_wide( dv_decoder ) ? ( this->is_pal ? 118.0/81.0 : 40.0/33.0 ) : ( this->is_pal ? 59.0/54.0 : 10.0/11.0 ) );
 516
 517
 518                 mlt_properties_set_int( properties, "audio_frequency", dv_decoder->audio->frequency );
 519                 mlt_properties_set_int( properties, "audio_channels", dv_decoder->audio->num_channels );
 520
 521                 // Register audio callback
 522                 if ( mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( producer ), "audio_index" ) > 0 )
 523                         mlt_frame_push_audio( *frame, producer_get_audio );
 524
 525                 if ( mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( producer ), "video_index" ) > -1 )
 526                 {
 527                         // Push the quality string
 528                         mlt_frame_push_service( *frame, mlt_properties_get( MLT_PRODUCER_PROPERTIES( producer ), "quality" ) );
 529
 530                         // Push the get_image method on to the stack
 531                         mlt_frame_push_get_image( *frame, producer_get_image );
 532                 }
 533
 534                 // Return the decoder
 535                 dv_decoder_return( dv_decoder );
 536         }
 537
 538         // Update timecode on the frame we're creating
 539         mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
 540
 541         // Calculate the next timecode
 542         mlt_producer_prepare_next( producer );
 543
 544         return 0;
 545 }
 546
 547 static void producer_close( mlt_producer parent )
 548 {
 549         // Obtain this
 550         producer_libdv this = parent->child;
 551
 552         // Close the file
 553         if ( this->fd > 0 )
 554                 close( this->fd );
 555
 556         if ( this->alternative )
 557                 mlt_producer_close( this->alternative );
 558
 559         // Close the parent
 560         parent->close = NULL;
 561         mlt_producer_close( parent );
 562
 563         // Free the memory
 564         free( this );
 565 }