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