1 /* $Id: scan.c,v 1.52 2005/11/25 15:05:25 titer Exp $
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. */
8 #include "a52dec/a52.h"
11 #define HB_MAX_PREVIEWS 30 // 30 previews = every 5 minutes of a 2.5 hour video
19 hb_list_t * list_title;
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 );
34 static const char *aspect_to_string( double aspect )
36 switch ( (int)(aspect * 9.) )
38 case 9 * 4 / 3: return "4:3";
39 case 9 * 16 / 9: return "16:9";
41 static char arstr[32];
42 sprintf( arstr, aspect >= 1.? "%.2f:1" : "1:%.2f", aspect );
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 )
50 hb_scan_t * data = calloc( sizeof( hb_scan_t ), 1 );
53 data->path = strdup( path );
54 data->title_index = title_index;
55 data->list_title = list_title;
57 data->preview_count = preview_count;
58 data->store_previews = store_previews;
60 return hb_thread_init( "scan", ScanFunc, data, HB_NORMAL_PRIORITY );
63 static void ScanFunc( void * _data )
65 hb_scan_t * data = (hb_scan_t *) _data;
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 ) ) )
76 hb_log( "scan: DVD has %d title(s)",
77 hb_dvd_title_count( data->dvd ) );
78 if( data->title_index )
80 /* Scan this title only */
81 hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd,
82 data->title_index ) );
87 for( i = 0; i < hb_dvd_title_count( data->dvd ); i++ )
89 hb_list_add( data->list_title,
90 hb_dvd_title_scan( data->dvd, i + 1 ) );
94 else if ( (data->stream = hb_stream_open( data->path, 0 ) ) != NULL )
96 hb_list_add( data->list_title, hb_stream_title_scan( data->stream ) );
100 hb_log( "scan: unrecognized file type" );
104 for( i = 0; i < hb_list_count( data->list_title ); )
109 hb_title_t * title_tmp = NULL;
111 title = hb_list_item( data->list_title, i );
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++ )
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 )
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! */
139 #define p state.param.scanning
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 );
147 /* Decode previews */
148 /* this will also detect more AC3 / DTS information */
149 if( !DecodePreviews( data, title ) )
151 /* TODO: free things */
152 hb_list_rem( data->list_title, title );
156 /* Make sure we found audio rates and bitrates */
157 for( j = 0; j < hb_list_count( title->list_audio ); )
159 audio = hb_list_item( title->list_audio, j );
160 if( !audio->config.in.bitrate )
162 hb_log( "scan: removing audio 0x%x because no bitrate found",
164 hb_list_rem( title->list_audio, audio );
174 /* Init jobs templates */
175 for( i = 0; i < hb_list_count( data->list_title ); i++ )
179 title = hb_list_item( data->list_title, i );
180 job = calloc( sizeof( hb_job_t ), 1 );
185 /* Set defaults settings */
186 job->chapter_start = 1;
187 job->chapter_end = hb_list_count( title->list_chapter );
189 /* Autocrop by default. Gnark gnark */
190 memcpy( job->crop, title->crop, 4 * sizeof( int ) );
192 /* Preserve a source's pixel aspect, if it's available. */
193 if( title->pixel_aspect_width && title->pixel_aspect_height )
195 job->anamorphic.par_width = title->pixel_aspect_width;
196 job->anamorphic.par_height = title->pixel_aspect_height;
199 if( title->aspect != 0 && title->aspect != 1. &&
200 !job->anamorphic.par_width && !job->anamorphic.par_height)
202 hb_reduce( &job->anamorphic.par_width, &job->anamorphic.par_height,
203 (int)(title->aspect * title->height + 0.5), title->width );
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] )
210 job->height = title->height - job->crop[0] - job->crop[1];
211 hb_fix_aspect( job, HB_KEEP_HEIGHT );
214 hb_log( "scan: title (%d) job->width:%d, job->height:%d",
215 i, job->width, job->height );
219 job->vcodec = HB_VCODEC_FFMPEG;
220 job->vquality = -1.0;
221 job->vbitrate = 1000;
223 job->vrate = title->rate;
224 job->vrate_base = title->rate_base;
226 job->list_audio = hb_list_init();
227 job->list_subtitle = hb_list_init();
229 job->mux = HB_MUX_MP4;
234 hb_dvd_close( &data->dvd );
238 hb_stream_close(&data->stream);
245 // -----------------------------------------------
246 // stuff related to cropping
250 static inline int absdiff( int x, int y )
252 return x < y ? y - x : x - y;
255 static inline int clampBlack( int x )
257 // luma 'black' is 16 and anything less should be clamped at 16
258 return x < 16 ? 16 : x;
261 static int row_all_dark( hb_title_t *title, uint8_t* luma, int row )
263 luma += title->width * row;
265 // compute the average luma value of the row
267 for ( i = 0; i < title->width; ++i )
269 avg += clampBlack( luma[i] );
275 // since we're trying to detect smooth borders, only take the row if
276 // all pixels are within +-16 of the average (this range is fairly coarse
277 // but there's a lot of quantization noise for luma values near black
278 // so anything less will fail to crop because of the noise).
279 for ( i = 0; i < title->width; ++i )
281 if ( absdiff( avg, clampBlack( luma[i] ) ) > 16 )
287 static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int bottom,
290 int stride = title->width;
291 int height = title->height - top - bottom;
292 luma += stride * top + col;
294 // compute the average value of the column
295 int i = height, avg = 0, row = 0;
296 for ( ; --i >= 0; row += stride )
298 avg += clampBlack( luma[row] );
304 // since we're trying to detect smooth borders, only take the column if
305 // all pixels are within +-16 of the average.
307 for ( ; --i >= 0; row += stride )
309 if ( absdiff( avg, clampBlack( luma[row] ) ) > 16 )
318 int t[HB_MAX_PREVIEWS];
319 int b[HB_MAX_PREVIEWS];
320 int l[HB_MAX_PREVIEWS];
321 int r[HB_MAX_PREVIEWS];
324 static void record_crop( crop_record_t *crops, int t, int b, int l, int r )
326 crops->t[crops->n] = t;
327 crops->b[crops->n] = b;
328 crops->l[crops->n] = l;
329 crops->r[crops->n] = r;
333 static int compare_int( const void *a, const void *b )
335 return *(const int *)a - *(const int *)b;
338 static void sort_crops( crop_record_t *crops )
340 qsort( crops->t, crops->n, sizeof(crops->t[0]), compare_int );
341 qsort( crops->b, crops->n, sizeof(crops->t[0]), compare_int );
342 qsort( crops->l, crops->n, sizeof(crops->t[0]), compare_int );
343 qsort( crops->r, crops->n, sizeof(crops->t[0]), compare_int );
346 // -----------------------------------------------
347 // stuff related to title width/height/aspect info
350 int count; /* number of times we've seen this info entry */
351 hb_work_info_t info; /* copy of info entry */
354 static void remember_info( info_list_t *info_list, hb_work_info_t *info )
356 for ( ; info_list->count; ++info_list )
358 if ( memcmp( &info_list->info, info, sizeof(*info) ) == 0 )
360 // we found a match - bump its count
365 // no match found - add new entry to list (info_list points to
366 // the first free slot). NB - we assume that info_list was allocated
367 // so that it's big enough even if there are no dups. I.e., 10 slots
368 // allocated if there are 10 previews.
369 info_list->count = 1;
370 info_list->info = *info;
373 static void most_common_info( info_list_t *info_list, hb_work_info_t *info )
376 for ( i = 1; info_list[i].count; ++i )
378 if ( info_list[i].count > info_list[biggest].count )
381 *info = info_list[biggest].info;
385 /***********************************************************************
387 ***********************************************************************
388 * Decode 10 pictures for the given title.
389 * It assumes that data->reader and data->vts have successfully been
390 * DVDOpen()ed and ifoOpen()ed.
391 **********************************************************************/
392 static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
394 int i, npreviews = 0;
395 hb_buffer_t * buf_ps, * buf_es;
397 int progressive_count = 0;
398 int interlaced_preview_count = 0;
399 info_list_t * info_list = calloc( data->preview_count+1, sizeof(*info_list) );
400 crop_record_t *crops = calloc( 1, sizeof(*crops) );
402 buf_ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
403 list_es = hb_list_init();
405 hb_log( "scan: decoding previews for title %d", title->index );
409 hb_dvd_start( data->dvd, title, 1 );
410 title->angle_count = hb_dvd_angle_count( data->dvd );
411 hb_log( "scan: title angle(s) %d", title->angle_count );
414 for( i = 0; i < data->preview_count; i++ )
422 if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) )
427 else if (data->stream)
429 /* we start reading streams at zero rather than 1/11 because
430 * short streams may have only one sequence header in the entire
431 * file and we need it to decode any previews. */
432 if (!hb_stream_seek(data->stream, (float) i / ( data->preview_count + 1.0 ) ) )
438 hb_deep_log( 2, "scan: preview %d", i + 1 );
440 int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
441 hb_work_object_t *vid_decoder = hb_get_work( vcodec );
442 vid_decoder->codec_param = title->video_codec_param;
443 vid_decoder->title = title;
444 vid_decoder->init( vid_decoder, NULL );
445 hb_buffer_t * vid_buf = NULL;
448 if ( title->flags & HBTF_NO_IDR )
450 // title doesn't have IDR frames so we decode but drop one second's
451 // worth of frames to allow the decoder to converge.
452 if ( ! title->rate_base )
458 vidskip = (double)title->rate / (double)title->rate_base + 0.5;
462 for( j = 0; j < 10240 ; j++ )
466 if( !hb_dvd_read( data->dvd, buf_ps ) )
472 hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
476 else if (data->stream)
478 if ( !hb_stream_read(data->stream,buf_ps) )
484 hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
488 (hb_demux[title->demuxer])(buf_ps, list_es, 0 );
490 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
492 hb_list_rem( list_es, buf_es );
493 if( buf_es->id == title->video_id && vid_buf == NULL )
495 vid_decoder->work( vid_decoder, &buf_es, &vid_buf );
496 if ( vid_buf && vidskip && --vidskip > 0 )
498 // we're dropping frames to get the video decoder in sync
499 // when the video stream doesn't contain IDR frames
500 hb_buffer_close( &vid_buf );
504 else if( ! AllAudioOK( title ) )
506 LookForAudio( title, buf_es );
509 hb_buffer_close( &buf_es );
512 if( vid_buf && AllAudioOK( title ) )
518 hb_log( "scan: could not get a decoded picture" );
522 /* Get size and rate infos */
524 hb_work_info_t vid_info;
525 if( !vid_decoder->info( vid_decoder, &vid_info ) )
528 * Could not fill vid_info, don't continue and try to use vid_info
531 vid_decoder->close( vid_decoder );
535 vid_decoder->close( vid_decoder );
538 remember_info( info_list, &vid_info );
540 title->video_codec_name = strdup( vid_info.name );
541 title->width = vid_info.width;
542 title->height = vid_info.height;
543 title->rate = vid_info.rate;
544 title->rate_base = vid_info.rate_base;
545 title->video_bitrate = vid_info.bitrate;
547 if( title->rate_base == 1126125 )
549 /* Frame FPS is 23.976 (meaning it's progressive), so
550 start keeping track of how many are reporting at
551 that speed. When enough show up that way, we want
552 to make that the overall title FPS.
556 if( progressive_count < 6 )
558 /* Not enough frames are reporting as progressive,
559 which means we should be conservative and use
560 29.97 as the title's FPS for now.
562 title->rate_base = 900900;
566 /* A majority of the scan frames are progressive. Make that
567 the title's FPS, and announce it once to the log.
569 if( progressive_count == 6 )
571 hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976");
573 title->rate_base = 1126125;
576 else if( title->rate_base == 900900 && progressive_count >= 6 )
579 * We've already deduced that the frame rate is 23.976, so set it
582 title->rate_base = 1126125;
585 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
587 hb_list_rem( list_es, buf_es );
588 hb_buffer_close( &buf_es );
591 /* Check preview for interlacing artifacts */
592 if( hb_detect_comb( vid_buf, title->width, title->height, 10, 30, 9, 10, 30, 9 ) )
594 hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1);
595 interlaced_preview_count++;
598 if( data->store_previews )
600 hb_get_tempory_filename( data->h, filename, "%" PRIxPTR "%d",
601 (intptr_t)title, i );
603 file_preview = fopen( filename, "wb" );
606 fwrite( vid_buf->data, title->width * title->height * 3 / 2,
608 fclose( file_preview );
612 hb_log( "scan: fopen failed (%s)", filename );
616 /* Detect black borders */
618 #define Y vid_buf->data
619 int top, bottom, left, right;
620 int h4 = title->height / 4, w4 = title->width / 4;
622 // When widescreen content is matted to 16:9 or 4:3 there's sometimes
623 // a thin border on the outer edge of the matte. On TV content it can be
624 // "line 21" VBI data that's normally hidden in the overscan. For HD
625 // content it can just be a diagnostic added in post production so that
626 // the frame borders are visible. We try to ignore these borders so
627 // we can crop the matte. The border width depends on the resolution
628 // (12 pixels on 1080i looks visually the same as 4 pixels on 480i)
629 // so we allow the border to be up to 1% of the frame height.
630 const int border = title->height / 100;
632 for ( top = border; top < h4; ++top )
634 if ( ! row_all_dark( title, Y, top ) )
639 // we never made it past the border region - see if the rows we
640 // didn't check are dark or if we shouldn't crop at all.
641 for ( top = 0; top < border; ++top )
643 if ( ! row_all_dark( title, Y, top ) )
651 for ( bottom = border; bottom < h4; ++bottom )
653 if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
656 if ( bottom <= border )
658 for ( bottom = 0; bottom < border; ++bottom )
660 if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
663 if ( bottom >= border )
668 for ( left = 0; left < w4; ++left )
670 if ( ! column_all_dark( title, Y, top, bottom, left ) )
673 for ( right = 0; right < w4; ++right )
675 if ( ! column_all_dark( title, Y, top, bottom, title->width - 1 - right ) )
679 // only record the result if all the crops are less than a quarter of
680 // the frame otherwise we can get fooled by frames with a lot of black
681 // like titles, credits & fade-thru-black transitions.
682 if ( top < h4 && bottom < h4 && left < w4 && right < w4 )
684 record_crop( crops, top, bottom, left, right );
690 hb_buffer_close( &vid_buf );
695 // use the most common frame info for our final title dimensions
696 hb_work_info_t vid_info;
697 most_common_info( info_list, &vid_info );
699 title->width = vid_info.width;
700 title->height = vid_info.height;
701 title->pixel_aspect_width = vid_info.pixel_aspect_width;
702 title->pixel_aspect_height = vid_info.pixel_aspect_height;
704 // compute the aspect ratio based on the storage dimensions and the
705 // pixel aspect ratio (if supplied) or just storage dimensions if no PAR.
706 title->aspect = (double)title->width / (double)title->height;
707 if( title->pixel_aspect_width && title->pixel_aspect_height )
709 title->aspect *= (double)title->pixel_aspect_width /
710 (double)title->pixel_aspect_height;
712 // For unknown reasons some French PAL DVDs put the original
713 // content's aspect ratio into the mpeg PAR even though it's
714 // the wrong PAR for the DVD. Apparently they rely on the fact
715 // that DVD players ignore the content PAR and just use the
716 // aspect ratio from the DVD metadata. So, if the aspect computed
717 // from the PAR is different from the container's aspect we use
718 // the container's aspect & recompute the PAR from it.
719 if( title->container_aspect && (int)(title->aspect * 9) != (int)(title->container_aspect * 9) )
721 hb_log("scan: content PAR gives wrong aspect %.2f; "
722 "using container aspect %.2f", title->aspect,
723 title->container_aspect );
724 title->aspect = title->container_aspect;
725 hb_reduce( &title->pixel_aspect_width, &title->pixel_aspect_height,
726 (int)(title->aspect * title->height + 0.5), title->width );
730 // don't try to crop unless we got at least 3 previews
734 // The next line selects median cropping - at least
735 // 50% of the frames will have their borders removed.
736 // Other possible choices are loose cropping (i = 0) where
737 // no non-black pixels will be cropped from any frame and a
738 // tight cropping (i = crops->n - (crops->n >> 2)) where at
739 // least 75% of the frames will have their borders removed.
741 title->crop[0] = EVEN( crops->t[i] );
742 title->crop[1] = EVEN( crops->b[i] );
743 title->crop[2] = EVEN( crops->l[i] );
744 title->crop[3] = EVEN( crops->r[i] );
748 hb_log( "scan: %d previews, %dx%d, %.3f fps, autocrop = %d/%d/%d/%d, "
749 "aspect %s, PAR %d:%d",
750 npreviews, title->width, title->height, (float) title->rate /
751 (float) title->rate_base,
752 title->crop[0], title->crop[1], title->crop[2], title->crop[3],
753 aspect_to_string( title->aspect ), title->pixel_aspect_width,
754 title->pixel_aspect_height );
756 if( interlaced_preview_count >= ( npreviews / 2 ) )
758 hb_log("Title is likely interlaced or telecined (%i out of %i previews). You should do something about that.",
759 interlaced_preview_count, npreviews);
760 title->detected_interlacing = 1;
764 title->detected_interlacing = 0;
768 hb_buffer_close( &buf_ps );
769 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
771 hb_list_rem( list_es, buf_es );
772 hb_buffer_close( &buf_es );
774 hb_list_close( &list_es );
776 hb_dvd_stop( data->dvd );
782 * This routine is called for every frame from a non-video elementary stream.
783 * These are a mix of audio & subtitle streams, some of which we want & some
784 * we're ignoring. This routine checks the frame against all our audio streams
785 * to see if it's one we want and haven't identified yet. If yes, it passes the
786 * frame to a codec-specific id routine which is responsible for filling in
787 * the sample rate, bit rate, channels & other audio parameters.
789 * Since a sample rate is essential for further audio processing, any audio
790 * stream which isn't successfully id'd by is deleted at the end of the scan.
791 * This is necessary to avoid ambiguities where things that might be audio
792 * aren't (e.g., some European DVD Teletext streams use the same IDs as US ATSC
795 static void LookForAudio( hb_title_t * title, hb_buffer_t * b )
799 hb_audio_t * audio = NULL;
800 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
802 audio = hb_list_item( title->list_audio, i );
803 /* check if this elementary stream is one we want */
804 if ( audio->id == b->id )
813 if( !audio || audio->config.in.bitrate != 0 )
815 /* not found or already done */
819 hb_work_object_t *w = hb_codec_decoder( audio->config.in.codec );
821 if ( w == NULL || w->bsinfo == NULL )
823 hb_log( "Internal error in scan: unhandled audio type %d for id 0x%x",
824 audio->config.in.codec, audio->id );
830 w->codec_param = audio->config.in.codec_param;
831 int ret = w->bsinfo( w, b, &info );
834 hb_log( "no info on audio type %d/0x%x for id 0x%x",
835 audio->config.in.codec, audio->config.in.codec_param,
841 /* didn't find any info */
844 audio->config.in.samplerate = info.rate;
845 audio->config.in.bitrate = info.bitrate;
846 audio->config.in.channel_layout = info.channel_layout;
847 audio->config.in.version = info.version;
848 audio->config.in.mode = info.mode;
849 audio->config.flags.ac3 = info.flags;
851 // update the audio description string based on the info we found
852 if ( audio->config.flags.ac3 & AUDIO_F_DOLBY )
854 strcat( audio->config.lang.description, " (Dolby Surround)" );
858 int layout = audio->config.in.channel_layout;
859 char *desc = audio->config.lang.description +
860 strlen( audio->config.lang.description );
861 sprintf( desc, " (%d.%d ch)",
862 HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(layout) +
863 HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(layout),
864 HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(layout) );
867 hb_log( "scan: audio 0x%x: %s, rate=%dHz, bitrate=%d %s", audio->id,
868 info.name, audio->config.in.samplerate, audio->config.in.bitrate,
869 audio->config.lang.description );
874 // We get here if there's no hope of finding info on an audio bitstream,
875 // either because we don't have a decoder (or a decoder with a bitstream
876 // info proc) or because the decoder's info proc said that the stream
877 // wasn't something it could handle. Delete the item from the title's
878 // audio list so we won't keep reading packets while trying to get its
884 hb_list_rem( title->list_audio, audio );
888 * This routine checks to see if we've ID'd all the audio streams associated
889 * with a title. It returns 0 if there are more to ID & 1 if all are done.
891 static int AllAudioOK( hb_title_t * title )
896 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
898 audio = hb_list_item( title->list_audio, i );
899 if( audio->config.in.bitrate == 0 )