X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fscan.c;h=eea1c3f0bf74d6d75423b50551446550b4f85fcf;hb=07cc0ebf6a7141a76fd9b6e2da6cf510def1ebc7;hp=6834d4614a6a06306ab2a62b8f7b64468e2e09c7;hpb=1a8ebaf33ee803773082e1978b132273f8fb0bb9;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/libhb/scan.c b/libhb/scan.c
index 6834d461..eea1c3f0 100644
--- a/libhb/scan.c
+++ b/libhb/scan.c
@@ -26,6 +26,18 @@ static int  DecodePreviews( hb_scan_t *, hb_title_t * title );
 static void LookForAudio( hb_title_t * title, hb_buffer_t * b );
 static int  AllAudioOK( hb_title_t * title );
 
+static const char *aspect_to_string( double aspect )
+{
+    switch ( (int)(aspect * 9.) )
+    {
+        case 9 * 4 / 3:    return "4:3";
+        case 9 * 16 / 9:   return "16:9";
+    }
+    static char arstr[32];
+    sprintf( arstr, aspect >= 1.? "%.2f:1" : "1:%.2f", aspect );
+    return arstr;
+}
+
 hb_thread_t * hb_scan_init( hb_handle_t * handle, const char * path,
                             int title_index, hb_list_t * list_title )
 {
@@ -176,15 +188,18 @@ static void ScanFunc( void * _data )
         /* Autocrop by default. Gnark gnark */
         memcpy( job->crop, title->crop, 4 * sizeof( int ) );
 
-        if( title->aspect == 16 && !job->pixel_aspect_width && !job->pixel_aspect_height)
+        /* Preserve a source's pixel aspect, if it's available. */
+        if( title->pixel_aspect_width && title->pixel_aspect_height )
         {
-            hb_reduce( &job->pixel_aspect_width, &job->pixel_aspect_height,
-                       16 * title->height, 9 * title->width );
+            job->pixel_aspect_width  = title->pixel_aspect_width;
+            job->pixel_aspect_height = title->pixel_aspect_height;
         }
-        else if( !job->pixel_aspect_width && !job->pixel_aspect_height )
+
+        if( title->aspect != 0 && title->aspect != 1. &&
+            !job->pixel_aspect_width && !job->pixel_aspect_height)
         {
             hb_reduce( &job->pixel_aspect_width, &job->pixel_aspect_height,
-                       4 * title->height, 3 * title->width );
+                       (int)(title->aspect * title->height), title->width );
         }
 
         job->width = title->width - job->crop[2] - job->crop[3];
@@ -227,6 +242,146 @@ static void ScanFunc( void * _data )
     _data = NULL;
 }
 
