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.fr/>.
   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 #define HB_MAX_PREVIEWS 30 // 30 previews = every 5 minutes of a 2.5 hour video
  12
  13 typedef struct
  14 {
  15     hb_handle_t * h;
  16
  17     char        * path;
  18     int           title_index;
  19     hb_list_t   * list_title;
  20
  21     hb_dvd_t    * dvd;
  22         hb_stream_t * stream;
  23
  24     int           preview_count;
  25     int           store_previews;
  26
  27 } hb_scan_t;
  28
  29 static void ScanFunc( void * );
  30 static int  DecodePreviews( hb_scan_t *, hb_title_t * title );
  31 static void LookForAudio( hb_title_t * title, hb_buffer_t * b );
  32 static int  AllAudioOK( hb_title_t * title );
  33
  34 static const char *aspect_to_string( double aspect )
  35 {
  36     switch ( (int)(aspect * 9.) )
  37     {
  38         case 9 * 4 / 3:    return "4:3";
  39         case 9 * 16 / 9:   return "16:9";
  40     }
  41     static char arstr[32];
  42     sprintf( arstr, aspect >= 1.? "%.2f:1" : "1:%.2f", aspect );
  43     return arstr;
  44 }
  45
  46 hb_thread_t * hb_scan_init( hb_handle_t * handle, const char * path,
  47                             int title_index, hb_list_t * list_title,
  48                             int preview_count, int store_previews )
  49 {
  50     hb_scan_t * data = calloc( sizeof( hb_scan_t ), 1 );
  51
  52     data->h            = handle;
  53     data->path         = strdup( path );
  54     data->title_index  = title_index;
  55     data->list_title   = list_title;
  56
  57     data->preview_count  = preview_count;
  58     data->store_previews = store_previews;
  59
  60     return hb_thread_init( "scan", ScanFunc, data, HB_NORMAL_PRIORITY );
  61 }
  62
  63 static void ScanFunc( void * _data )
  64 {
  65     hb_scan_t  * data = (hb_scan_t *) _data;
  66     hb_title_t * title;
  67     int          i;
  68
  69         data->dvd = NULL;
  70         data->stream = NULL;
  71
  72     /* Try to open the path as a DVD. If it fails, try as a file */
  73     hb_log( "scan: trying to open with libdvdread" );
  74     if( ( data->dvd = hb_dvd_init( data->path ) ) )
  75     {
  76         hb_log( "scan: DVD has %d title(s)",
  77                 hb_dvd_title_count( data->dvd ) );
  78         if( data->title_index )
  79         {
  80             /* Scan this title only */
  81             hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd,
  82                             data->title_index ) );
  83         }
  84         else
  85         {
  86             /* Scan all titles */
  87             for( i = 0; i < hb_dvd_title_count( data->dvd ); i++ )
  88             {
  89                 hb_list_add( data->list_title,
  90                              hb_dvd_title_scan( data->dvd, i + 1 ) );
  91             }
  92         }
  93     }
  94     else if ( (data->stream = hb_stream_open( data->path, 0 ) ) != NULL )
  95     {
  96         hb_list_add( data->list_title, hb_stream_title_scan( data->stream ) );
  97     }
  98     else
  99     {
 100         hb_log( "scan: unrecognized file type" );
 101         return;
 102     }
 103
 104     for( i = 0; i < hb_list_count( data->list_title ); )
 105     {
 106         int j;
 107         hb_state_t state;
 108         hb_audio_t * audio;
 109         hb_title_t * title_tmp = NULL;
 110
 111         title = hb_list_item( data->list_title, i );
 112
 113         /* I've seen a DVD with strictly identical titles. Check this
 114            here and ignore it if redundant */
 115         for( j = 0; j < i; j++ )
 116         {
 117             title_tmp = hb_list_item( data->list_title, j );
 118             if( title->vts         == title_tmp->vts &&
 119                 title->block_start == title_tmp->block_start &&
 120                 title->block_end   == title_tmp->block_end &&
 121                 title->block_count == title_tmp->block_count )
 122             {
 123                 break;
 124             }
 125             else
 126             {
 127                 title_tmp = NULL;
 128             }
 129         }
 130         if( title_tmp )
 131         {
 132             hb_log( "scan: title %d is duplicate with title %d",
 133                     title->index, title_tmp->index );
 134             hb_list_rem( data->list_title, title );
 135             free( title );      /* This _will_ leak! */
 136             continue;
 137         }
 138
 139 #define p state.param.scanning
 140         /* Update the UI */
 141         state.state   = HB_STATE_SCANNING;
 142         p.title_cur   = title->index;
 143         p.title_count = data->dvd ? hb_dvd_title_count( data->dvd ) : hb_list_count(data->list_title);
 144         hb_set_state( data->h, &state );
 145 #undef p
 146
 147         /* Decode previews */
 148         /* this will also detect more AC3 / DTS information */
 149         if( !DecodePreviews( data, title ) )
 150         {
 151             /* TODO: free things */
 152             hb_list_rem( data->list_title, title );
 153             continue;
 154         }
 155
 156         /* Make sure we found audio rates and bitrates */
 157         for( j = 0; j < hb_list_count( title->list_audio ); )
 158         {
 159             audio = hb_list_item( title->list_audio, j );
 160             if( !audio->config.in.bitrate )
 161             {
 162                 hb_log( "scan: removing audio 0x%x because no bitrate found",
 163                         audio->id );
 164                 hb_list_rem( title->list_audio, audio );
 165                 free( audio );
 166                 continue;
 167             }
 168             j++;
 169         }
 170
 171         i++;
 172     }
 173
 174     /* Init jobs templates */
 175     for( i = 0; i < hb_list_count( data->list_title ); i++ )
 176     {
 177         hb_job_t * job;
 178
 179         title      = hb_list_item( data->list_title, i );
 180         job        = calloc( sizeof( hb_job_t ), 1 );
 181         title->job = job;
 182
 183         job->title = title;
 184
 185         /* Set defaults settings */
 186         job->chapter_start = 1;
 187         job->chapter_end   = hb_list_count( title->list_chapter );
 188
 189         /* Autocrop by default. Gnark gnark */
 190         memcpy( job->crop, title->crop, 4 * sizeof( int ) );
 191
 192         /* Preserve a source's pixel aspect, if it's available. */
 193         if( title->pixel_aspect_width && title->pixel_aspect_height )
 194         {
 195             job->anamorphic.par_width  = title->pixel_aspect_width;
 196             job->anamorphic.par_height = title->pixel_aspect_height;
 197         }
 198
 199         if( title->aspect != 0 && title->aspect != 1. &&
 200             !job->anamorphic.par_width && !job->anamorphic.par_height)
 201         {
 202             hb_reduce( &job->anamorphic.par_width, &job->anamorphic.par_height,
 203                        (int)(title->aspect * title->height + 0.5), title->width );
 204         }
 205
 206         job->width = title->width - job->crop[2] - job->crop[3];
 207         hb_fix_aspect( job, HB_KEEP_WIDTH );
 208         if( job->height > title->height - job->crop[0] - job->crop[1] )
 209         {
 210             job->height = title->height - job->crop[0] - job->crop[1];
 211             hb_fix_aspect( job, HB_KEEP_HEIGHT );
 212         }
 213
 214         hb_log( "scan: title (%d) job->width:%d, job->height:%d",
 215                 i, job->width, job->height );
 216
 217         job->keep_ratio = 1;
 218
 219         job->vcodec     = HB_VCODEC_FFMPEG;
 220         job->vquality   = -1.0;
 221         job->vbitrate   = 1000;
 222         job->pass       = 0;
 223         job->vrate      = title->rate;
 224         job->vrate_base = title->rate_base;
 225
 226         job->list_audio = hb_list_init();
 227
 228         job->subtitle = -1;
 229
 230         job->mux = HB_MUX_MP4;
 231     }
 232
 233     if( data->dvd )
 234     {
 235         hb_dvd_close( &data->dvd );
 236     }
 237         if (data->stream)
 238         {
 239                 hb_stream_close(&data->stream);
 240         }
 241     free( data->path );
 242     free( data );
 243     _data = NULL;
 244 }
 245
 246 // -----------------------------------------------
 247 // stuff related to cropping
 248
 249 #define DARK 32
 250
 251 static inline int absdiff( int x, int y )
 252 {
 253     return x < y ? y - x : x - y;
 254 }
 255
 256 static inline int clampBlack( int x )
 257 {
 258     // luma 'black' is 16 and anything less should be clamped at 16
 259     return x < 16 ? 16 : x;
 260 }
 261
 262 static int row_all_dark( hb_title_t *title, uint8_t* luma, int row )
 263 {
 264     luma += title->width * row;
 265
 266     // compute the average luma value of the row
 267     int i, avg = 0;
 268     for ( i = 0; i < title->width; ++i )
 269     {
 270         avg += clampBlack( luma[i] );
 271     }
 272     avg /= title->width;
 273     if ( avg >= DARK )
 274         return 0;
 275
 276     // since we're trying to detect smooth borders, only take the row if
 277     // all pixels are within +-16 of the average (this range is fairly coarse
 278     // but there's a lot of quantization noise for luma values near black
 279     // so anything less will fail to crop because of the noise).
 280     for ( i = 0; i < title->width; ++i )
 281     {
 282         if ( absdiff( avg, clampBlack( luma[i] ) ) > 16 )
 283             return 0;
 284     }
 285     return 1;
 286 }
 287
 288 static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int bottom,
 289                             int col )
 290 {
 291     int stride = title->width;
 292     int height = title->height - top - bottom;
 293     luma += stride * top + col;
 294
 295     // compute the average value of the column
 296     int i = height, avg = 0, row = 0;
 297     for ( ; --i >= 0; row += stride )
 298     {
 299         avg += clampBlack( luma[row] );
 300     }
 301     avg /= height;
 302     if ( avg >= DARK )
 303         return 0;
 304
 305     // since we're trying to detect smooth borders, only take the column if
 306     // all pixels are within +-16 of the average.
 307     i = height, row = 0;
 308     for ( ; --i >= 0; row += stride )
 309     {
 310         if ( absdiff( avg, clampBlack( luma[row] ) ) > 16 )
 311             return 0;
 312     }
 313     return 1;
 314 }
 315 #undef DARK
 316
 317 typedef struct {
 318     int n;
 319     int t[HB_MAX_PREVIEWS];
 320     int b[HB_MAX_PREVIEWS];
 321     int l[HB_MAX_PREVIEWS];
 322     int r[HB_MAX_PREVIEWS];
 323 } crop_record_t;
 324
 325 static void record_crop( crop_record_t *crops, int t, int b, int l, int r )
 326 {
 327     crops->t[crops->n] = t;
 328     crops->b[crops->n] = b;
 329     crops->l[crops->n] = l;
 330     crops->r[crops->n] = r;
 331     ++crops->n;
 332 }
 333
 334 static int compare_int( const void *a, const void *b )
 335 {
 336     return *(const int *)a - *(const int *)b;
 337 }
 338
 339 static void sort_crops( crop_record_t *crops )
 340 {
 341     qsort( crops->t, crops->n, sizeof(crops->t[0]), compare_int );
 342     qsort( crops->b, crops->n, sizeof(crops->t[0]), compare_int );
 343     qsort( crops->l, crops->n, sizeof(crops->t[0]), compare_int );
 344     qsort( crops->r, crops->n, sizeof(crops->t[0]), compare_int );
 345 }
 346
 347 // -----------------------------------------------
 348 // stuff related to title width/height/aspect info
 349
 350 typedef struct {
 351     int count;              /* number of times we've seen this info entry */
 352     hb_work_info_t info;    /* copy of info entry */
 353 } info_list_t;
 354
 355 static void remember_info( info_list_t *info_list, hb_work_info_t *info )
 356 {
 357     for ( ; info_list->count; ++info_list )
 358     {
 359         if ( memcmp( &info_list->info, info, sizeof(*info) ) == 0 )
 360         {
 361             // we found a match - bump its count
 362             ++info_list->count;
 363             return;
 364         }
 365     }
 366     // no match found - add new entry to list (info_list points to
 367     // the first free slot). NB - we assume that info_list was allocated
 368     // so that it's big enough even if there are no dups. I.e., 10 slots
 369     // allocated if there are 10 previews.
 370     info_list->count = 1;
 371     info_list->info = *info;
 372 }
 373
 374 static void most_common_info( info_list_t *info_list, hb_work_info_t *info )
 375 {
 376     int i, biggest = 0;
 377     for ( i = 1; info_list[i].count; ++i )
 378     {
 379         if ( info_list[i].count > info_list[biggest].count )
 380             biggest = i;
 381     }
 382     *info = info_list[biggest].info;
 383     free( info_list );
 384 }
 385
 386 /***********************************************************************
 387  * DecodePreviews
 388  ***********************************************************************
 389  * Decode 10 pictures for the given title.
 390  * It assumes that data->reader and data->vts have successfully been
 391  * DVDOpen()ed and ifoOpen()ed.
 392  **********************************************************************/
 393 static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
 394 {
 395     int             i, npreviews = 0;
 396     hb_buffer_t   * buf_ps, * buf_es;
 397     hb_list_t     * list_es;
 398     int progressive_count = 0;
 399     int interlaced_preview_count = 0;
 400     info_list_t * info_list = calloc( data->preview_count+1, sizeof(*info_list) );
 401     crop_record_t *crops = calloc( 1, sizeof(*crops) );
 402
 403     buf_ps   = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
 404     list_es  = hb_list_init();
 405
 406     hb_log( "scan: decoding previews for title %d", title->index );
 407
 408     if (data->dvd)
 409       hb_dvd_start( data->dvd, title->index, 1 );
 410
 411     for( i = 0; i < data->preview_count; i++ )
 412     {
 413         int j;
 414         FILE * file_preview;
 415         char   filename[1024];
 416
 417         if (data->dvd)
 418         {
 419           if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) )
 420           {
 421               continue;
 422           }
 423         }
 424         else if (data->stream)
 425         {
 426           /* we start reading streams at zero rather than 1/11 because
 427            * short streams may have only one sequence header in the entire
 428            * file and we need it to decode any previews. */
 429           if (!hb_stream_seek(data->stream, (float) i / ( data->preview_count + 1.0 ) ) )
 430           {
 431               continue;
 432           }
 433         }
 434
 435         hb_deep_log( 2, "scan: preview %d", i + 1 );
 436
 437         int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
 438         hb_work_object_t *vid_decoder = hb_get_work( vcodec );
 439         vid_decoder->codec_param = title->video_codec_param;
 440         vid_decoder->init( vid_decoder, NULL );
 441         hb_buffer_t * vid_buf = NULL;
 442         int vidskip = 0;
 443
 444         if ( title->flags & HBTF_NO_IDR )
 445         {
 446             // title doesn't have IDR frames so we decode but drop one second's
 447             // worth of frames to allow the decoder to converge.
 448             if ( ! title->rate_base )
 449             {
 450                 vidskip = 30;
 451             }
 452             else
 453             {
 454                 vidskip = (double)title->rate / (double)title->rate_base + 0.5;
 455             }
 456         }
 457
 458         for( j = 0; j < 10240 ; j++ )
 459         {
 460             if (data->dvd)
 461             {
 462               if( !hb_dvd_read( data->dvd, buf_ps ) )
 463               {
 464                   if ( vid_buf )
 465                   {
 466                     break;
 467                   }
 468                   hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
 469                   goto skip_preview;
 470               }
 471             }
 472             else if (data->stream)
 473             {
 474               if ( !hb_stream_read(data->stream,buf_ps) )
 475               {
 476                   if ( vid_buf )
 477                   {
 478                     break;
 479                   }
 480                   hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
 481                   goto skip_preview;
 482               }
 483             }
 484             (hb_demux[title->demuxer])(buf_ps, list_es, 0 );
 485
 486             while( ( buf_es = hb_list_item( list_es, 0 ) ) )
 487             {
 488                 hb_list_rem( list_es, buf_es );
 489                 if( buf_es->id == title->video_id && vid_buf == NULL )
 490                 {
 491                     vid_decoder->work( vid_decoder, &buf_es, &vid_buf );
 492                     if ( vid_buf && vidskip && --vidskip > 0 )
 493                     {
 494                         // we're dropping frames to get the video decoder in sync
 495                         // when the video stream doesn't contain IDR frames
 496                         hb_buffer_close( &vid_buf );
 497                         vid_buf = NULL;
 498                     }
 499                 }
 500                 else if( ! AllAudioOK( title ) )
 501                 {
 502                     LookForAudio( title, buf_es );
 503                 }
 504                 if ( buf_es )
 505                     hb_buffer_close( &buf_es );
 506             }
 507
 508             if( vid_buf && AllAudioOK( title ) )
 509                 break;
 510         }
 511
 512         if( ! vid_buf )
 513         {
 514             hb_log( "scan: could not get a decoded picture" );
 515             continue;
 516         }
 517
 518         /* Get size and rate infos */
 519
 520         hb_work_info_t vid_info;
 521         if( !vid_decoder->info( vid_decoder, &vid_info ) )
 522         {
 523             /*
 524              * Could not fill vid_info, don't continue and try to use vid_info
 525              * in this case.
 526              */
 527             vid_decoder->close( vid_decoder );
 528             free( vid_decoder );
 529             continue;
 530         }
 531         vid_decoder->close( vid_decoder );
 532         free( vid_decoder );
 533
 534         remember_info( info_list, &vid_info );
 535
 536         title->video_codec_name = strdup( vid_info.name );
 537         title->width = vid_info.width;
 538         title->height = vid_info.height;
 539         title->rate = vid_info.rate;
 540         title->rate_base = vid_info.rate_base;
 541         title->video_bitrate = vid_info.bitrate;
 542
 543         if( title->rate_base == 1126125 )
 544         {
 545             /* Frame FPS is 23.976 (meaning it's progressive), so
 546                start keeping track of how many are reporting at
 547                that speed. When enough show up that way, we want
 548                to make that the overall title FPS.
 549             */
 550             progressive_count++;
 551
 552             if( progressive_count < 6 )
 553             {
 554                 /* Not enough frames are reporting as progressive,
 555                    which means we should be conservative and use
 556                    29.97 as the title's FPS for now.
 557                 */
 558                 title->rate_base = 900900;
 559             }
 560             else
 561             {
 562                 /* A majority of the scan frames are progressive. Make that
 563                     the title's FPS, and announce it once to the log.
 564                 */
 565                 if( progressive_count == 6 )
 566                 {
 567                     hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976");
 568                 }
 569                 title->rate_base = 1126125;
 570             }
 571         }
 572         else if( title->rate_base == 900900 && progressive_count >= 6 )
 573         {
 574             /*
 575              * We've already deduced that the frame rate is 23.976, so set it
 576              * back again.
 577              */
 578             title->rate_base = 1126125;
 579         }
 580
 581         while( ( buf_es = hb_list_item( list_es, 0 ) ) )
 582         {
 583             hb_list_rem( list_es, buf_es );
 584             hb_buffer_close( &buf_es );
 585         }
 586
 587         /* Check preview for interlacing artifacts */
 588         if( hb_detect_comb( vid_buf, title->width, title->height, 10, 30, 9, 10, 30, 9 ) )
 589         {
 590             hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1);
 591             interlaced_preview_count++;
 592         }
 593
 594         if( data->store_previews )
 595         {
 596             hb_get_tempory_filename( data->h, filename, "%" PRIxPTR "%d",
 597                                      (intptr_t)title, i );
 598
 599             file_preview = fopen( filename, "w" );
 600             if( file_preview )
 601             {
 602                 fwrite( vid_buf->data, title->width * title->height * 3 / 2,
 603                         1, file_preview );
 604                 fclose( file_preview );
 605             }
 606             else
 607             {
 608                 hb_log( "scan: fopen failed (%s)", filename );
 609             }
 610         }
 611
 612         /* Detect black borders */
 613
 614 #define Y    vid_buf->data
 615         int top, bottom, left, right;
 616         int h4 = title->height / 4, w4 = title->width / 4;
 617
 618         // When widescreen content is matted to 16:9 or 4:3 there's sometimes
 619         // a thin border on the outer edge of the matte. On TV content it can be
 620         // "line 21" VBI data that's normally hidden in the overscan. For HD
 621         // content it can just be a diagnostic added in post production so that
 622         // the frame borders are visible. We try to ignore these borders so
 623         // we can crop the matte. The border width depends on the resolution
 624         // (12 pixels on 1080i looks visually the same as 4 pixels on 480i)
 625         // so we allow the border to be up to 1% of the frame height.
 626         const int border = title->height / 100;
 627
 628         for ( top = border; top < h4; ++top )
 629         {
 630             if ( ! row_all_dark( title, Y, top ) )
 631                 break;
 632         }
 633         if ( top <= border )
 634         {
 635             // we never made it past the border region - see if the rows we
 636             // didn't check are dark or if we shouldn't crop at all.
 637             for ( top = 0; top < border; ++top )
 638             {
 639                 if ( ! row_all_dark( title, Y, top ) )
 640                     break;
 641             }
 642             if ( top >= border )
 643             {
 644                 top = 0;
 645             }
 646         }
 647         for ( bottom = border; bottom < h4; ++bottom )
 648         {
 649             if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
 650                 break;
 651         }
 652         if ( bottom <= border )
 653         {
 654             for ( bottom = 0; bottom < border; ++bottom )
 655             {
 656                 if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
 657                     break;
 658             }
 659             if ( bottom >= border )
 660             {
 661                 bottom = 0;
 662             }
 663         }
 664         for ( left = 0; left < w4; ++left )
 665         {
 666             if ( ! column_all_dark( title, Y, top, bottom, left ) )
 667                 break;
 668         }
 669         for ( right = 0; right < w4; ++right )
 670         {
 671             if ( ! column_all_dark( title, Y, top, bottom, title->width - 1 - right ) )
 672                 break;
 673         }
 674
 675         // only record the result if all the crops are less than a quarter of
 676         // the frame otherwise we can get fooled by frames with a lot of black
 677         // like titles, credits & fade-thru-black transitions.
 678         if ( top < h4 && bottom < h4 && left < w4 && right < w4 )
 679         {
 680             record_crop( crops, top, bottom, left, right );
 681         }
 682         ++npreviews;
 683
 684 skip_preview:
 685         if ( vid_buf )
 686             hb_buffer_close( &vid_buf );
 687     }
 688
 689     if ( npreviews )
 690     {
 691         // use the most common frame info for our final title dimensions
 692         hb_work_info_t vid_info;
 693         most_common_info( info_list, &vid_info );
 694
 695         title->width = vid_info.width;
 696         title->height = vid_info.height;
 697         title->pixel_aspect_width = vid_info.pixel_aspect_width;
 698         title->pixel_aspect_height = vid_info.pixel_aspect_height;
 699
 700         // compute the aspect ratio based on the storage dimensions and the
 701         // pixel aspect ratio (if supplied) or just storage dimensions if no PAR.
 702         title->aspect = (double)title->width / (double)title->height;
 703         if( title->pixel_aspect_width && title->pixel_aspect_height )
 704         {
 705             title->aspect *= (double)title->pixel_aspect_width /
 706                              (double)title->pixel_aspect_height;
 707
 708             // For unknown reasons some French PAL DVDs put the original
 709             // content's aspect ratio into the mpeg PAR even though it's
 710             // the wrong PAR for the DVD. Apparently they rely on the fact
 711             // that DVD players ignore the content PAR and just use the
 712             // aspect ratio from the DVD metadata. So, if the aspect computed
 713             // from the PAR is different from the container's aspect we use
 714             // the container's aspect & recompute the PAR from it.
 715             if( title->container_aspect && (int)(title->aspect * 9) != (int)(title->container_aspect * 9) )
 716             {
 717                 hb_log("scan: content PAR gives wrong aspect %.2f; "
 718                        "using container aspect %.2f", title->aspect,
 719                        title->container_aspect );
 720                 title->aspect = title->container_aspect;
 721                 hb_reduce( &title->pixel_aspect_width, &title->pixel_aspect_height,
 722                            (int)(title->aspect * title->height + 0.5), title->width );
 723             }
 724         }
 725
 726         // don't try to crop unless we got at least 3 previews
 727         if ( crops->n > 2 )
 728         {
 729             sort_crops( crops );
 730             // The next line selects median cropping - at least
 731             // 50% of the frames will have their borders removed.
 732             // Other possible choices are loose cropping (i = 0) where
 733             // no non-black pixels will be cropped from any frame and a
 734             // tight cropping (i = crops->n - (crops->n >> 2)) where at
 735             // least 75% of the frames will have their borders removed.
 736             i = crops->n >> 1;
 737             title->crop[0] = EVEN( crops->t[i] );
 738             title->crop[1] = EVEN( crops->b[i] );
 739             title->crop[2] = EVEN( crops->l[i] );
 740             title->crop[3] = EVEN( crops->r[i] );
 741         }
 742         free( crops );
 743
 744         hb_log( "scan: %d previews, %dx%d, %.3f fps, autocrop = %d/%d/%d/%d, "
 745                 "aspect %s, PAR %d:%d",
 746                 npreviews, title->width, title->height, (float) title->rate /
 747                 (float) title->rate_base,
 748                 title->crop[0], title->crop[1], title->crop[2], title->crop[3],
 749                 aspect_to_string( title->aspect ), title->pixel_aspect_width,
 750                 title->pixel_aspect_height );
 751
 752         if( interlaced_preview_count >= ( npreviews / 2 ) )
 753         {
 754             hb_log("Title is likely interlaced or telecined (%i out of %i previews). You should do something about that.",
 755                    interlaced_preview_count, npreviews);
 756             title->detected_interlacing = 1;
 757         }
 758         else
 759         {
 760             title->detected_interlacing = 0;
 761         }
 762     }
 763
 764     hb_buffer_close( &buf_ps );
 765     while( ( buf_es = hb_list_item( list_es, 0 ) ) )
 766     {
 767         hb_list_rem( list_es, buf_es );
 768         hb_buffer_close( &buf_es );
 769     }
 770     hb_list_close( &list_es );
 771     if (data->dvd)
 772       hb_dvd_stop( data->dvd );
 773
 774     return npreviews;
 775 }
 776
 777 /*
 778  * This routine is called for every frame from a non-video elementary stream.
 779  * These are a mix of audio & subtitle streams, some of which we want & some
 780  * we're ignoring. This routine checks the frame against all our audio streams
 781  * to see if it's one we want and haven't identified yet. If yes, it passes the
 782  * frame to a codec-specific id routine which is responsible for filling in
 783  * the sample rate, bit rate, channels & other audio parameters.
 784  *
 785  * Since a sample rate is essential for further audio processing, any audio
 786  * stream which isn't successfully id'd by is deleted at the end of the scan.
 787  * This is necessary to avoid ambiguities where things that might be audio
 788  * aren't (e.g., some European DVD Teletext streams use the same IDs as US ATSC
 789  * AC-3 audio).
 790  */
 791 static void LookForAudio( hb_title_t * title, hb_buffer_t * b )
 792 {
 793     int i;
 794
 795     hb_audio_t * audio = NULL;
 796     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 797     {
 798         audio = hb_list_item( title->list_audio, i );
 799         /* check if this elementary stream is one we want */
 800         if ( audio->id == b->id )
 801         {
 802             break;
 803         }
 804         else
 805         {
 806             audio = NULL;
 807         }
 808     }
 809     if( !audio || audio->config.in.bitrate != 0 )
 810     {
 811         /* not found or already done */
 812         return;
 813     }
 814
 815     hb_work_object_t *w = hb_codec_decoder( audio->config.in.codec );
 816
 817     if ( w == NULL || w->bsinfo == NULL )
 818     {
 819         hb_log( "Internal error in scan: unhandled audio type %d for id 0x%x",
 820                 audio->config.in.codec, audio->id );
 821         goto drop_audio;
 822     }
 823
 824     hb_work_info_t info;
 825     w->audio = audio;
 826     w->codec_param = audio->config.in.codec_param;
 827     int ret = w->bsinfo( w, b, &info );
 828     if ( ret < 0 )
 829     {
 830         hb_log( "no info on audio type %d/0x%x for id 0x%x",
 831                 audio->config.in.codec, audio->config.in.codec_param,
 832                 audio->id );
 833         goto drop_audio;
 834     }
 835     if ( !info.bitrate )
 836     {
 837         /* didn't find any info */
 838         return;
 839     }
 840     audio->config.in.samplerate = info.rate;
 841     audio->config.in.bitrate = info.bitrate;
 842     audio->config.in.channel_layout = info.channel_layout;
 843     audio->config.in.version = info.version;
 844     audio->config.in.mode = info.mode;
 845     audio->config.flags.ac3 = info.flags;
 846
 847     // update the audio description string based on the info we found
 848     if ( audio->config.flags.ac3 & AUDIO_F_DOLBY )
 849     {
 850         strcat( audio->config.lang.description, " (Dolby Surround)" );
 851     }
 852     else
 853     {
 854         int layout = audio->config.in.channel_layout;
 855         char *desc = audio->config.lang.description +
 856                         strlen( audio->config.lang.description );
 857         sprintf( desc, " (%d.%d ch)",
 858                  HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(layout) +
 859                      HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(layout),
 860                  HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(layout) );
 861     }
 862
 863     hb_log( "scan: audio 0x%x: %s, rate=%dHz, bitrate=%d %s", audio->id,
 864             info.name, audio->config.in.samplerate, audio->config.in.bitrate,
 865             audio->config.lang.description );
 866
 867     free( w );
 868     return;
 869
 870     // We get here if there's no hope of finding info on an audio bitstream,
 871     // either because we don't have a decoder (or a decoder with a bitstream
 872     // info proc) or because the decoder's info proc said that the stream
 873     // wasn't something it could handle. Delete the item from the title's
 874     // audio list so we won't keep reading packets while trying to get its
 875     // bitstream info.
 876  drop_audio:
 877     if ( w )
 878         free( w );
 879
 880     hb_list_rem( title->list_audio, audio );
 881 }
 882
 883 /*
 884  * This routine checks to see if we've ID'd all the audio streams associated
 885  * with a title. It returns 0 if there are more to ID & 1 if all are done.
 886  */
 887 static int  AllAudioOK( hb_title_t * title )
 888 {
 889     int i;
 890     hb_audio_t * audio;
 891
 892     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 893     {
 894         audio = hb_list_item( title->list_audio, i );
 895         if( audio->config.in.bitrate == 0 )
 896         {
 897             return 0;
 898         }
 899     }
 900     return 1;
 901 }