X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fscan.c;h=445314bcd8695ee5faf7e717a59e23e888c1a8b0;hb=4b72a63eb61a01275493c4bfb51ba02152d1c5e1;hp=960332dfc204a120edc79a1d02ea6a164f39a90b;hpb=cb5b4d38b6d195d8fe790618be9c359c96b27e1f;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/scan.c b/libhb/scan.c index 960332df..445314bc 100644 --- a/libhb/scan.c +++ b/libhb/scan.c @@ -8,16 +8,26 @@ #include "a52dec/a52.h" #include "dca.h" +#define HB_MAX_PREVIEWS 30 // 30 previews = every 5 minutes of a 2.5 hour video + typedef struct { - hb_handle_t * h; + hb_handle_t * h; + volatile int * die; + + char * path; + int title_index; + hb_list_t * list_title; + + hb_bd_t * bd; + hb_dvd_t * dvd; + hb_stream_t * stream; + hb_batch_t * batch; - char * path; - int title_index; - hb_list_t * list_title; + int preview_count; + int store_previews; - hb_dvd_t * dvd; - hb_stream_t * stream; + uint64_t min_title_duration; } hb_scan_t; @@ -26,31 +36,35 @@ 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; } -hb_thread_t * hb_scan_init( hb_handle_t * handle, const char * path, - int title_index, hb_list_t * list_title ) +hb_thread_t * hb_scan_init( hb_handle_t * handle, volatile int * die, + const char * path, int title_index, + hb_list_t * list_title, int preview_count, + int store_previews, uint64_t min_duration ) { hb_scan_t * data = calloc( sizeof( hb_scan_t ), 1 ); data->h = handle; + data->die = die; data->path = strdup( path ); data->title_index = title_index; data->list_title = list_title; - + + data->preview_count = preview_count; + data->store_previews = store_previews; + data->min_title_duration = min_duration; + return hb_thread_init( "scan", ScanFunc, data, HB_NORMAL_PRIORITY ); } @@ -59,13 +73,35 @@ static void ScanFunc( void * _data ) hb_scan_t * data = (hb_scan_t *) _data; hb_title_t * title; int i; + int feature = 0; - data->dvd = NULL; - data->stream = NULL; + data->bd = NULL; + data->dvd = NULL; + data->stream = NULL; /* Try to open the path as a DVD. If it fails, try as a file */ - hb_log( "scan: trying to open with libdvdread" ); - if( ( data->dvd = hb_dvd_init( data->path ) ) ) + if( ( data->bd = hb_bd_init( data->path ) ) ) + { + hb_log( "scan: BD has %d title(s)", + hb_bd_title_count( data->bd ) ); + if( data->title_index ) + { + /* Scan this title only */ + hb_list_add( data->list_title, hb_bd_title_scan( data->bd, + data->title_index, 0 ) ); + } + else + { + /* Scan all titles */ + for( i = 0; i < hb_bd_title_count( data->bd ); i++ ) + { + hb_list_add( data->list_title, hb_bd_title_scan( data->bd, + i + 1, data->min_title_duration ) ); + } + feature = hb_bd_main_feature( data->bd, data->list_title ); + } + } + else if( ( data->dvd = hb_dvd_init( data->path ) ) ) { hb_log( "scan: DVD has %d title(s)", hb_dvd_title_count( data->dvd ) ); @@ -73,15 +109,42 @@ static void ScanFunc( void * _data ) { /* Scan this title only */ hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd, - data->title_index ) ); + data->title_index, 0 ) ); } else { /* Scan all titles */ for( i = 0; i < hb_dvd_title_count( data->dvd ); i++ ) { - hb_list_add( data->list_title, - hb_dvd_title_scan( data->dvd, i + 1 ) ); + hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd, + i + 1, data->min_title_duration ) ); + } + feature = hb_dvd_main_feature( data->dvd, data->list_title ); + } + } + else if ( ( data->batch = hb_batch_init( data->path ) ) ) + { + if( data->title_index ) + { + /* Scan this title only */ + title = hb_batch_title_scan( data->batch, data->title_index ); + if ( title ) + { + hb_list_add( data->list_title, title ); + } + } + else + { + /* Scan all titles */ + for( i = 0; i < hb_batch_title_count( data->batch ); i++ ) + { + hb_title_t * title; + + title = hb_batch_title_scan( data->batch, i + 1 ); + if ( title != NULL ) + { + hb_list_add( data->list_title, title ); + } } } } @@ -100,41 +163,20 @@ static void ScanFunc( void * _data ) int j; hb_state_t state; hb_audio_t * audio; - hb_title_t * title_tmp = NULL; - title = hb_list_item( data->list_title, i ); - - /* I've seen a DVD with strictly identical titles. Check this - here and ignore it if redundant */ - for( j = 0; j < i; j++ ) - { - title_tmp = hb_list_item( data->list_title, j ); - if( title->vts == title_tmp->vts && - title->block_start == title_tmp->block_start && - title->block_end == title_tmp->block_end && - title->block_count == title_tmp->block_count ) - { - break; - } - else - { - title_tmp = NULL; - } - } - if( title_tmp ) + if ( *data->die ) { - hb_log( "scan: title %d is duplicate with title %d", - title->index, title_tmp->index ); - hb_list_rem( data->list_title, title ); - free( title ); /* This _will_ leak! */ - continue; + goto finish; } + title = hb_list_item( data->list_title, i ); #define p state.param.scanning /* Update the UI */ state.state = HB_STATE_SCANNING; p.title_cur = title->index; - p.title_count = data->dvd ? hb_dvd_title_count( data->dvd ) : hb_list_count(data->list_title); + p.title_count = data->dvd ? hb_dvd_title_count( data->dvd ) : + data->bd ? hb_bd_title_count( data->bd ) : + hb_list_count(data->list_title); hb_set_state( data->h, &state ); #undef p @@ -159,17 +201,30 @@ static void ScanFunc( void * _data ) free( audio ); continue; } + if ( audio->priv.scan_cache ) + { + hb_fifo_flush( audio->priv.scan_cache ); + hb_fifo_close( &audio->priv.scan_cache ); + } j++; } - /* If we don't have any audio streams left, remove the title */ - if( !hb_list_count( title->list_audio ) ) + if ( data->dvd || data->bd ) { - hb_list_rem( data->list_title, title ); - free( title ); - continue; + // The subtitle width and height needs to be set to the + // title widht and height for DVDs. title width and + // height don't get set until we decode previews, so + // we can't set subtitle width/height till we get here. + for( j = 0; j < hb_list_count( title->list_subtitle ); j++ ) + { + hb_subtitle_t *subtitle = hb_list_item( title->list_subtitle, j ); + if ( subtitle->source == VOBSUB ) + { + subtitle->width = title->width; + subtitle->height = title->height; + } + } } - i++; } @@ -183,6 +238,7 @@ static void ScanFunc( void * _data ) title->job = job; job->title = title; + job->feature = feature; /* Set defaults settings */ job->chapter_start = 1; @@ -194,19 +250,15 @@ static void ScanFunc( void * _data ) /* Preserve a source's pixel aspect, if it's available. */ if( title->pixel_aspect_width && title->pixel_aspect_height ) { - job->pixel_aspect_width = title->pixel_aspect_width; - job->pixel_aspect_height = title->pixel_aspect_height; + job->anamorphic.par_width = title->pixel_aspect_width; + job->anamorphic.par_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->anamorphic.par_width && !job->anamorphic.par_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 ); + hb_reduce( &job->anamorphic.par_width, &job->anamorphic.par_height, + (int)(title->aspect * title->height + 0.5), title->width ); } job->width = title->width - job->crop[2] - job->crop[3]; @@ -230,20 +282,29 @@ static void ScanFunc( void * _data ) job->vrate_base = title->rate_base; job->list_audio = hb_list_init(); - - job->subtitle = -1; + job->list_subtitle = hb_list_init(); job->mux = HB_MUX_MP4; } +finish: + + if( data->bd ) + { + hb_bd_close( &data->bd ); + } if( data->dvd ) { hb_dvd_close( &data->dvd ); } - if (data->stream) - { - hb_stream_close(&data->stream); - } + if (data->stream) + { + hb_stream_close(&data->stream); + } + if( data->batch ) + { + hb_batch_close( &data->batch ); + } free( data->path ); free( data ); _data = NULL; @@ -291,24 +352,26 @@ static int row_all_dark( hb_title_t *title, uint8_t* luma, int row ) return 1; } -static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int col ) +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 = title->height - top, avg = 0, row = 0; + int i = height, avg = 0, row = 0; for ( ; --i >= 0; row += stride ) { avg += clampBlack( luma[row] ); } - avg /= title->height - top; + 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 = title->height - top, row = 0; + i = height, row = 0; for ( ; --i >= 0; row += stride ) { if ( absdiff( avg, clampBlack( luma[row] ) ) > 16 ) @@ -320,10 +383,10 @@ static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int col ) typedef struct { int n; - int t[10]; - int b[10]; - int l[10]; - int r[10]; + int t[HB_MAX_PREVIEWS]; + int b[HB_MAX_PREVIEWS]; + int l[HB_MAX_PREVIEWS]; + int r[HB_MAX_PREVIEWS]; } crop_record_t; static void record_crop( crop_record_t *crops, int t, int b, int l, int r ) @@ -401,7 +464,7 @@ 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; - info_list_t * info_list = calloc( 10+1, sizeof(*info_list) ); + info_list_t * info_list = calloc( data->preview_count+1, sizeof(*info_list) ); crop_record_t *crops = calloc( 1, sizeof(*crops) ); buf_ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE ); @@ -409,18 +472,42 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) hb_log( "scan: decoding previews for title %d", title->index ); - if (data->dvd) - hb_dvd_start( data->dvd, title->index, 1 ); + if (data->bd) + { + hb_bd_start( data->bd, title ); + hb_log( "scan: title angle(s) %d", title->angle_count ); + } + else if (data->dvd) + { + hb_dvd_start( data->dvd, title, 1 ); + title->angle_count = hb_dvd_angle_count( data->dvd ); + hb_log( "scan: title angle(s) %d", title->angle_count ); + } + else if (data->batch) + { + data->stream = hb_stream_open( title->path, title ); + } - for( i = 0; i < 10; i++ ) + for( i = 0; i < data->preview_count; i++ ) { int j; FILE * file_preview; char filename[1024]; + if ( *data->die ) + { + return 0; + } + if (data->bd) + { + if( !hb_bd_seek( data->bd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) ) + { + continue; + } + } if (data->dvd) { - if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / 11.0 ) ) + if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) ) { continue; } @@ -430,26 +517,62 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) /* we start reading streams at zero rather than 1/11 because * short streams may have only one sequence header in the entire * file and we need it to decode any previews. */ - if (!hb_stream_seek(data->stream, (float) i / 11.0 ) ) + if (!hb_stream_seek(data->stream, (float) i / ( data->preview_count + 1.0 ) ) ) { continue; } } - hb_log( "scan: preview %d", i + 1 ); + hb_deep_log( 2, "scan: preview %d", i + 1 ); int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2; hb_work_object_t *vid_decoder = hb_get_work( vcodec ); vid_decoder->codec_param = title->video_codec_param; + vid_decoder->title = title; vid_decoder->init( vid_decoder, NULL ); hb_buffer_t * vid_buf = NULL; + int vidskip = 0; + + if ( title->flags & HBTF_NO_IDR ) + { + // title doesn't have IDR frames so we decode but drop one second's + // worth of frames to allow the decoder to converge. + if ( ! title->rate_base ) + { + vidskip = 30; + } + else + { + vidskip = (double)title->rate / (double)title->rate_base + 0.5; + } + // If it's a BD, we can relax this a bit. Since seeks will + // at least get us to a recovery point. + if (data->bd) + vidskip = 4; + } for( j = 0; j < 10240 ; j++ ) { + if (data->bd) + { + if( !hb_bd_read( data->bd, buf_ps ) ) + { + if ( vid_buf ) + { + break; + } + hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 ); + goto skip_preview; + } + } if (data->dvd) { if( !hb_dvd_read( data->dvd, buf_ps ) ) { + if ( vid_buf ) + { + break; + } hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 ); goto skip_preview; } @@ -458,18 +581,15 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) { if ( !hb_stream_read(data->stream,buf_ps) ) { + if ( vid_buf ) + { + break; + } hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 ); goto skip_preview; } } - if ( title->demuxer == HB_NULL_DEMUXER ) - { - hb_demux_null( buf_ps, list_es, 0 ); - } - else - { - hb_demux_ps( buf_ps, list_es, 0 ); - } + (hb_demux[title->demuxer])(buf_ps, list_es, 0 ); while( ( buf_es = hb_list_item( list_es, 0 ) ) ) { @@ -477,10 +597,23 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) if( buf_es->id == title->video_id && vid_buf == NULL ) { vid_decoder->work( vid_decoder, &buf_es, &vid_buf ); + if ( vid_buf && vidskip && --vidskip > 0 ) + { + // we're dropping frames to get the video decoder in sync + // when the video stream doesn't contain IDR frames + while (vid_buf && --vidskip >= 0) + { + hb_buffer_t * next = vid_buf->next; + vid_buf->next = NULL; + hb_buffer_close( &vid_buf ); + vid_buf = next; + } + } } - else if( ! AllAudioOK( title ) ) + else if( ! AllAudioOK( title ) ) { LookForAudio( title, buf_es ); + buf_es = NULL; } if ( buf_es ) hb_buffer_close( &buf_es ); @@ -499,16 +632,31 @@ 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. + */ + if (vid_buf) + { + hb_buffer_close( &vid_buf ); + } + 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 ) { @@ -534,7 +682,7 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) */ if( progressive_count == 6 ) { - hb_log("Title's mostly NTSC Film, setting fps to 23.976"); + hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976"); } title->rate_base = 1126125; } @@ -557,23 +705,26 @@ 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+1); + hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1); interlaced_preview_count++; } - - hb_get_tempory_filename( data->h, filename, "%x%d", - (intptr_t)title, i ); - - file_preview = fopen( filename, "w" ); - if( file_preview ) + + if( data->store_previews ) { - fwrite( vid_buf->data, title->width * title->height * 3 / 2, - 1, file_preview ); - fclose( file_preview ); - } - else - { - hb_log( "scan: fopen failed (%s)", filename ); + hb_get_tempory_filename( data->h, filename, "%d_%d_%d", + hb_get_instance_id(data->h), title->index, i ); + + file_preview = fopen( filename, "wb" ); + if( file_preview ) + { + fwrite( vid_buf->data, title->width * title->height * 3 / 2, + 1, file_preview ); + fclose( file_preview ); + } + else + { + hb_log( "scan: fopen failed (%s)", filename ); + } } /* Detect black borders */ @@ -581,39 +732,61 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) #define Y vid_buf->data int top, bottom, left, right; int h4 = title->height / 4, w4 = title->width / 4; - for ( top = 4; top < h4; ++top ) + + // 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 ) { if ( ! row_all_dark( title, Y, top ) ) break; } - if ( top < 5 ) + if ( top <= border ) { - // we started at row 4 to avoid the "line 21" noise that shows - // up on row 0 & 1 of some TV shows. Since we stopped before row 4 - // check if the missed rows are dark or if we shouldn't crop at all. - for ( top = 0; top < 4; ++top ) + // 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; } - if ( top >= 4 ) + if ( top >= border ) { top = 0; } } - for ( bottom = 0; bottom < h4; ++bottom ) + 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, left ) ) + if ( ! column_all_dark( title, Y, top, bottom, left ) ) break; } for ( right = 0; right < w4; ++right ) { - if ( ! column_all_dark( title, Y, top, title->width - 1 - right ) ) + if ( ! column_all_dark( title, Y, top, bottom, title->width - 1 - right ) ) break; } @@ -627,8 +800,24 @@ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) ++npreviews; skip_preview: - if ( vid_buf ) + /* Make sure we found audio rates and bitrates */ + for( j = 0; j < hb_list_count( title->list_audio ); j++ ) + { + hb_audio_t * audio = hb_list_item( title->list_audio, j ); + if ( audio->priv.scan_cache ) + { + hb_fifo_flush( audio->priv.scan_cache ); + } + } + if (vid_buf) + { hb_buffer_close( &vid_buf ); + } + } + + if ( data->batch && data->stream ) + { + hb_stream_close( &data->stream ); } if ( npreviews ) @@ -644,16 +833,29 @@ 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 && (int)(title->aspect * 9) != (int)(title->container_aspect * 9) ) + { + 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 + 0.5), title->width ); + } } - title->aspect = ( aspect + 0.05 ) * HB_ASPECT_BASE; // don't try to crop unless we got at least 3 previews if ( crops->n > 2 ) @@ -700,6 +902,8 @@ skip_preview: hb_buffer_close( &buf_es ); } hb_list_close( &list_es ); + if (data->bd) + hb_bd_stop( data->bd ); if (data->dvd) hb_dvd_stop( data->dvd ); @@ -741,9 +945,21 @@ static void LookForAudio( hb_title_t * title, hb_buffer_t * b ) if( !audio || audio->config.in.bitrate != 0 ) { /* not found or already done */ + hb_buffer_close( &b ); return; } + if ( audio->priv.scan_cache == NULL ) + audio->priv.scan_cache = hb_fifo_init( 16, 16 ); + + if ( hb_fifo_size_bytes( audio->priv.scan_cache ) >= 4096 ) + { + hb_buffer_t * tmp; + tmp = hb_fifo_get( audio->priv.scan_cache ); + hb_buffer_close( &tmp ); + } + hb_fifo_push( audio->priv.scan_cache, b ); + hb_work_object_t *w = hb_codec_decoder( audio->config.in.codec ); if ( w == NULL || w->bsinfo == NULL ) @@ -756,6 +972,7 @@ static void LookForAudio( hb_title_t * title, hb_buffer_t * b ) hb_work_info_t info; w->audio = audio; w->codec_param = audio->config.in.codec_param; + b = hb_fifo_see( audio->priv.scan_cache ); int ret = w->bsinfo( w, b, &info ); if ( ret < 0 ) { @@ -769,9 +986,14 @@ static void LookForAudio( hb_title_t * title, hb_buffer_t * b ) /* didn't find any info */ return; } + hb_fifo_flush( audio->priv.scan_cache ); + hb_fifo_close( &audio->priv.scan_cache ); + audio->config.in.samplerate = info.rate; audio->config.in.bitrate = info.bitrate; audio->config.in.channel_layout = info.channel_layout; + audio->config.in.version = info.version; + audio->config.in.mode = info.mode; audio->config.flags.ac3 = info.flags; // update the audio description string based on the info we found @@ -807,7 +1029,10 @@ static void LookForAudio( hb_title_t * title, hb_buffer_t * b ) if ( w ) free( w ); + hb_fifo_flush( audio->priv.scan_cache ); + hb_fifo_close( &audio->priv.scan_cache ); hb_list_rem( title->list_audio, audio ); + return; } /*