+// -----------------------------------------------
+// stuff related to cropping
+
+#define DARK 32
+
+static inline int absdiff( int x, int y )
+{
+    return x < y ? y - x : x - y;
+}
+
+static inline int clampBlack( int x ) 
+{
+    // luma 'black' is 16 and anything less should be clamped at 16
+    return x < 16 ? 16 : x;
+}
+
+static int row_all_dark( hb_title_t *title, uint8_t* luma, int row )
+{
+    luma += title->width * row;
+
+    // compute the average luma value of the row
+    int i, avg = 0;
+    for ( i = 0; i < title->width; ++i )
+    {
+        avg += clampBlack( luma[i] );
+    }
+    avg /= title->width;
+    if ( avg >= DARK )
+        return 0;
+
+    // since we're trying to detect smooth borders, only take the row if
+    // all pixels are within +-16 of the average (this range is fairly coarse
+    // but there's a lot of quantization noise for luma values near black
+    // so anything less will fail to crop because of the noise).
+    for ( i = 0; i < title->width; ++i )
+    {
+        if ( absdiff( avg, clampBlack( luma[i] ) ) > 16 )
+            return 0;
+    }
+    return 1;
+}
+
+static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int bottom,
+                            int col )
+{
+    int stride = title->width;
+    int height = title->height - top - bottom;
+    luma += stride * top + col;
+
+    // compute the average value of the column
+    int i = height, avg = 0, row = 0;
+    for ( ; --i >= 0; row += stride )
+    {
+        avg += clampBlack( luma[row] );
+    }
+    avg /= height;
+    if ( avg >= DARK )
+        return 0;
+
+    // since we're trying to detect smooth borders, only take the column if
+    // all pixels are within +-16 of the average.
+    i = height, row = 0;
+    for ( ; --i >= 0; row += stride )
+    {
+        if ( absdiff( avg, clampBlack( luma[row] ) ) > 16 )
+            return 0;
+    }
+    return 1;
+}
+#undef DARK
+
+typedef struct {
+    int n;
+    int t[10];
+    int b[10];
+    int l[10];
+    int r[10];
+} crop_record_t;
+
+static void record_crop( crop_record_t *crops, int t, int b, int l, int r )
+{
+    crops->t[crops->n] = t;
+    crops->b[crops->n] = b;
+    crops->l[crops->n] = l;
+    crops->r[crops->n] = r;
+    ++crops->n;
+}
+
+static int compare_int( const void *a, const void *b )
+{
+    return *(const int *)a - *(const int *)b;
+}
+
+static void sort_crops( crop_record_t *crops )
+{
+    qsort( crops->t, crops->n, sizeof(crops->t[0]), compare_int );
+    qsort( crops->b, crops->n, sizeof(crops->t[0]), compare_int );
+    qsort( crops->l, crops->n, sizeof(crops->t[0]), compare_int );
+    qsort( crops->r, crops->n, sizeof(crops->t[0]), compare_int );
+}
+
+// -----------------------------------------------
+// stuff related to title width/height/aspect info
+
+typedef struct {
+    int count;              /* number of times we've seen this info entry */
+    hb_work_info_t info;    /* copy of info entry */
+} info_list_t;
+
+static void remember_info( info_list_t *info_list, hb_work_info_t *info )
+{
+    for ( ; info_list->count; ++info_list )
+    {
+        if ( memcmp( &info_list->info, info, sizeof(*info) ) == 0 )
+        {
+            // we found a match - bump its count
+            ++info_list->count;
+            return;
+        }
+    }
+    // no match found - add new entry to list (info_list points to
+    // the first free slot). NB - we assume that info_list was allocated
+    // so that it's big enough even if there are no dups. I.e., 10 slots
+    // allocated if there are 10 previews.
+    info_list->count = 1;
+    info_list->info = *info;
+}
+
+static void most_common_info( info_list_t *info_list, hb_work_info_t *info )
+{
+    int i, biggest = 0;
+    for ( i = 1; info_list[i].count; ++i )
+    {
+        if ( info_list[i].count > info_list[biggest].count )
+            biggest = i;
+    }
+    *info = info_list[biggest].info;
+    free( info_list );
+}
+
 /***********************************************************************
  * DecodePreviews
  ***********************************************************************
@@ -241,8 +396,8 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
     hb_list_t     * list_es;
     int progressive_count = 0;
     int interlaced_preview_count = 0;
-    double last_ar = 0;
-    int ar16_count = 0, ar4_count = 0;
+    info_list_t * info_list = calloc( 10+1, sizeof(*info_list) );
+    crop_record_t *crops = calloc( 1, sizeof(*crops) );
 
     buf_ps   = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
     list_es  = hb_list_init();
@@ -254,7 +409,7 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
 
     for( i = 0; i < 10; i++ )
     {
-        int j, k;
+        int j;
         FILE * file_preview;
         char   filename[1024];
 
@@ -339,39 +494,27 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
         /* Get size and rate infos */
 
         hb_work_info_t vid_info;
-        vid_decoder->info( vid_decoder, &vid_info );
+        if( !vid_decoder->info( vid_decoder, &vid_info ) )
+        {
+            /*
+             * Could not fill vid_info, don't continue and try to use vid_info
+             * in this case.
+             */
+            vid_decoder->close( vid_decoder );
+            free( vid_decoder );
+            continue;
+        }
         vid_decoder->close( vid_decoder );
         free( vid_decoder );
 
+        remember_info( info_list, &vid_info );
+
+        title->video_codec_name = strdup( vid_info.name );
         title->width = vid_info.width;
         title->height = vid_info.height;
         title->rate = vid_info.rate;
         title->rate_base = vid_info.rate_base;
-        if ( vid_info.aspect != 0 )
-        {
-            if ( vid_info.aspect != last_ar && last_ar != 0 )
-            {
-                hb_log( "aspect ratio changed from %g to %g",
-                        last_ar, vid_info.aspect );
-            }
-            switch ( (int)vid_info.aspect )
-            {
-                case HB_ASPECT_BASE * 4 / 3:
-                    ++ar4_count;
-                    break;
-                case HB_ASPECT_BASE * 16 / 9:
-                    ++ar16_count;
-                    break;
-                default:
-                    hb_log( "unknown aspect ratio %g", vid_info.aspect );
-                    /* if the aspect is closer to 4:3 use that
-                     * otherwise use 16:9 */
-                    vid_info.aspect < HB_ASPECT_BASE * 14 / 9 ? ++ar4_count :
-                                                                ++ar16_count;
-                    break;
-            }
-            last_ar = vid_info.aspect;
-        }
+        title->video_bitrate = vid_info.bitrate;
 
         if( title->rate_base == 1126125 )
         {
@@ -411,13 +554,6 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
             title->rate_base = 1126125;
         }
 
