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();
230 job->mux = HB_MUX_MP4;
235 hb_dvd_close( &data->dvd );
239 hb_stream_close(&data->stream);
246 // -----------------------------------------------
247 // stuff related to cropping
251 static inline int absdiff( int x, int y )
253 return x < y ? y - x : x - y;
256 static inline int clampBlack( int x )
258 // luma 'black' is 16 and anything less should be clamped at 16
259 return x < 16 ? 16 : x;
262 static int row_all_dark( hb_title_t *title, uint8_t* luma, int row )
264 luma += title->width * row;
266 // compute the average luma value of the row
268 for ( i = 0; i < title->width; ++i )
270 avg += clampBlack( luma[i] );
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 )
282 if ( absdiff( avg, clampBlack( luma[i] ) ) > 16 )
288 static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int bottom,
291 int stride = title->width;
292 int height = title->height - top - bottom;
293 luma += stride * top + col;
295 // compute the average value of the column
296 int i = height, avg = 0, row = 0;
297 for ( ; --i >= 0; row += stride )
299 avg += clampBlack( luma[row] );
305 // since we're trying to detect smooth borders, only take the column if
306 // all pixels are within +-16 of the average.
308 for ( ; --i >= 0; row += stride )
310 if ( absdiff( avg, clampBlack( luma[row] ) ) > 16 )
319 int t[HB_MAX_PREVIEWS];
320 int b[HB_MAX_PREVIEWS];
321 int l[HB_MAX_PREVIEWS];
322 int r[HB_MAX_PREVIEWS];
325 static void record_crop( crop_record_t *crops, int t, int b, int l, int r )
327 crops->t[crops->n] = t;
328 crops->b[crops->n] = b;
329 crops->l[crops->n] = l;
330 crops->r[crops->n] = r;
334 static int compare_int( const void *a, const void *b )
336 return *(const int *)a - *(const int *)b;
339 static void sort_crops( crop_record_t *crops )
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 );
347 // -----------------------------------------------
348 // stuff related to title width/height/aspect info
351 int count; /* number of times we've seen this info entry */
352 hb_work_info_t info; /* copy of info entry */
355 static void remember_info( info_list_t *info_list, hb_work_info_t *info )
357 for ( ; info_list->count; ++info_list )
359 if ( memcmp( &info_list->info, info, sizeof(*info) ) == 0 )
361 // we found a match - bump its count
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;
374 static void most_common_info( info_list_t *info_list, hb_work_info_t *info )
377 for ( i = 1; info_list[i].count; ++i )
379 if ( info_list[i].count > info_list[biggest].count )
382 *info = info_list[biggest].info;
386 /***********************************************************************
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 )
395 int i, npreviews = 0;
396 hb_buffer_t * buf_ps, * buf_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) );
403 buf_ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
404 list_es = hb_list_init();
406 hb_log( "scan: decoding previews for title %d", title->index );
409 hb_dvd_start( data->dvd, title->index, 1 );
411 for( i = 0; i < data->preview_count; i++ )
419 if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) )
424 else if (data->stream)
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 ) ) )
435 hb_deep_log( 2, "scan: preview %d", i + 1 );
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;
444 if ( title->flags & HBTF_NO_IDR )
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 )
454 vidskip = (double)title->rate / (double)title->rate_base + 0.5;
458 for( j = 0; j < 10240 ; j++ )
462 if( !hb_dvd_read( data->dvd, buf_ps ) )
468 hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
472 else if (data->stream)
474 if ( !hb_stream_read(data->stream,buf_ps) )
480 hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
484 (hb_demux[title->demuxer])(buf_ps, list_es, 0 );
486 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
488 hb_list_rem( list_es, buf_es );
489 if( buf_es->id == title->video_id && vid_buf == NULL )
491 vid_decoder->work( vid_decoder, &buf_es, &vid_buf );
492 if ( vid_buf && vidskip && --vidskip > 0 )
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 );
500 else if( ! AllAudioOK( title ) )
502 LookForAudio( title, buf_es );
505 hb_buffer_close( &buf_es );
508 if( vid_buf && AllAudioOK( title ) )
514 hb_log( "scan: could not get a decoded picture" );
518 /* Get size and rate infos */
520 hb_work_info_t vid_info;
521 if( !vid_decoder->info( vid_decoder, &vid_info ) )
524 * Could not fill vid_info, don't continue and try to use vid_info
527 vid_decoder->close( vid_decoder );
531 vid_decoder->close( vid_decoder );
534 remember_info( info_list, &vid_info );
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;
543 if( title->rate_base == 1126125 )
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.
552 if( progressive_count < 6 )
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.
558 title->rate_base = 900900;
562 /* A majority of the scan frames are progressive. Make that
563 the title's FPS, and announce it once to the log.
565 if( progressive_count == 6 )
567 hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976");
569 title->rate_base = 1126125;
572 else if( title->rate_base == 900900 && progressive_count >= 6 )
575 * We've already deduced that the frame rate is 23.976, so set it
578 title->rate_base = 1126125;
581 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
583 hb_list_rem( list_es, buf_es );
584 hb_buffer_close( &buf_es );
587 /* Check preview for interlacing artifacts */
588 if( hb_detect_comb( vid_buf, title->width, title->height, 10, 30, 9, 10, 30, 9 ) )
590 hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1);
591 interlaced_preview_count++;
594 if( data->store_previews )
596 hb_get_tempory_filename( data->h, filename, "%x%d",
597 (intptr_t)title, i );
599 file_preview = fopen( filename, "w" );
602 fwrite( vid_buf->data, title->width * title->height * 3 / 2,
604 fclose( file_preview );
608 hb_log( "scan: fopen failed (%s)", filename );
612 /* Detect black borders */
614 #define Y vid_buf->data
615 int top, bottom, left, right;
616 int h4 = title->height / 4, w4 = title->width / 4;
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;
628 for ( top = border; top < h4; ++top )
630 if ( ! row_all_dark( title, Y, top ) )
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 )
639 if ( ! row_all_dark( title, Y, top ) )
647 for ( bottom = border; bottom < h4; ++bottom )
649 if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
652 if ( bottom <= border )
654 for ( bottom = 0; bottom < border; ++bottom )
656 if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
659 if ( bottom >= border )
664 for ( left = 0; left < w4; ++left )
666 if ( ! column_all_dark( title, Y, top, bottom, left ) )
669 for ( right = 0; right < w4; ++right )
671 if ( ! column_all_dark( title, Y, top, bottom, title->width - 1 - right ) )
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 )
680 record_crop( crops, top, bottom, left, right );
686 hb_buffer_close( &vid_buf );
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 );
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;
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 )
705 title->aspect *= (double)title->pixel_aspect_width /
706 (double)title->pixel_aspect_height;
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) )
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 );
726 // don't try to crop unless we got at least 3 previews
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.
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] );
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 );
752 if( interlaced_preview_count >= ( npreviews / 2 ) )
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;
760 title->detected_interlacing = 0;
764 hb_buffer_close( &buf_ps );
765 while( ( buf_es = hb_list_item( list_es, 0 ) ) )
767 hb_list_rem( list_es, buf_es );
768 hb_buffer_close( &buf_es );
770 hb_list_close( &list_es );
772 hb_dvd_stop( data->dvd );
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.
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
791 static void LookForAudio( hb_title_t * title, hb_buffer_t * b )
795 hb_audio_t * audio = NULL;
796 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
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 )
809 if( !audio || audio->config.in.bitrate != 0 )
811 /* not found or already done */
815 hb_work_object_t *w = hb_codec_decoder( audio->config.in.codec );
817 if ( w == NULL || w->bsinfo == NULL )
819 hb_log( "Internal error in scan: unhandled audio type %d for id 0x%x",
820 audio->config.in.codec, audio->id );
826 w->codec_param = audio->config.in.codec_param;
827 int ret = w->bsinfo( w, b, &info );
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,
837 /* didn't find any info */
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;
847 // update the audio description string based on the info we found
848 if ( audio->config.flags.ac3 & AUDIO_F_DOLBY )
850 strcat( audio->config.lang.description, " (Dolby Surround)" );
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) );
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 );
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
880 hb_list_rem( title->list_audio, audio );
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.
887 static int AllAudioOK( hb_title_t * title )
892 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
894 audio = hb_list_item( title->list_audio, i );
895 if( audio->config.in.bitrate == 0 )