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                         // Get the properties
 229                         mlt_properties properties = MLT_PRODUCER_PROPERTIES( &this->parent );
 230
 231                         // Get a dv_decoder
 232                         dv_decoder_t *dv_decoder = dv_decoder_alloc( );
 233
 234                         // Determine the file size
 235                         struct stat buf;
 236                         fstat( this->fd, &buf );
 237
 238                         // Store the file size
 239                         this->file_size = buf.st_size;
 240
 241                         // Determine the frame size
 242                         this->frame_size = this->is_pal ? FRAME_SIZE_625_50 : FRAME_SIZE_525_60;
 243
 244                         // Determine the number of frames in the file
 245                         this->frames_in_file = this->file_size / this->frame_size;
 246
 247                         // Calculate default in/out points
 248                         int fps = 1000 * ( this->is_pal ? 25 : ( 30000.0 / 1001.0 ) );
 249                         if ( ( int )( mlt_profile_fps( profile ) * 1000 ) == fps )
 250                         {
 251                                 if ( this->frames_in_file > 0 )
 252                                 {
 253                                         mlt_properties_set_position( properties, "length", this->frames_in_file );
 254                                         mlt_properties_set_position( properties, "in", 0 );
 255                                         mlt_properties_set_position( properties, "out", this->frames_in_file - 1 );
 256                                 }
 257                         }
 258                         else
 259                         {
 260                                 valid = 0;
 261                         }
 262
 263                         // Parse the header for meta info
 264                         dv_parse_header( dv_decoder, dv_data );
 265                         mlt_properties_set_double( properties, "aspect_ratio",
 266                                 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 ) );
 267                         mlt_properties_set_double( properties, "source_fps", this->is_pal ? 25 : ( 30000.0 / 1001.0 ) );
 268                         mlt_properties_set_int( properties, "meta.media.nb_streams", 2 );
 269                         mlt_properties_set_int( properties, "video_index", 0 );
 270                         mlt_properties_set( properties, "meta.media.0.stream.type", "video" );
 271                         mlt_properties_set( properties, "meta.media.0.codec.name", "dvvideo" );
 272                         mlt_properties_set( properties, "meta.media.0.codec.long_name", "DV (Digital Video)" );
 273                         mlt_properties_set_int( properties, "audio_index", 1 );
 274                         mlt_properties_set( properties, "meta.media.1.stream.type", "audio" );
 275                         mlt_properties_set( properties, "meta.media.1.codec.name", "pcm_s16le" );
 276                         mlt_properties_set( properties, "meta.media.1.codec.long_name", "signed 16-bit little-endian PCM" );
 277
 278                         // Return the decoder
 279                         dv_decoder_return( dv_decoder );
 280                 }
 281
 282                 mlt_pool_release( dv_data );
 283         }
 284
 285         return valid;
 286 }
 287
 288 static int producer_get_image( mlt_frame this, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
 289 {
 290         int pitches[3] = { 0, 0, 0 };
 291         uint8_t *pixels[3] = { NULL, NULL, NULL };
 292
 293         // Get the frames properties
 294         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 295
 296         // Get a dv_decoder
 297         dv_decoder_t *decoder = dv_decoder_alloc( );
 298
 299         // Get the dv data
 300         uint8_t *dv_data = mlt_properties_get_data( properties, "dv_data", NULL );
 301
 302         // Get and set the quality request
 303         char *quality = mlt_frame_pop_service( this );
 304
 305         if ( quality != NULL )
 306         {
 307                 if ( strncmp( quality, "fast", 4 ) == 0 )
 308                         decoder->quality = ( DV_QUALITY_COLOR | DV_QUALITY_DC );
 309                 else if ( strncmp( quality, "best", 4 ) == 0 )
 310                         decoder->quality = ( DV_QUALITY_COLOR | DV_QUALITY_AC_2 );
 311                 else
 312                         decoder->quality = ( DV_QUALITY_COLOR | DV_QUALITY_AC_1 );
 313         }
 314
 315         // Parse the header for meta info
 316         dv_parse_header( decoder, dv_data );
 317
 318         // Assign width and height according to the frame
 319         *width = 720;
 320         *height = dv_data[ 3 ] & 0x80 ? 576 : 480;
 321
 322         // Extract an image of the format requested
 323         if ( *format == mlt_image_yuv422 || *format == mlt_image_yuv420p )
 324         {
 325                 // Allocate an image
 326                 uint8_t *image = mlt_pool_alloc( *width * ( *height + 1 ) * 2 );
 327
 328                 // Pass to properties for clean up
 329                 mlt_frame_set_image( this, image, *width * ( *height + 1 ) * 2, mlt_pool_release );
 330
 331                 // Decode the image
 332                 pitches[ 0 ] = *width * 2;
 333                 pixels[ 0 ] = image;
 334                 dv_decode_full_frame( decoder, dv_data, e_dv_color_yuv, pixels, pitches );
 335
 336                 // Assign result
 337                 *buffer = image;
 338                 *format = mlt_image_yuv422;
 339         }
 340         else
 341         {
 342                 // Allocate an image
 343                 uint8_t *image = mlt_pool_alloc( *width * ( *height + 1 ) * 3 );
 344
 345                 // Pass to properties for clean up
 346                 mlt_frame_set_image( this, image, *width * ( *height + 1 ) * 3, mlt_pool_release );
 347
 348                 // Decode the frame
 349                 pitches[ 0 ] = 720 * 3;
 350                 pixels[ 0 ] = image;
 351                 dv_decode_full_frame( decoder, dv_data, e_dv_color_rgb, pixels, pitches );
 352
 353                 // Assign result
 354                 *buffer = image;
 355                 *format = mlt_image_rgb24;
 356         }
 357
 358         // Return the decoder
 359         dv_decoder_return( decoder );
 360
 361         return 0;
 362 }
 363
 364 static int producer_get_audio( mlt_frame this, void **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
 365 {
 366         int16_t *p;
 367         int i, j;
 368         int16_t *audio_channels[ 4 ];
 369
 370         // Get the frames properties
 371         mlt_properties properties = MLT_FRAME_PROPERTIES( this );
 372
 373         // Get a dv_decoder
 374         dv_decoder_t *decoder = dv_decoder_alloc( );
 375
 376         // Get the dv data
 377         uint8_t *dv_data = mlt_properties_get_data( properties, "dv_data", NULL );
 378
 379         // Parse the header for meta info
 380         dv_parse_header( decoder, dv_data );
 381
 382         // Check that we have audio
 383         if ( decoder->audio->num_channels > 0 )
 384         {
 385                 int size = *channels * DV_AUDIO_MAX_SAMPLES * sizeof( int16_t );
 386
 387                 // Obtain required values
 388                 *frequency = decoder->audio->frequency;
 389                 *samples = decoder->audio->samples_this_frame;
 390                 *channels = decoder->audio->num_channels;
 391                 *format = mlt_audio_s16;
 392
 393                 // Create a temporary workspace
 394                 for ( i = 0; i < 4; i++ )
 395                         audio_channels[ i ] = mlt_pool_alloc( DV_AUDIO_MAX_SAMPLES * sizeof( int16_t ) );
 396
 397                 // Create a workspace for the result
 398                 *buffer = mlt_pool_alloc( size );
 399
 400                 // Pass the allocated audio buffer as a property
 401                 mlt_frame_set_audio( this, *buffer, *format, size, mlt_pool_release );
 402
 403                 // Decode the audio
 404                 dv_decode_full_audio( decoder, dv_data, audio_channels );
 405
 406                 // Interleave the audio
 407                 p = *buffer;
 408                 for ( i = 0; i < *samples; i++ )
 409                         for ( j = 0; j < *channels; j++ )
 410                                 *p++ = audio_channels[ j ][ i ];
 411
 412                 // Free the temporary work space
 413                 for ( i = 0; i < 4; i++ )
 414                         mlt_pool_release( audio_channels[ i ] );
 415         }
 416         else
 417         {
 418                 // No audio available on the frame, so get test audio (silence)
 419                 mlt_frame_get_audio( this, buffer, format, frequency, channels, samples );
 420         }
 421
 422         // Return the decoder
 423         dv_decoder_return( decoder );
 424
 425         return 0;
 426 }
 427
 428 static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
 429 {
 430         // Access the private data
 431         producer_libdv this = producer->child;
 432
 433         // Will carry the frame data
 434         uint8_t *data = NULL;
 435
 436         // Obtain the current frame number
 437         uint64_t position = mlt_producer_frame( producer );
 438
 439         if ( this->alternative == NULL )
 440         {
 441                 // Convert timecode to a file position (ensuring that we're on a frame boundary)
 442                 uint64_t offset = position * this->frame_size;
 443
 444                 // Allocate space
 445                 data = mlt_pool_alloc( FRAME_SIZE_625_50 );
 446
 447                 // Create an empty frame
 448                 *frame = mlt_frame_init( MLT_PRODUCER_SERVICE( producer ) );
 449
 450                 // Seek and fetch
 451                 if ( this->fd != 0 &&
 452                          lseek( this->fd, offset, SEEK_SET ) == offset &&
 453                          read_frame( this->fd, data, &this->is_pal ) )
 454                 {
 455                         // Pass the dv data
 456                         mlt_properties_set_data( MLT_FRAME_PROPERTIES( *frame ), "dv_data", data, FRAME_SIZE_625_50, ( mlt_destructor )mlt_pool_release, NULL );
 457                 }
 458                 else
 459                 {
 460                         mlt_pool_release( data );
 461                         data = NULL;
 462                 }
 463         }
 464         else
 465         {
 466                 // Seek
 467                 mlt_producer_seek( this->alternative, position );
 468
 469                 // Fetch
 470                 mlt_service_get_frame( MLT_PRODUCER_SERVICE( this->alternative ), frame, 0 );
 471
 472                 // Verify
 473                 if ( *frame != NULL )
 474                         data = mlt_properties_get_data( MLT_FRAME_PROPERTIES( *frame ), "dv_data", NULL );
 475         }
 476
 477         if ( data != NULL )
 478         {
 479                 // Get the frames properties
 480                 mlt_properties properties = MLT_FRAME_PROPERTIES( *frame );
 481
 482                 // Get a dv_decoder
 483                 dv_decoder_t *dv_decoder = dv_decoder_alloc( );
 484
 485                 mlt_properties_set_int( properties, "test_image", 0 );
 486                 mlt_properties_set_int( properties, "test_audio", 0 );
 487
 488                 // Update other info on the frame
 489                 mlt_properties_set_int( properties, "width", 720 );
 490                 mlt_properties_set_int( properties, "height", this->is_pal ? 576 : 480 );
 491                 mlt_properties_set_int( properties, "real_width", 720 );
 492                 mlt_properties_set_int( properties, "real_height", this->is_pal ? 576 : 480 );
 493                 mlt_properties_set_int( properties, "top_field_first", !this->is_pal ? 0 : ( data[ 5 ] & 0x07 ) == 0 ? 0 : 1 );
 494                 mlt_properties_set_int( properties, "colorspace", 601 );
 495
 496                 // Parse the header for meta info
 497                 dv_parse_header( dv_decoder, data );
 498                 //mlt_properties_set_int( properties, "progressive", dv_is_progressive( dv_decoder ) );
 499                 mlt_properties_set_double( properties, "aspect_ratio",
 500                                 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 ) );
 501
 502
 503                 mlt_properties_set_int( properties, "frequency", dv_decoder->audio->frequency );
 504                 mlt_properties_set_int( properties, "channels", dv_decoder->audio->num_channels );
 505
 506                 // Register audio callback
 507                 if ( mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( producer ), "audio_index" ) > 0 )
 508                         mlt_frame_push_audio( *frame, producer_get_audio );
 509
 510                 if ( mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( producer ), "video_index" ) > -1 )
 511                 {
 512                         // Push the quality string
 513                         mlt_frame_push_service( *frame, mlt_properties_get( MLT_PRODUCER_PROPERTIES( producer ), "quality" ) );
 514
 515                         // Push the get_image method on to the stack
 516                         mlt_frame_push_get_image( *frame, producer_get_image );
 517                 }
 518
 519                 // Return the decoder
 520                 dv_decoder_return( dv_decoder );
 521         }
 522
 523         // Update timecode on the frame we're creating
 524         mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
 525
 526         // Calculate the next timecode
 527         mlt_producer_prepare_next( producer );
 528
 529         return 0;
 530 }
 531
 532 static void producer_close( mlt_producer parent )
 533 {
 534         // Obtain this
 535         producer_libdv this = parent->child;
 536
 537         // Close the file
 538         if ( this->fd > 0 )
 539                 close( this->fd );
 540
 541         if ( this->alternative )
 542                 mlt_producer_close( this->alternative );
 543
 544         // Close the parent
 545         parent->close = NULL;
 546         mlt_producer_close( parent );
 547
 548         // Free the memory
 549         free( this );
 550 }