/* $Id: scan.c,v 1.52 2005/11/25 15:05:25 titer Exp $
This file is part of the HandBrake source code.
- Homepage: <http://handbrake.m0k.org/>.
+ Homepage: <http://handbrake.fr/>.
It may be used under the terms of the GNU General Public License. */
#include "hb.h"
typedef struct
{
hb_handle_t * h;
-
+
char * path;
int title_index;
hb_list_t * list_title;
-
+
hb_dvd_t * dvd;
hb_stream_t * stream;
-
+
} hb_scan_t;
static void ScanFunc( void * );
static int DecodePreviews( hb_scan_t *, hb_title_t * title );
-static void LookForAC3AndDCA( hb_title_t * title, hb_buffer_t * b );
-static int AllAC3AndDCAOK( 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 )
+{
+ switch ( aspect )
+ {
+ 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";
+ }
+ static char arstr[32];
+ double a = (double)aspect / HB_ASPECT_BASE;
+ sprintf( arstr, aspect >= 1.? "%.2f:1" : "1:%.2f", a );
+ return arstr;
+}
hb_thread_t * hb_scan_init( hb_handle_t * handle, const char * path,
int title_index, hb_list_t * list_title )
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 ) ) )
}
}
}
+ else if ( (data->stream = hb_stream_open( data->path, 0 ) ) != NULL )
+ {
+ hb_list_add( data->list_title, hb_stream_title_scan( data->stream ) );
+ }
else
{
- if ( hb_stream_is_stream_type(data->path) )
- {
- hb_log( "scan: trying to open as MPEG-2 Stream");
- data->stream = hb_stream_open (data->path);
- hb_list_add( data->list_title, hb_stream_title_scan( data->stream ) );
- }
- else
- {
- hb_log( "scan: unrecognized file type" );
- return;
- }
+ hb_log( "scan: unrecognized file type" );
+ return;
}
for( i = 0; i < hb_list_count( data->list_title ); )
hb_list_rem( data->list_title, title );
continue;
}
-
- if (data->stream)
- {
- // Stream based processing uses PID's to handle the different audio options for a given title
- for( j = 0; j < hb_list_count( title->list_audio ); j++ )
- {
- audio = hb_list_item( title->list_audio, j );
- hb_stream_update_audio(data->stream, audio);
- }
- }
- else if (data->dvd)
- {
- /* Make sure we found AC3 rates and bitrates */
- for( j = 0; j < hb_list_count( title->list_audio ); )
- {
- audio = hb_list_item( title->list_audio, j );
- if( audio->codec == HB_ACODEC_AC3 &&
- !audio->bitrate )
- {
- hb_list_rem( title->list_audio, audio );
- free( audio );
- continue;
- }
- j++;
- }
- }
-
- /* Make sure we found AC3 / DCA rates and bitrates */
+
+ /* Make sure we found audio rates and bitrates */
for( j = 0; j < hb_list_count( title->list_audio ); )
{
audio = hb_list_item( title->list_audio, j );
- if( ( audio->codec == HB_ACODEC_AC3 || audio->codec == HB_ACODEC_DCA ) &&
- !audio->bitrate )
+ if( !audio->config.in.bitrate )
{
- hb_log( "scan: removing audio with codec of 0x%x because of no bitrate",
- audio->codec );
+ hb_log( "scan: removing audio 0x%x because no bitrate found",
+ audio->id );
hb_list_rem( title->list_audio, audio );
free( audio );
continue;
j++;
}
- /* Do we still have audio */
+ /* If we don't have any audio streams left, remove the title */
if( !hb_list_count( title->list_audio ) )
{
hb_list_rem( data->list_title, title );
continue;
}
- /* set a default input channel layout of stereo for LPCM or MPEG2 audio */
- /* AC3 and DCA will already have had their layout set via DecodePreviews above, */
- /* which calls LookForAC3AndDCA */
- for( j = 0; j < hb_list_count( title->list_audio ); j++ )
- {
- audio = hb_list_item( title->list_audio, j );
- if( audio->codec == HB_ACODEC_LPCM || audio->codec == HB_ACODEC_MPGA )
- {
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- }
- }
-
i++;
}
/* Autocrop by default. Gnark gnark */
memcpy( job->crop, title->crop, 4 * sizeof( int ) );
- if( title->aspect == 16 )
+ /* 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;
+ }
+
+ if( title->aspect == 16 && !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
+ 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 );
}
job->width = title->width - job->crop[2] - job->crop[3];
-// job->height = title->height - job->crop[0] - job->crop[1];
hb_fix_aspect( job, HB_KEEP_WIDTH );
if( job->height > title->height - job->crop[0] - job->crop[1] )
{
hb_fix_aspect( job, HB_KEEP_HEIGHT );
}
- hb_log( "scan: title (%d) job->width:%d, job->height:%d",
- i,job->width, job->height );
+ hb_log( "scan: title (%d) job->width:%d, job->height:%d",
+ i, job->width, job->height );
job->keep_ratio = 1;
job->vrate = title->rate;
job->vrate_base = title->rate_base;
- job->audios[0] = 0;
- job->audios[1] = -1;
-
- job->acodec = HB_ACODEC_FAAC;
- job->abitrate = 128;
- job->arate = 44100;
+ job->list_audio = hb_list_init();
job->subtitle = -1;
_data = NULL;
}
+// -----------------------------------------------
+// stuff related to cropping
+
+#define DARK 64
+
+static int row_all_dark( hb_title_t *title, uint8_t* luma, int row )
+{
+ int i = title->width;
+ luma += i * row;
+ while ( --i >= 0 )
+ {
+ if ( *luma++ > DARK )
+ return 0;
+ }
+ return 1;
+}
+
+static int column_all_dark( hb_title_t *title, uint8_t* luma, int top, int col )
+{
+ int i = title->height - top;
+ int stride = title->width;
+ luma += stride * top + col;
+ for ( ; --i >= 0; luma += stride )
+ {
+ if ( *luma > DARK )
+ 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
***********************************************************************
**********************************************************************/
static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
{
- int i, ret;
- hb_buffer_t * buf_ps, * buf_es, * buf_raw;
- hb_list_t * list_es, * list_raw;
- hb_libmpeg2_t * mpeg2;
+ int i, npreviews = 0;
+ hb_buffer_t * buf_ps, * buf_es;
+ 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) );
+ crop_record_t *crops = calloc( 1, sizeof(*crops) );
+
buf_ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
list_es = hb_list_init();
- list_raw = hb_list_init();
hb_log( "scan: decoding previews for title %d", title->index );
if (data->dvd)
hb_dvd_start( data->dvd, title->index, 1 );
-
+
for( i = 0; i < 10; i++ )
{
- int j, k;
+ int j;
FILE * file_preview;
char filename[1024];
- //hb_log("Seeking to: %f", (float) ( i + 1 ) / 11.0 );
-
if (data->dvd)
{
if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / 11.0 ) )
{
- goto error;
+ continue;
}
}
else if (data->stream)
{
- if (!hb_stream_seek(data->stream, (float) ( i + 1 ) / 11.0 ) )
+ /* 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 ) )
{
- goto error;
+ continue;
}
}
-
+
hb_log( "scan: preview %d", i + 1 );
- mpeg2 = hb_libmpeg2_init();
+ 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->init( vid_decoder, NULL );
+ hb_buffer_t * vid_buf = NULL;
for( j = 0; j < 10240 ; j++ )
{
{
if( !hb_dvd_read( data->dvd, buf_ps ) )
{
- goto error;
+ hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
+ goto skip_preview;
}
}
else if (data->stream)
{
if ( !hb_stream_read(data->stream,buf_ps) )
{
- goto error;
+ hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
+ goto skip_preview;
}
}
- hb_demux_ps( buf_ps, list_es );
+ if ( title->demuxer == HB_NULL_DEMUXER )
+ {
+ hb_demux_null( buf_ps, list_es, 0 );
+ }
+ else
+ {
+ hb_demux_ps( buf_ps, list_es, 0 );
+ }
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_list_rem( list_es, buf_es );
- if( buf_es->id == 0xE0 && !hb_list_count( list_raw ) )
+ if( buf_es->id == title->video_id && vid_buf == NULL )
{
- hb_libmpeg2_decode( mpeg2, buf_es, list_raw );
+ vid_decoder->work( vid_decoder, &buf_es, &vid_buf );
}
- else if( !i )
- {
- LookForAC3AndDCA( title, buf_es );
- }
- hb_buffer_close( &buf_es );
-
- if( hb_list_count( list_raw ) &&
- ( i || AllAC3AndDCAOK( title ) ) )
+ else if( ! AllAudioOK( title ) )
{
- /* We got a picture */
- break;
+ LookForAudio( title, buf_es );
}
+ if ( buf_es )
+ hb_buffer_close( &buf_es );
}
- if( hb_list_count( list_raw ) &&
- ( i || AllAC3AndDCAOK( title ) ) )
- {
+ if( vid_buf && AllAudioOK( title ) )
break;
- }
}
- if( !hb_list_count( list_raw ) )
+ if( ! vid_buf )
{
hb_log( "scan: could not get a decoded picture" );
- goto error;
+ continue;
}
/* Get size and rate infos */
- title->rate = 27000000;
- int ar;
- hb_libmpeg2_info( mpeg2, &title->width, &title->height,
- &title->rate_base, &ar );
-
- if (title->rate_base == 1126125)
+
+ hb_work_info_t vid_info;
+ vid_decoder->info( vid_decoder, &vid_info );
+ vid_decoder->close( vid_decoder );
+ free( vid_decoder );
+
+ remember_info( info_list, &vid_info );
+
+ title->width = vid_info.width;
+ title->height = vid_info.height;
+ title->rate = vid_info.rate;
+ title->rate_base = vid_info.rate_base;
+
+ if( title->rate_base == 1126125 )
{
/* Frame FPS is 23.976 (meaning it's progressive), so
start keeping track of how many are reporting at
*/
progressive_count++;
- if (progressive_count < 6)
+ if( progressive_count < 6 )
+ {
/* Not enough frames are reporting as progressive,
which means we should be conservative and use
29.97 as the title's FPS for now.
*/
- title->rate_base = 900900;
+ title->rate_base = 900900;
+ }
else
{
/* A majority of the scan frames are progressive. Make that
the title's FPS, and announce it once to the log.
*/
- if (progressive_count == 6)
- hb_log("Title's mostly progressive NTSC, setting fps to 23.976");
- title->rate_base = 1126125;
+ if( progressive_count == 6 )
+ {
+ hb_log("Title's mostly NTSC Film, setting fps to 23.976");
+ }
+ title->rate_base = 1126125;
}
}
-
- if( i == 2) // Use the third frame's info, so as to skip opening logos
+ else if( title->rate_base == 900900 && progressive_count >= 6 )
{
- // The aspect ratio may have already been set by parsing the VOB/IFO details on a DVD, however
- // if we're working with program/transport streams that data needs to come from within the stream.
- if (title->aspect <= 0)
- title->aspect = ar;
- title->crop[0] = title->crop[1] = title->height / 2;
- title->crop[2] = title->crop[3] = title->width / 2;
+ /*
+ * We've already deduced that the frame rate is 23.976, so set it
+ * back again.
+ */
+ title->rate_base = 1126125;
}
- hb_libmpeg2_close( &mpeg2 );
-
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_list_rem( list_es, buf_es );
hb_buffer_close( &buf_es );
}
- buf_raw = hb_list_item( list_raw, 0 );
+ /* 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);
+ interlaced_preview_count++;
+ }
hb_get_tempory_filename( data->h, filename, "%x%d",
(intptr_t)title, i );
file_preview = fopen( filename, "w" );
if( file_preview )
{
- fwrite( buf_raw->data, title->width * title->height * 3 / 2,
+ fwrite( vid_buf->data, title->width * title->height * 3 / 2,
1, file_preview );
fclose( file_preview );
}
hb_log( "scan: fopen failed (%s)", filename );
}
-#define Y buf_raw->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;
+ for ( top = 2; top < h4; ++top )
{
- for( k = 0; 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 < 4 )
{
- for( k = 0; k < title->crop[2]; k++ )
- if( Y[ j * title->width + k ] > DARK )
- {
- title->crop[2] = k;
- break;
- }
- for( k = 0; k < title->crop[3]; k++ )
- if( Y[ j * title->width +
- title->width - k - 1 ] > DARK )
- {
- title->crop[3] = k;
- break;
- }
+ // we started at row two to avoid the "line 19" noise that shows
+ // up on row 0 & 1 of some TV shows. Since we stopped before row 4
+ // check if row 0 & 1 are dark or if we shouldn't crop the top at all.
+ if ( row_all_dark( title, Y, 0 ) )
+ {
+ top = row_all_dark( title, Y, 1 )? top : 1;
+ }
+ else
+ {
+ top = 0;
+ }
+ }
+ for ( bottom = 0; bottom < h4; ++bottom )
+ {
+ if ( ! row_all_dark( title, Y, title->height - 1 - bottom ) )
+ break;
+ }
+ for ( left = 0; left < w4; ++left )
+ {
+ if ( ! column_all_dark( title, Y, top, left ) )
+ break;
+ }
+ for ( right = 0; right < w4; ++right )
+ {
+ if ( ! column_all_dark( title, Y, top, title->width - 1 - right ) )
+ break;
}
- while( ( buf_raw = hb_list_item( list_raw, 0 ) ) )
+ // 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 )
{
- hb_list_rem( list_raw, buf_raw );
- hb_buffer_close( &buf_raw );
+ record_crop( crops, top, bottom, left, right );
}
+ ++npreviews;
+
+skip_preview:
+ if ( vid_buf )
+ hb_buffer_close( &vid_buf );
}
- 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] );
+ 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->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;
+
+ // 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;
+ if( title->pixel_aspect_width && title->pixel_aspect_height )
+ {
+ aspect *= (double)title->pixel_aspect_width /
+ (double)title->pixel_aspect_height;
+ }
+ title->aspect = ( aspect + 0.05 ) * HB_ASPECT_BASE;
- hb_log( "scan: %dx%d, %.3f fps, autocrop = %d/%d/%d/%d",
- title->width, title->height, (float) title->rate /
- (float) title->rate_base, title->crop[0], title->crop[1],
- title->crop[2], title->crop[3] );
+ if ( crops->n )
+ {
+ 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 );
- ret = 1;
- goto cleanup;
+ 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 );
-error:
- ret = 0;
+ 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;
+ }
+ }
-cleanup:
hb_buffer_close( &buf_ps );
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_buffer_close( &buf_es );
}
hb_list_close( &list_es );
- while( ( buf_raw = hb_list_item( list_raw, 0 ) ) )
- {
- hb_list_rem( list_raw, buf_raw );
- hb_buffer_close( &buf_raw );
- }
- hb_list_close( &list_raw );
if (data->dvd)
hb_dvd_stop( data->dvd );
- return ret;
+ return npreviews;
}
-static void LookForAC3AndDCA( hb_title_t * title, hb_buffer_t * b )
+/*
+ * This routine is called for every frame from a non-video elementary stream.
+ * These are a mix of audio & subtitle streams, some of which we want & some
+ * we're ignoring. This routine checks the frame against all our audio streams
+ * to see if it's one we want and haven't identified yet. If yes, it passes the
+ * frame to a codec-specific id routine which is responsible for filling in
+ * the sample rate, bit rate, channels & other audio parameters.
+ *
+ * Since a sample rate is essential for further audio processing, any audio
+ * stream which isn't successfully id'd by is deleted at the end of the scan.
+ * This is necessary to avoid ambiguities where things that might be audio
+ * aren't (e.g., some European DVD Teletext streams use the same IDs as US ATSC
+ * AC-3 audio).
+ */
+static void LookForAudio( hb_title_t * title, hb_buffer_t * b )
{
int i;
- int flags;
- int rate;
- int bitrate;
- int frame_length;
- dca_state_t * state;
- /* Figure out if this is a AC3 or DCA buffer for a known track */
hb_audio_t * audio = NULL;
for( i = 0; i < hb_list_count( title->list_audio ); i++ )
{
audio = hb_list_item( title->list_audio, i );
- /* check if we have an AC3 or DCA which we recognise */
- if( ( audio->codec == HB_ACODEC_AC3 || audio->codec == HB_ACODEC_DCA ) &&
- audio->id == b->id )
+ /* check if this elementary stream is one we want */
+ if ( audio->id == b->id )
{
break;
}
audio = NULL;
}
}
- if( !audio )
+ if( !audio || audio->config.in.bitrate != 0 )
{
+ /* not found or already done */
return;
}
- if( audio->bitrate )
+ hb_work_object_t *w = hb_codec_decoder( audio->config.in.codec );
+
+ if ( w == NULL || w->bsinfo == NULL )
{
- /* Already done for this track */
- return;
+ hb_log( "Internal error in scan: unhandled audio type %d for id 0x%x",
+ audio->config.in.codec, audio->id );
+ goto drop_audio;
}
- for( i = 0; i < b->size - 7; i++ )
+ hb_work_info_t info;
+ w->audio = audio;
+ w->codec_param = audio->config.in.codec_param;
+ int ret = w->bsinfo( w, b, &info );
+ if ( ret < 0 )
{
+ hb_log( "no info on audio type %d/0x%x for id 0x%x",
+ audio->config.in.codec, audio->config.in.codec_param,
+ audio->id );
+ goto drop_audio;
+ }
+ if ( !info.bitrate )
+ {
+ /* didn't find any info */
+ return;
+ }
+ audio->config.in.samplerate = info.rate;
+ audio->config.in.bitrate = info.bitrate;
+ audio->config.in.channel_layout = info.channel_layout;
+ audio->config.flags.ac3 = info.flags;
- if ( audio->codec == HB_ACODEC_AC3 )
- {
-
- /* check for a52 */
- if( a52_syncinfo( &b->data[i], &flags, &rate, &bitrate ) )
- {
- hb_log( "scan: AC3, rate=%dHz, bitrate=%d", rate, bitrate );
- audio->rate = rate;
- audio->bitrate = bitrate;
- switch( flags & A52_CHANNEL_MASK )
- {
- /* mono sources */
- case A52_MONO:
- case A52_CHANNEL1:
- case A52_CHANNEL2:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_MONO;
- break;
- /* stereo input */
- case A52_CHANNEL:
- case A52_STEREO:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- break;
- /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */
- case A52_DOLBY:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_DOLBY;
- break;
- /* 3F/2R input */
- case A52_3F2R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
- break;
- /* 3F/1R input */
- case A52_3F1R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
- break;
- /* other inputs */
- case A52_3F:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F;
- break;
- case A52_2F1R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
- break;
- case A52_2F2R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
- break;
- /* unknown */
- default:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- }
-
- /* add in our own LFE flag if the source has LFE */
- if (flags & A52_LFE)
- {
- audio->input_channel_layout = audio->input_channel_layout | HB_INPUT_CH_LAYOUT_HAS_LFE;
- }
-
- /* store the AC3 flags for future reference
- This enables us to find out if we had a stereo or Dolby source later on */
- audio->config.a52.ac3flags = flags;
-
- /* store the ac3 flags in the public ac3flags property too, so we can access it from the GUI */
- audio->ac3flags = audio->config.a52.ac3flags;
-
- /* XXX */
- if ( (flags & A52_CHANNEL_MASK) == A52_DOLBY ) {
- sprintf( audio->lang + strlen( audio->lang ),
- " (Dolby Surround)" );
- } else {
- sprintf( audio->lang + strlen( audio->lang ),
- " (%d.%d ch)",
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->input_channel_layout) +
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->input_channel_layout),
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->input_channel_layout));
- }
-
- break;
-
- }
-
- }
- else if ( audio->codec == HB_ACODEC_DCA )
- {
-
- hb_log( "scan: checking for DCA syncinfo" );
-
- /* check for dca */
- state = dca_init( 0 );
- if( dca_syncinfo( state, &b->data[i], &flags, &rate, &bitrate, &frame_length ) )
- {
- hb_log( "scan: DCA, rate=%dHz, bitrate=%d", rate, bitrate );
- audio->rate = rate;
- audio->bitrate = bitrate;
- switch( flags & DCA_CHANNEL_MASK )
- {
- /* mono sources */
- case DCA_MONO:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_MONO;
- break;
- /* stereo input */
- case DCA_CHANNEL:
- case DCA_STEREO:
- case DCA_STEREO_SUMDIFF:
- case DCA_STEREO_TOTAL:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- break;
- /* 3F/2R input */
- case DCA_3F2R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
- break;
- /* 3F/1R input */
- case DCA_3F1R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
- break;
- /* other inputs */
- case DCA_3F:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F;
- break;
- case DCA_2F1R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
- break;
- case DCA_2F2R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
- break;
- case DCA_4F2R:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_4F2R;
- break;
- /* unknown */
- default:
- audio->input_channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- }
-
- /* add in our own LFE flag if the source has LFE */
- if (flags & DCA_LFE)
- {
- audio->input_channel_layout = audio->input_channel_layout | HB_INPUT_CH_LAYOUT_HAS_LFE;
- }
-
- /* store the DCA flags for future reference
- This enables us to find out if we had a stereo or Dolby source later on */
- audio->config.dca.dcaflags = flags;
-
- /* store the dca flags in the public dcaflags property too, so we can access it from the GUI */
- audio->dcaflags = audio->config.dca.dcaflags;
-
- /* XXX */
- if ( (flags & DCA_CHANNEL_MASK) == DCA_DOLBY ) {
- sprintf( audio->lang + strlen( audio->lang ),
- " (Dolby Surround)" );
- } else {
- sprintf( audio->lang + strlen( audio->lang ),
- " (%d.%d ch)",
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->input_channel_layout) +
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->input_channel_layout),
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->input_channel_layout));
- }
-
- break;
- }
- }
+ // update the audio description string based on the info we found
+ if ( audio->config.flags.ac3 & AUDIO_F_DOLBY )
+ {
+ strcat( audio->config.lang.description, " (Dolby Surround)" );
+ }
+ else
+ {
+ int layout = audio->config.in.channel_layout;
+ char *desc = audio->config.lang.description +
+ strlen( audio->config.lang.description );
+ sprintf( desc, " (%d.%d ch)",
+ HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(layout) +
+ HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(layout),
+ HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(layout) );
}
+ hb_log( "scan: audio 0x%x: %s, rate=%dHz, bitrate=%d %s", audio->id,
+ info.name, audio->config.in.samplerate, audio->config.in.bitrate,
+ audio->config.lang.description );
+
+ free( w );
+ return;
+
+ // We get here if there's no hope of finding info on an audio bitstream,
+ // either because we don't have a decoder (or a decoder with a bitstream
+ // info proc) or because the decoder's info proc said that the stream
+ // wasn't something it could handle. Delete the item from the title's
+ // audio list so we won't keep reading packets while trying to get its
+ // bitstream info.
+ drop_audio:
+ if ( w )
+ free( w );
+
+ hb_list_rem( title->list_audio, audio );
}
-static int AllAC3AndDCAOK( hb_title_t * title )
+/*
+ * This routine checks to see if we've ID'd all the audio streams associated
+ * with a title. It returns 0 if there are more to ID & 1 if all are done.
+ */
+static int AllAudioOK( hb_title_t * title )
{
int i;
hb_audio_t * audio;
for( i = 0; i < hb_list_count( title->list_audio ); i++ )
{
audio = hb_list_item( title->list_audio, i );
- if( ( audio->codec == HB_ACODEC_AC3 || audio->codec == HB_ACODEC_DCA ) &&
- !audio->bitrate )
+ if( audio->config.in.bitrate == 0 )
{
return 0;
}
}
-
return 1;
}
OSDN Git Service
