X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fscan.c;h=eea1c3f0bf74d6d75423b50551446550b4f85fcf;hb=07cc0ebf6a7141a76fd9b6e2da6cf510def1ebc7;hp=265cfb2459a062222ceba5bcf29900da88de429f;hpb=4940aa576f1615beceaca5639899dbde5ab87d6a;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/scan.c b/libhb/scan.c index 265cfb24..eea1c3f0 100644 --- a/libhb/scan.c +++ b/libhb/scan.c @@ -26,18 +26,15 @@ 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( int aspect ) +static const char *aspect_to_string( double aspect ) { - switch ( aspect ) + switch ( (int)(aspect * 9.) ) { - case HB_ASPECT_BASE * 1 / 1: return "1:1"; - case HB_ASPECT_BASE * 4 / 3: return "4:3"; - case HB_ASPECT_BASE * 16 / 9: return "16:9"; - case HB_ASPECT_BASE * 221 / 100: return "2.21:1"; + case 9 * 4 / 3: return "4:3"; + case 9 * 16 / 9: return "16:9"; } static char arstr[32]; - double a = (double)aspect / HB_ASPECT_BASE; - sprintf( arstr, aspect >= 1.? "%.2f:1" : "1:%.2f", a ); + sprintf( arstr, aspect >= 1.? "%.2f:1" : "1:%.2f", aspect ); return arstr; } @@ -198,15 +195,11 @@ static void ScanFunc( void * _data ) job->pixel_aspect_height = title->pixel_aspect_height; } - if( title->aspect == 16 && !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, - 16 * title->height, 9 * title->width ); - } - else if( !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]; @@ -249,6 +242,110 @@ 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 */ @@ -300,6 +397,7 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) int progressive_count = 0; int interlaced_preview_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(); @@ -311,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]; @@ -396,16 +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; + title->video_bitrate = vid_info.bitrate; if( title->rate_base == 1126125 ) { @@ -445,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 ); @@ -480,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; @@ -537,21 +672,47 @@ skip_preview: // 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 + 0.05 ) * - HB_ASPECT_BASE; - - double aspect = (double)title->width / (double)title->height; + title->aspect = (double)title->width / (double)title->height; if( title->pixel_aspect_width && title->pixel_aspect_height ) { - aspect *= (double)title->pixel_aspect_width / - (double)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 ); + } } - title->aspect = ( aspect + 0.05 ) * HB_ASPECT_BASE; - 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] ); + // 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",