-        // start from third frame to skip opening logos
-        if( i == 2)
-        {
-            title->crop[0] = title->crop[1] = title->height / 2;
-            title->crop[2] = title->crop[3] = title->width / 2;
-        }
-
         while( ( buf_es = hb_list_item( list_es, 0 ) ) )
         {
             hb_list_rem( list_es, buf_es );
@@ -427,7 +563,7 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
         /* Check preview for interlacing artifacts */
         if( hb_detect_comb( vid_buf, title->width, title->height, 10, 30, 9, 10, 30, 9 ) )
         {
-            hb_log("Interlacing detected in preview frame %i", i);
+            hb_log("Interlacing detected in preview frame %i", i+1);
             interlaced_preview_count++;
         }
 
@@ -446,42 +582,75 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
             hb_log( "scan: fopen failed (%s)", filename );
         }
 
-#define Y    vid_buf->data
-#define DARK 64
-
         /* Detect black borders */
 
-        for( j = 0; j < title->width; j++ )
+#define Y    vid_buf->data
+        int top, bottom, left, right;
+        int h4 = title->height / 4, w4 = title->width / 4;
+
+        // When widescreen content is matted to 16:9 or 4:3 there's sometimes
+        // a thin border on the outer edge of the matte. On TV content it can be
+        // "line 21" VBI data that's normally hidden in the overscan. For HD
+        // content it can just be a diagnostic added in post production so that
+        // the frame borders are visible. We try to ignore these borders so
+        // we can crop the matte. The border width depends on the resolution
+        // (12 pixels on 1080i looks visually the same as 4 pixels on 480i)
+        // so we allow the border to be up to 1% of the frame height.
+        const int border = title->height / 100;
+
+        for ( top = border; top < h4; ++top )
         {
-            for( k = 2; k < title->crop[0]; k++ )
-                if( Y[ k * title->width + j ] > DARK )
-                {
-                    title->crop[0] = k;
-                    break;
-                }
-            for( k = 0; k < title->crop[1]; k++ )
-                if( Y[ ( title->height - k - 1 ) *
-                       title->width + j ] > DARK )
-                {
-                    title->crop[1] = k;
-                    break;
-                }
+            if ( ! row_all_dark( title, Y, top ) )
+                break;
         }
-        for( j = 0; j < title->height; j++ )
+        if ( top <= border )
         {
-            for( k = 0; k < title->crop[2]; k++ )
-                if( Y[ j * title->width + k ] > DARK )
-                {
-                    title->crop[2] = k;
+            // we never made it past the border region - see if the rows we
+            // didn't check are dark or if we shouldn't crop at all.
+            for ( top = 0; top < border; ++top )
+            {
+                if ( ! row_all_dark( title, Y, top ) )
                     break;
-                }
-            for( k = 0; k < title->crop[3]; k++ )
-                if( Y[ j * title->width +
-                        title->width - k - 1 ] > DARK )
-                {
-                    title->crop[3] = k;
+            }
+            if ( top >= border )
+            {
+                top = 0;
+            }
+        }
+        for ( bottom = border; bottom < h4; ++bottom )
+        {
+            if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
+                break;
+        }
+        if ( bottom <= border )
+        {
+            for ( bottom = 0; bottom < border; ++bottom )
+            {
+                if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
                     break;
-                }
+            }
+            if ( bottom >= border )
+            {
+                bottom = 0;
+            }
+        }
+        for ( left = 0; left < w4; ++left )
+        {
+            if ( ! column_all_dark( title, Y, top, bottom, left ) )
+                break;
+        }
+        for ( right = 0; right < w4; ++right )
+        {
+            if ( ! column_all_dark( title, Y, top, bottom, title->width - 1 - right ) )
+                break;
+        }
+
+        // only record the result if all the crops are less than a quarter of
+        // the frame otherwise we can get fooled by frames with a lot of black
+        // like titles, credits & fade-thru-black transitions.
+        if ( top < h4 && bottom < h4 && left < w4 && right < w4 )
+        {
+            record_crop( crops, top, bottom, left, right );
         }
         ++npreviews;
 
@@ -490,32 +659,79 @@ skip_preview:
             hb_buffer_close( &vid_buf );
     }
 
