libhb/scan.c

   1 /* $Id: scan.c,v 1.52 2005/11/25 15:05:25 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.m0k.org/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "hb.h"
   8 #include "a52dec/a52.h"
   9
  10 typedef struct
  11 {
  12     hb_handle_t * h;
  13
  14     char        * path;
  15     int           title_index;
  16     hb_list_t   * list_title;
  17
  18     hb_dvd_t    * dvd;
  19
  20 } hb_scan_t;
  21
  22 static void ScanFunc( void * );
  23 static int  DecodePreviews( hb_scan_t *, hb_title_t * title );
  24 static void LookForAC3( hb_title_t * title, hb_buffer_t * b );
  25 static int  AllAC3OK( hb_title_t * title );
  26
  27 hb_thread_t * hb_scan_init( hb_handle_t * handle, const char * path,
  28                             int title_index, hb_list_t * list_title )
  29 {
  30     hb_scan_t * data = calloc( sizeof( hb_scan_t ), 1 );
  31
  32     data->h            = handle;
  33     data->path         = strdup( path );
  34     data->title_index  = title_index;
  35     data->list_title   = list_title;
  36
  37     return hb_thread_init( "scan", ScanFunc, data, HB_NORMAL_PRIORITY );
  38 }
  39
  40 static void ScanFunc( void * _data )
  41 {
  42     hb_scan_t  * data = (hb_scan_t *) _data;
  43     hb_title_t * title;
  44     int          i;
  45
  46     /* Try to open the path as a DVD. If it fails, try as a file */
  47     hb_log( "scan: trying to open with libdvdread" );
  48     if( ( data->dvd = hb_dvd_init( data->path ) ) )
  49     {
  50         hb_log( "scan: DVD has %d title(s)",
  51                 hb_dvd_title_count( data->dvd ) );
  52         if( data->title_index )
  53         {
  54             /* Scan this title only */
  55             hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd,
  56                             data->title_index ) );
  57         }
  58         else
  59         {
  60             /* Scan all titles */
  61             for( i = 0; i < hb_dvd_title_count( data->dvd ); i++ )
  62             {
  63                 hb_list_add( data->list_title,
  64                              hb_dvd_title_scan( data->dvd, i + 1 ) );
  65             }
  66         }
  67     }
  68     else
  69     {
  70         /* Open as a VOB file */
  71         FILE * file;
  72         hb_log( "scan: trying to open as VOB file" );
  73         file = fopen( data->path, "rb" );
  74         if( file )
  75         {
  76             /* XXX */
  77             fclose( file );
  78         }
  79         else
  80         {
  81             hb_log( "scan: fopen failed" );
  82             return;
  83         }
  84     }
  85
  86     for( i = 0; i < hb_list_count( data->list_title ); )
  87     {
  88         int j;
  89         hb_state_t state;
  90         hb_audio_t * audio;
  91         hb_title_t * title_tmp = NULL;
  92
  93         title = hb_list_item( data->list_title, i );
  94
  95         /* I've seen a DVD with strictly identical titles. Check this
  96            here and ignore it if redundant */
  97         for( j = 0; j < i; j++ )
  98         {
  99             title_tmp = hb_list_item( data->list_title, j );
 100             if( title->vts         == title_tmp->vts &&
 101                 title->block_start == title_tmp->block_start &&
 102                 title->block_end   == title_tmp->block_end &&
 103                 title->block_count == title_tmp->block_count )
 104             {
 105                 break;
 106             }
 107             else
 108             {
 109                 title_tmp = NULL;
 110             }
 111         }
 112         if( title_tmp )
 113         {
 114             hb_log( "scan: title %d is duplicate with title %d",
 115                     title->index, title_tmp->index );
 116             hb_list_rem( data->list_title, title );
 117             free( title );      /* This _will_ leak! */
 118             continue;
 119         }
 120
 121 #define p state.param.scanning
 122         /* Update the UI */
 123         state.state   = HB_STATE_SCANNING;
 124         p.title_cur   = title->index;
 125         p.title_count = hb_dvd_title_count( data->dvd );
 126         hb_set_state( data->h, &state );
 127 #undef p
 128
 129         /* Decode previews */
 130         if( !DecodePreviews( data, title ) )
 131         {
 132             /* TODO: free things */
 133             hb_list_rem( data->list_title, title );
 134             continue;
 135         }
 136
 137         /* Make sure we found AC3 rates and bitrates */
 138         for( j = 0; j < hb_list_count( title->list_audio ); )
 139         {
 140             audio = hb_list_item( title->list_audio, j );
 141             if( audio->codec == HB_ACODEC_AC3 &&
 142                 !audio->bitrate )
 143             {
 144                 hb_list_rem( title->list_audio, audio );
 145                 free( audio );
 146                 continue;
 147             }
 148             j++;
 149         }
 150
 151         /* Do we still have audio */
 152         if( !hb_list_count( title->list_audio ) )
 153         {
 154             hb_list_rem( data->list_title, title );
 155             free( title );
 156             continue;
 157         }
 158
 159         i++;
 160     }
 161
 162     /* Init jobs templates */
 163     for( i = 0; i < hb_list_count( data->list_title ); i++ )
 164     {
 165         hb_job_t * job;
 166
 167         title      = hb_list_item( data->list_title, i );
 168         job        = calloc( sizeof( hb_job_t ), 1 );
 169         title->job = job;
 170
 171         job->title = title;
 172
 173         /* Set defaults settings */
 174         job->chapter_start = 1;
 175         job->chapter_end   = hb_list_count( title->list_chapter );
 176
 177         /* Autocrop by default. Gnark gnark */
 178         memcpy( job->crop, title->crop, 4 * sizeof( int ) );
 179
 180         if( title->aspect == 16 )
 181         {
 182             hb_reduce( &job->pixel_aspect_width, &job->pixel_aspect_height,
 183                        16 * title->height, 9 * title->width );
 184         }
 185         else
 186         {
 187             hb_reduce( &job->pixel_aspect_width, &job->pixel_aspect_height,
 188                        4 * title->height, 3 * title->width );
 189         }
 190
 191         job->width = title->width - job->crop[2] - job->crop[3];
 192 //        job->height = title->height - job->crop[0] - job->crop[1];
 193         hb_fix_aspect( job, HB_KEEP_WIDTH );
 194         if( job->height > title->height - job->crop[0] - job->crop[1] )
 195         {
 196             job->height = title->height - job->crop[0] - job->crop[1];
 197             hb_fix_aspect( job, HB_KEEP_HEIGHT );
 198         }
 199
 200     hb_log( "scan: title (%d) job->width:%d, job->height:%d",
 201             i,job->width, job->height );
 202
 203         job->keep_ratio = 1;
 204
 205         job->vcodec     = HB_VCODEC_FFMPEG;
 206         job->vquality   = -1.0;
 207         job->vbitrate   = 1000;
 208         job->pass       = 0;
 209         job->vrate      = title->rate;
 210         job->vrate_base = title->rate_base;
 211
 212         job->audios[0] = 0;
 213         job->audios[1] = -1;
 214
 215         job->acodec   = HB_ACODEC_FAAC;
 216         job->abitrate = 128;
 217         job->arate    = 44100;
 218
 219         job->subtitle = -1;
 220
 221         job->mux = HB_MUX_MP4;
 222     }
 223
 224     if( data->dvd )
 225     {
 226         hb_dvd_close( &data->dvd );
 227     }
 228     free( data->path );
 229     free( data );
 230     _data = NULL;
 231 }
 232
 233 /***********************************************************************
 234  * DecodePreviews
 235  ***********************************************************************
 236  * Decode 10 pictures for the given title.
 237  * It assumes that data->reader and data->vts have successfully been
 238  * DVDOpen()ed and ifoOpen()ed.
 239  **********************************************************************/
 240 static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
 241 {
 242     int             i, ret;
 243     hb_buffer_t   * buf_ps, * buf_es, * buf_raw;
 244     hb_list_t     * list_es, * list_raw;
 245     hb_libmpeg2_t * mpeg2;
 246
 247     buf_ps   = hb_buffer_init( 2048 );
 248     list_es  = hb_list_init();
 249     list_raw = hb_list_init();
 250
 251     hb_log( "scan: decoding previews for title %d", title->index );
 252
 253     hb_dvd_start( data->dvd, title->index, 1 );
 254
 255     for( i = 0; i < 10; i++ )
 256     {
 257         int j, k;
 258         FILE * file_preview;
 259         char   filename[1024];
 260
 261         if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / 11.0 ) )
 262         {
 263             goto error;
 264         }
 265
 266         hb_log( "scan: preview %d", i + 1 );
 267
 268         mpeg2 = hb_libmpeg2_init();
 269
 270         for( j = 0; j < 10240 ; j++ )
 271         {
 272             if( !hb_dvd_read( data->dvd, buf_ps ) )
 273             {
 274                 goto error;
 275             }
 276             hb_demux_ps( buf_ps, list_es );
 277
 278             while( ( buf_es = hb_list_item( list_es, 0 ) ) )
 279             {
 280                 hb_list_rem( list_es, buf_es );
 281                 if( buf_es->id == 0xE0 && !hb_list_count( list_raw ) )
 282                 {
 283                     hb_libmpeg2_decode( mpeg2, buf_es, list_raw );
 284                 }
 285                 else if( !i )
 286                 {
 287                     LookForAC3( title, buf_es );
 288                 }
 289                 hb_buffer_close( &buf_es );
 290
 291                 if( hb_list_count( list_raw ) &&
 292                     ( i || AllAC3OK( title ) ) )
 293                 {
 294                     /* We got a picture */
 295                     break;
 296                 }
 297             }
 298
 299             if( hb_list_count( list_raw ) &&
 300                 ( i || AllAC3OK( title ) ) )
 301             {
 302                 break;
 303             }
 304         }
 305
 306         if( !hb_list_count( list_raw ) )
 307         {
 308             hb_log( "scan: could not get a decoded picture" );
 309             goto error;
 310         }
 311
 312         if( !i )
 313         {
 314             /* Get size and rate infos */
 315             title->rate = 27000000;
 316             hb_libmpeg2_info( mpeg2, &title->width, &title->height,
 317                               &title->rate_base );
 318             title->crop[0] = title->crop[1] = title->height / 2;
 319             title->crop[2] = title->crop[3] = title->width / 2;
 320         }
 321
 322         hb_libmpeg2_close( &mpeg2 );
 323
 324         while( ( buf_es = hb_list_item( list_es, 0 ) ) )
 325         {
 326             hb_list_rem( list_es, buf_es );
 327             hb_buffer_close( &buf_es );
 328         }
 329
 330         buf_raw = hb_list_item( list_raw, 0 );
 331
 332         hb_get_tempory_filename( data->h, filename, "%x%d",
 333                                  (intptr_t)title, i );
 334
 335         file_preview = fopen( filename, "w" );
 336         if( file_preview )
 337         {
 338             fwrite( buf_raw->data, title->width * title->height * 3 / 2,
 339                     1, file_preview );
 340             fclose( file_preview );
 341         }
 342         else
 343         {
 344             hb_log( "scan: fopen failed (%s)", filename );
 345         }
 346
 347 #define Y    buf_raw->data
 348 #define DARK 64
 349
 350         /* Detect black borders */
 351
 352         for( j = 0; j < title->width; j++ )
 353         {
 354             for( k = 0; k < title->crop[0]; k++ )
 355                 if( Y[ k * title->width + j ] > DARK )
 356                 {
 357                     title->crop[0] = k;
 358                     break;
 359                 }
 360             for( k = 0; k < title->crop[1]; k++ )
 361                 if( Y[ ( title->height - k - 1 ) *
 362                        title->width + j ] > DARK )
 363                 {
 364                     title->crop[1] = k;
 365                     break;
 366                 }
 367         }
 368         for( j = 0; j < title->height; j++ )
 369         {
 370             for( k = 0; k < title->crop[2]; k++ )
 371                 if( Y[ j * title->width + k ] > DARK )
 372                 {
 373                     title->crop[2] = k;
 374                     break;
 375                 }
 376             for( k = 0; k < title->crop[3]; k++ )
 377                 if( Y[ j * title->width +
 378                         title->width - k - 1 ] > DARK )
 379                 {
 380                     title->crop[3] = k;
 381                     break;
 382                 }
 383         }
 384
 385         while( ( buf_raw = hb_list_item( list_raw, 0 ) ) )
 386         {
 387             hb_list_rem( list_raw, buf_raw );
 388             hb_buffer_close( &buf_raw );
 389         }
 390     }
 391
 392     title->crop[0] = EVEN( title->crop[0] );
 393     title->crop[1] = EVEN( title->crop[1] );
 394     title->crop[2] = EVEN( title->crop[2] );
 395     title->crop[3] = EVEN( title->crop[3] );
 396
 397     hb_log( "scan: %dx%d, %.3f fps, autocrop = %d/%d/%d/%d",
 398             title->width, title->height, (float) title->rate /
 399             (float) title->rate_base, title->crop[0], title->crop[1],
 400             title->crop[2], title->crop[3] );
 401
 402     ret = 1;
 403     goto cleanup;
 404
 405 error:
 406     ret = 0;
 407
 408 cleanup:
 409     hb_buffer_close( &buf_ps );
 410     while( ( buf_es = hb_list_item( list_es, 0 ) ) )
 411     {
 412         hb_list_rem( list_es, buf_es );
 413         hb_buffer_close( &buf_es );
 414     }
 415     hb_list_close( &list_es );
 416     while( ( buf_raw = hb_list_item( list_raw, 0 ) ) )
 417     {
 418         hb_list_rem( list_raw, buf_raw );
 419         hb_buffer_close( &buf_raw );
 420     }
 421     hb_list_close( &list_raw );
 422     hb_dvd_stop( data->dvd );
 423     return ret;
 424 }
 425
 426 static void LookForAC3( hb_title_t * title, hb_buffer_t * b )
 427 {
 428     int i;
 429     int flags;
 430     int rate;
 431     int bitrate;
 432
 433     /* Figure out if this is a AC3 buffer for a known track */
 434     hb_audio_t * audio = NULL;
 435     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 436     {
 437         audio = hb_list_item( title->list_audio, i );
 438         if( audio->codec == HB_ACODEC_AC3 &&
 439             audio->id    == b->id )
 440         {
 441             break;
 442         }
 443         else
 444         {
 445             audio = NULL;
 446         }
 447     }
 448     if( !audio )
 449     {
 450         return;
 451     }
 452
 453     if( audio->bitrate )
 454     {
 455         /* Already done for this track */
 456         return;
 457     }
 458
 459     for( i = 0; i < b->size - 7; i++ )
 460     {
 461         if( a52_syncinfo( &b->data[i], &flags, &rate, &bitrate ) )
 462         {
 463             hb_log( "scan: rate=%dHz, bitrate=%d", rate, bitrate );
 464             audio->rate    = rate;
 465             audio->bitrate = bitrate;
 466             switch( flags & A52_CHANNEL_MASK )
 467             {
 468                 case A52_MONO:
 469                 case A52_CHANNEL1:
 470                 case A52_CHANNEL2:
 471                     audio->src_discrete_front_channels = 1;
 472                     audio->src_discrete_rear_channels = 0;
 473                     audio->src_encoded_front_channels = 1;
 474                     audio->src_encoded_rear_channels = 0;
 475                     break;
 476                 case A52_STEREO:
 477                 case A52_CHANNEL:
 478                     audio->src_discrete_front_channels = 2;
 479                     audio->src_discrete_rear_channels = 0;
 480                     audio->src_encoded_front_channels = 2;
 481                     audio->src_encoded_rear_channels = 0;
 482                     break;
 483                 case A52_DOLBY:
 484                     audio->src_discrete_front_channels = 2;
 485                     audio->src_discrete_rear_channels = 0;
 486                     audio->src_encoded_front_channels = 3;
 487                     audio->src_encoded_rear_channels = 1;
 488                     break;
 489                 case A52_3F:
 490                     audio->src_discrete_front_channels = 3;
 491                     audio->src_discrete_rear_channels = 0;
 492                     audio->src_encoded_front_channels = 3;
 493                     audio->src_encoded_rear_channels = 0;
 494                     break;
 495                 case A52_2F1R:
 496                     audio->src_discrete_front_channels = 2;
 497                     audio->src_discrete_rear_channels = 1;
 498                     audio->src_encoded_front_channels = 2;
 499                     audio->src_encoded_rear_channels = 1;
 500                     break;
 501                 case A52_3F1R:
 502                     audio->src_discrete_front_channels = 3;
 503                     audio->src_discrete_rear_channels = 1;
 504                     audio->src_encoded_front_channels = 3;
 505                     audio->src_encoded_rear_channels = 1;
 506                     break;
 507                                 case A52_2F2R:
 508                     audio->src_discrete_front_channels = 2;
 509                     audio->src_discrete_rear_channels = 2;
 510                     audio->src_encoded_front_channels = 2;
 511                     audio->src_encoded_rear_channels = 2;
 512                     break;
 513                 case A52_3F2R:
 514                     audio->src_discrete_front_channels = 3;
 515                     audio->src_discrete_rear_channels = 2;
 516                     audio->src_encoded_front_channels = 3;
 517                     audio->src_encoded_rear_channels = 2;
 518                     break;
 519             }
 520
 521                         if (flags & A52_LFE) {
 522                 audio->src_discrete_lfe_channels = 1;
 523                         } else {
 524                 audio->src_discrete_lfe_channels = 0;
 525                         }
 526
 527                         /* store the AC3 flags for future reference
 528                         This enables us to find out if we had a stereo or Dolby source later on */
 529                         audio->config.a52.ac3flags = flags;
 530
 531                         /* store the ac3 flags in the public ac3flags property too, so we can access it from the GUI */
 532                         audio->ac3flags = audio->config.a52.ac3flags;
 533
 534             /* XXX */
 535                         if ( (flags & A52_CHANNEL_MASK) == A52_DOLBY ) {
 536                                 sprintf( audio->lang + strlen( audio->lang ),
 537                      " (Dolby Surround)" );
 538                         } else {
 539                                 sprintf( audio->lang + strlen( audio->lang ),
 540                      " (%d.%d ch)",
 541                                          audio->src_discrete_front_channels + audio->src_discrete_rear_channels, audio->src_discrete_lfe_channels );
 542                         }
 543
 544             break;
 545         }
 546     }
 547 }
 548
 549 static int  AllAC3OK( hb_title_t * title )
 550 {
 551     int i;
 552     hb_audio_t * audio;
 553
 554     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 555     {
 556         audio = hb_list_item( title->list_audio, i );
 557         if( audio->codec == HB_ACODEC_AC3 &&
 558             !audio->bitrate )
 559         {
 560             return 0;
 561         }
 562     }
 563
 564     return 1;
 565 }