-    /* if we found mostly 4:3 previews use that as the aspect ratio otherwise
-       use 16:9 */
-    title->aspect = ar4_count > ar16_count ?
-                        HB_ASPECT_BASE * 4 / 3 : HB_ASPECT_BASE * 16 / 9;
+    if ( npreviews )
+    {
+        // use the most common frame info for our final title dimensions
+        hb_work_info_t vid_info;
+        most_common_info( info_list, &vid_info );
 
-    title->crop[0] = EVEN( title->crop[0] );
-    title->crop[1] = EVEN( title->crop[1] );
-    title->crop[2] = EVEN( title->crop[2] );
-    title->crop[3] = EVEN( title->crop[3] );
+        title->width = vid_info.width;
+        title->height = vid_info.height;
+        title->pixel_aspect_width = vid_info.pixel_aspect_width;
+        title->pixel_aspect_height = vid_info.pixel_aspect_height;
 
-    hb_log( "scan: %d previews, %dx%d, %.3f fps, autocrop = %d/%d/%d/%d, aspect %s",
-            npreviews, title->width, title->height, (float) title->rate /
-            (float) title->rate_base, title->crop[0], title->crop[1],
-            title->crop[2], title->crop[3],
-            title->aspect == HB_ASPECT_BASE * 16 / 9 ? "16:9" :
-                title->aspect == HB_ASPECT_BASE * 4 / 3 ? "4:3" : "none" );
+        // compute the aspect ratio based on the storage dimensions and the
+        // pixel aspect ratio (if supplied) or just storage dimensions if no PAR.
+        title->aspect = (double)title->width / (double)title->height;
+        if( title->pixel_aspect_width && title->pixel_aspect_height )
+        {
+            title->aspect *= (double)title->pixel_aspect_width /
+                             (double)title->pixel_aspect_height;
+
+            // For unknown reasons some French PAL DVDs put the original
+            // content's aspect ratio into the mpeg PAR even though it's
+            // the wrong PAR for the DVD. Apparently they rely on the fact
+            // that DVD players ignore the content PAR and just use the
+            // aspect ratio from the DVD metadata. So, if the aspect computed
+            // from the PAR is different from the container's aspect we use
+            // the container's aspect & recompute the PAR from it.
+            if( title->container_aspect && title->aspect != title->container_aspect )
+            {
+                hb_log("scan: content PAR gives wrong aspect %.2f; "
+                       "using container aspect %.2f", title->aspect,
+                       title->container_aspect );
+                title->aspect = title->container_aspect;
+                hb_reduce( &title->pixel_aspect_width, &title->pixel_aspect_height,
+                           (int)(title->aspect * title->height), title->width );
+            }
+        }
 
-    if( interlaced_preview_count >= ( npreviews / 2 ) )
-    {
-        hb_log("Title is likely interlaced or telecined (%i out of %i previews). You should do something about that.",
-               interlaced_preview_count, npreviews);
-        title->detected_interlacing = 1;
-    }
-    else
-    {
-        title->detected_interlacing = 0;
+        // don't try to crop unless we got at least 3 previews
+        if ( crops->n > 2 )
+        {
+            sort_crops( crops );
+            // The next line selects median cropping - at least
+            // 50% of the frames will have their borders removed.
+            // Other possible choices are loose cropping (i = 0) where 
+            // no non-black pixels will be cropped from any frame and a
+            // tight cropping (i = crops->n - (crops->n >> 2)) where at
+            // least 75% of the frames will have their borders removed.
+            i = crops->n >> 1;
+            title->crop[0] = EVEN( crops->t[i] );
+            title->crop[1] = EVEN( crops->b[i] );
+            title->crop[2] = EVEN( crops->l[i] );
+            title->crop[3] = EVEN( crops->r[i] );
+        }
+        free( crops );
+
+        hb_log( "scan: %d previews, %dx%d, %.3f fps, autocrop = %d/%d/%d/%d, "
+                "aspect %s, PAR %d:%d",
+                npreviews, title->width, title->height, (float) title->rate /
+                (float) title->rate_base,
+                title->crop[0], title->crop[1], title->crop[2], title->crop[3],
+                aspect_to_string( title->aspect ), title->pixel_aspect_width,
+                title->pixel_aspect_height );
+
+        if( interlaced_preview_count >= ( npreviews / 2 ) )
+        {
+            hb_log("Title is likely interlaced or telecined (%i out of %i previews). You should do something about that.",
+                   interlaced_preview_count, npreviews);
+            title->detected_interlacing = 1;
+        }
+        else
+        {
+            title->detected_interlacing = 0;
+        }
     }
 
     hb_buffer_close( &buf_ps );