/***********************************************************************
* DecodePreviews
***********************************************************************
* Decode 10 pictures for the given title.
* It assumes that data->reader and data->vts have successfully been
* DVDOpen()ed and ifoOpen()ed.
**********************************************************************/
static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
{
int i, npreviews = 0;
hb_buffer_t * buf, * buf_es;
hb_list_t * list_es;
int progressive_count = 0;
int pulldown_count = 0;
int doubled_frame_count = 0;
int interlaced_preview_count = 0;
info_list_t * info_list = calloc( data->preview_count+1, sizeof(*info_list) );
crop_record_t *crops = crop_record_init( data->preview_count );
list_es = hb_list_init();
if( data->batch )
{
hb_log( "scan: decoding previews for title %d (%s)", title->index, title->path );
}
else
{
hb_log( "scan: decoding previews for title %d", title->index );
}
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, 1 );
}
if (title->video_codec == WORK_NONE)
{
hb_error("No video decoder set!");
return 0;
}
hb_work_object_t *vid_decoder = hb_get_work(title->video_codec);
vid_decoder->codec_param = title->video_codec_param;
vid_decoder->title = title;
vid_decoder->init( vid_decoder, NULL );
for( i = 0; i < data->preview_count; i++ )
{
int j;
UpdateState3(data, i + 1);
if ( *data->die )
{
free( info_list );
crop_record_free( crops );
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 ) / ( data->preview_count + 1.0 ) ) )
{
continue;
}
}
else if (data->stream)
{
/* 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 / ( data->preview_count + 1.0 ) ) )
{
continue;
}
}
hb_deep_log( 2, "scan: preview %d", i + 1 );
if ( vid_decoder->flush )
vid_decoder->flush( vid_decoder );
hb_buffer_t * vid_buf = NULL;
for( j = 0; j < 10240 ; j++ )
{
if (data->bd)
{
if( (buf = hb_bd_read( data->bd )) == NULL )
{
if ( vid_buf )
{
break;
}
hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
goto skip_preview;
}
}
else if (data->dvd)
{
if( (buf = hb_dvd_read( data->dvd )) == NULL )
{
if ( vid_buf )
{
break;
}
hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
goto skip_preview;
}
}
else if (data->stream)
{
if ( (buf = hb_stream_read( data->stream )) == NULL )
{
if ( vid_buf )
{
break;
}
hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 );
goto skip_preview;
}
}
else
{
// Silence compiler warning
buf = NULL;
hb_error( "Error: This can't happen!" );
goto skip_preview;
}
(hb_demux[title->demuxer])(buf, list_es, 0 );
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_list_rem( list_es, buf_es );
if( buf_es->s.id == title->video_id && vid_buf == NULL )
{
vid_decoder->work( vid_decoder, &buf_es, &vid_buf );
}
else if( ! AllAudioOK( title ) )
{
LookForAudio( title, buf_es );
buf_es = NULL;
}
if ( buf_es )
hb_buffer_close( &buf_es );
}
if( vid_buf && AllAudioOK( title ) )
break;
}
if( ! vid_buf )
{
hb_log( "scan: could not get a decoded picture" );
continue;
}
/* Get size and rate infos */
hb_work_info_t 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 );
}
hb_log( "scan: could not get a video information" );
continue;
}
remember_info( info_list, &vid_info );
if( is_close_to( vid_info.rate_base, 900900, 100 ) &&
( vid_buf->s.flags & PIC_FLAG_REPEAT_FIRST_FIELD ) )
{
/* Potentially soft telecine material */
pulldown_count++;
}
if( vid_buf->s.flags & PIC_FLAG_REPEAT_FRAME )
{
// AVCHD-Lite specifies that all streams are
// 50 or 60 fps. To produce 25 or 30 fps, camera
// makers are repeating all frames.
doubled_frame_count++;
}
if( is_close_to( vid_info.rate_base, 1126125, 100 ) )
{
// Frame FPS is 23.976 (meaning it's progressive), so start keeping
// track of how many are reporting at that speed. When enough
// show up that way, we want to make that the overall title FPS.
progressive_count++;
}
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_list_rem( list_es, buf_es );
hb_buffer_close( &buf_es );
}
/* Check preview for interlacing artifacts */
if( hb_detect_comb( vid_buf, 10, 30, 9, 10, 30, 9 ) )
{
hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1);
interlaced_preview_count++;
}
if( data->store_previews )
{
hb_save_preview( data->h, title->index, i, vid_buf );
}
/* Detect black borders */
int top, bottom, left, right;
int h4 = vid_info.height / 4, w4 = vid_info.width / 4;
// When widescreen content is matted to 16:9 or 4:3 there's sometimes
// a thin border on the outer edge of the matte. On TV content it can be
// "line 21" VBI data that's normally hidden in the overscan. For HD
// content it can just be a diagnostic added in post production so that
// the frame borders are visible. We try to ignore these borders so
// we can crop the matte. The border width depends on the resolution
// (12 pixels on 1080i looks visually the same as 4 pixels on 480i)
// so we allow the border to be up to 1% of the frame height.
const int border = vid_info.height / 100;
for ( top = border; top < h4; ++top )
{
if ( ! row_all_dark( vid_buf, top ) )
break;
}
if ( top <= border )
{
// 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( vid_buf, top ) )
break;
}
if ( top >= border )
{
top = 0;
}
}
for ( bottom = border; bottom < h4; ++bottom )
{
if ( ! row_all_dark( vid_buf, vid_info.height - 1 - bottom ) )
break;
}
if ( bottom <= border )
{
for ( bottom = 0; bottom < border; ++bottom )
{
if ( ! row_all_dark( vid_buf, vid_info.height - 1 - bottom ) )
break;
}
if ( bottom >= border )
{
bottom = 0;
}
}
for ( left = 0; left < w4; ++left )
{
if ( ! column_all_dark( vid_buf, top, bottom, left ) )
break;
}
for ( right = 0; right < w4; ++right )
{
if ( ! column_all_dark( vid_buf, top, bottom, vid_info.width - 1 - right ) )
break;
}
// only record the result if all the crops are less than a quarter of
// the frame otherwise we can get fooled by frames with a lot of black
// like titles, credits & fade-thru-black transitions.
if ( top < h4 && bottom < h4 && left < w4 && right < w4 )
{
record_crop( crops, top, bottom, left, right );
}
++npreviews;
skip_preview:
/* 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 );
}
}
UpdateState3(data, i);
vid_decoder->close( vid_decoder );
free( vid_decoder );
if ( data->batch && data->stream )
{
hb_stream_close( &data->stream );
}
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->has_resolution_change = has_resolution_change( info_list );
if ( title->video_codec_name == NULL )
{
title->video_codec_name = strdup( vid_info.name );
}
title->width = vid_info.width;
title->height = vid_info.height;
if ( vid_info.rate && vid_info.rate_base )
{
// if the frame rate is very close to one of our "common" framerates,
// assume it actually is said frame rate; e.g. some 24000/1001 sources
// may have a rate_base of 1126124 (instead of 1126125)
const hb_rate_t *video_framerate = NULL;
while ((video_framerate = hb_video_framerate_get_next(video_framerate)) != NULL)
{
if (is_close_to(vid_info.rate_base, video_framerate->rate, 100))
{
vid_info.rate_base = video_framerate->rate;
break;
}
}
title->rate = vid_info.rate;
title->rate_base = vid_info.rate_base;
if( vid_info.rate_base == 900900 )
{
if( npreviews >= 4 && pulldown_count >= npreviews / 4 )
{
title->rate_base = 1126125;
hb_deep_log( 2, "Pulldown detected, setting fps to 23.976" );
}
if( npreviews >= 2 && progressive_count >= npreviews / 2 )
{
// We've already deduced that the frame rate is 23.976,
// so set it back again.
title->rate_base = 1126125;
hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976" );
}
}
if( npreviews >= 2 && doubled_frame_count >= 3 * npreviews / 4 )
{
// We've detected that a significant number of the frames
// have been doubled in duration by repeat flags.
title->rate_base = 2 * vid_info.rate_base;
hb_deep_log( 2, "Repeat frames detected, setting fps to %.3f", (float)title->rate / title->rate_base );
}
}
title->video_bitrate = vid_info.bitrate;
if( vid_info.pixel_aspect_width && vid_info.pixel_aspect_height )
{
title->pixel_aspect_width = vid_info.pixel_aspect_width;
title->pixel_aspect_height = vid_info.pixel_aspect_height;
}
title->color_prim = vid_info.color_prim;
title->color_transfer = vid_info.color_transfer;
title->color_matrix = vid_info.color_matrix;
title->video_decode_support = vid_info.video_decode_support;
// TODO: check video dimensions
title->opencl_support = !!hb_opencl_available();
// 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;
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 );
}
// don't try to crop unless we got at least 3 previews
if ( crops->n > 2 )
{
sort_crops( crops );
// The next line selects median cropping - at least
// 50% of the frames will have their borders removed.
// Other possible choices are loose cropping (i = 0) where
// no non-black pixels will be cropped from any frame and a
// tight cropping (i = crops->n - (crops->n >> 2)) where at
// least 75% of the frames will have their borders removed.
i = crops->n >> 1;
title->crop[0] = EVEN( crops->t[i] );
title->crop[1] = EVEN( crops->b[i] );
title->crop[2] = EVEN( crops->l[i] );
title->crop[3] = EVEN( crops->r[i] );
}
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 );
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;
}
}
/***********************************************************************
* hb_work_encfaac_init
***********************************************************************
*
**********************************************************************/
int encfaacInit( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
hb_audio_t * audio = w->audio;
faacEncConfigurationPtr cfg;
uint8_t * bytes;
unsigned long length;
w->private_data = pv;
pv->job = job;
/* pass the number of channels used into the private work data */
pv->out_discrete_channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
/* if the sample rate is 'auto' and that has given us an invalid output */
/* rate, map it to the next highest output rate or 48K if above the highest. */
int rate_index = find_samplerate(audio->config.out.samplerate);
if ( audio->config.out.samplerate != valid_rates[rate_index] )
{
int rate = valid_rates[valid_rates[rate_index]? rate_index : rate_index - 1];
hb_log( "encfaac changing output samplerate from %d to %d",
audio->config.out.samplerate, rate );
audio->config.out.samplerate = rate;
/* if the new rate is over the max bandwidth per channel limit */
/* lower the bandwidth. */
double bw = audio->config.out.bitrate * 1000 / pv->out_discrete_channels;
if ( bw > (double)rate * (6144./1024.) )
{
int newbr = (double)rate * (6.144/1024.) * pv->out_discrete_channels;
hb_log( "encfaac changing output bitrate from %d to %d",
audio->config.out.bitrate, newbr );
audio->config.out.bitrate = newbr;
}
}
pv->faac = faacEncOpen( audio->config.out.samplerate, pv->out_discrete_channels,
&pv->input_samples, &pv->output_bytes );
pv->buf = malloc( pv->input_samples * sizeof( float ) );
pv->obuf = malloc( pv->output_bytes );
pv->framedur = 90000.0 * pv->input_samples /
( audio->config.out.samplerate * pv->out_discrete_channels );
audio->config.out.samples_per_frame = pv->input_samples / pv->out_discrete_channels;
cfg = faacEncGetCurrentConfiguration( pv->faac );
cfg->mpegVersion = MPEG4;
cfg->aacObjectType = LOW;
cfg->allowMidside = 1;
if (pv->out_discrete_channels == 6) {
/* we are preserving 5.1 audio into 6-channel AAC,
so indicate that we have an lfe channel */
cfg->useLfe = 1;
} else {
cfg->useLfe = 0;
}
cfg->useTns = 0;
cfg->bitRate = audio->config.out.bitrate * 1000 / pv->out_discrete_channels; /* Per channel */
cfg->bandWidth = 0;
cfg->outputFormat = 0;
cfg->inputFormat = FAAC_INPUT_FLOAT;
if( ( audio->config.out.mixdown == HB_AMIXDOWN_6CH ) && ( audio->config.in.channel_map != &hb_qt_chan_map ) )
{
if( audio->config.in.channel_map == &hb_ac3_chan_map )
{
cfg->channel_map[0] = 2;
cfg->channel_map[1] = 1;
cfg->channel_map[2] = 3;
cfg->channel_map[3] = 4;
cfg->channel_map[4] = 5;
cfg->channel_map[5] = 0;
}
else if( audio->config.in.channel_map == &hb_smpte_chan_map )
{
cfg->channel_map[0] = 2;
cfg->channel_map[1] = 0;
cfg->channel_map[2] = 1;
cfg->channel_map[3] = 4;
cfg->channel_map[4] = 5;
cfg->channel_map[5] = 3;
}
}
if( !faacEncSetConfiguration( pv->faac, cfg ) )
{
hb_log( "faacEncSetConfiguration failed" );
*job->die = 1;
return 0;
}
if( faacEncGetDecoderSpecificInfo( pv->faac, &bytes, &length ) < 0 )
{
hb_log( "faacEncGetDecoderSpecificInfo failed" );
*job->die = 1;
return 0;
}
memcpy( w->config->extradata.bytes, bytes, length );
w->config->extradata.length = length;
free( bytes );
pv->list = hb_list_init();
return 0;
}
/***********************************************************************
* ReaderFunc
***********************************************************************
*
**********************************************************************/
void ReadLoop( void * _w )
{
hb_work_object_t * w = _w;
hb_work_private_t * r = w->private_data;
hb_fifo_t ** fifos;
hb_buffer_t * buf;
hb_list_t * list;
int n;
int chapter = -1;
int chapter_end = r->job->chapter_end;
if (r->bd)
{
if( !hb_bd_start( r->bd, r->title ) )
{
hb_bd_close( &r->bd );
return;
}
if ( r->job->start_at_preview )
{
// XXX code from DecodePreviews - should go into its own routine
hb_bd_seek( r->bd, (float)r->job->start_at_preview /
( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
}
else if ( r->job->pts_to_start )
{
// Note, bd seeks always put us to an i-frame. no need
// to start decoding early using r->pts_to_start
hb_bd_seek_pts( r->bd, r->job->pts_to_start );
r->job->pts_to_start = 0;
r->start_found = 1;
}
else
{
hb_bd_seek_chapter( r->bd, r->job->chapter_start );
}
if (r->job->angle > 1)
{
hb_bd_set_angle( r->bd, r->job->angle - 1 );
}
}
else if (r->dvd)
{
/*
* XXX this code is a temporary hack that should go away if/when
* chapter merging goes away in libhb/dvd.c
* map the start and end chapter numbers to on-media chapter
* numbers since chapter merging could cause the handbrake numbers
* to diverge from the media numbers and, if our chapter_end is after
* a media chapter that got merged, we'll stop ripping too early.
*/
int start = r->job->chapter_start;
hb_chapter_t *chap = hb_list_item( r->title->list_chapter, chapter_end - 1 );
chapter_end = chap->index;
if (start > 1)
{
chap = hb_list_item( r->title->list_chapter, start - 1 );
start = chap->index;
}
/* end chapter mapping XXX */
if( !hb_dvd_start( r->dvd, r->title, start ) )
{
hb_dvd_close( &r->dvd );
return;
}
if (r->job->angle)
{
hb_dvd_set_angle( r->dvd, r->job->angle );
}
if ( r->job->start_at_preview )
{
// XXX code from DecodePreviews - should go into its own routine
hb_dvd_seek( r->dvd, (float)r->job->start_at_preview /
( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
}
}
else if ( r->stream && r->job->start_at_preview )
{
// XXX code from DecodePreviews - should go into its own routine
hb_stream_seek( r->stream, (float)( r->job->start_at_preview - 1 ) /
( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
}
else if ( r->stream && r->job->pts_to_start )
{
int64_t pts_to_start = r->job->pts_to_start;
// Find out what the first timestamp of the stream is
// and then seek to the appropriate offset from it
if ( ( buf = hb_stream_read( r->stream ) ) )
{
if ( buf->start > 0 )
{
pts_to_start += buf->start;
r->pts_to_start += buf->start;
r->job->pts_to_start += buf->start;
}
}
if ( hb_stream_seek_ts( r->stream, pts_to_start ) >= 0 )
{
// Seek takes us to the nearest I-frame before the timestamp
// that we want. So we will retrieve the start time of the
// first packet we get, subtract that from pts_to_start, and
// inspect the reset of the frames in sync.
r->start_found = 2;
r->job->pts_to_start = pts_to_start;
}
}
else if( r->stream )
{
/*
* Standard stream, seek to the starting chapter, if set, and track the
* end chapter so that we end at the right time.
*/
int start = r->job->chapter_start;
hb_chapter_t *chap = hb_list_item( r->title->list_chapter, chapter_end - 1 );
chapter_end = chap->index;
if (start > 1)
{
chap = hb_list_item( r->title->list_chapter, start - 1 );
start = chap->index;
}
/*
* Seek to the start chapter.
*/
hb_stream_seek_chapter( r->stream, start );
}
list = hb_list_init();
while( !*r->die && !r->job->done )
{
if (r->bd)
chapter = hb_bd_chapter( r->bd );
else if (r->dvd)
chapter = hb_dvd_chapter( r->dvd );
else if (r->stream)
chapter = hb_stream_chapter( r->stream );
if( chapter < 0 )
{
hb_log( "reader: end of the title reached" );
break;
}
if( chapter > chapter_end )
{
hb_log( "reader: end of chapter %d (media %d) reached at media chapter %d",
r->job->chapter_end, chapter_end, chapter );
break;
}
if (r->bd)
{
if( (buf = hb_bd_read( r->bd )) == NULL )
{
break;
}
}
else if (r->dvd)
{
if( (buf = hb_dvd_read( r->dvd )) == NULL )
{
break;
}
}
else if (r->stream)
{
if ( (buf = hb_stream_read( r->stream )) == NULL )
{
break;
}
if ( r->start_found == 2 )
{
// We will inspect the timestamps of each frame in sync
// to skip from this seek point to the timestamp we
// want to start at.
if ( buf->start > 0 && buf->start < r->job->pts_to_start )
{
r->job->pts_to_start -= buf->start;
}
else if ( buf->start >= r->job->pts_to_start )
{
r->job->pts_to_start = 0;
r->start_found = 1;
}
}
}
if( r->job->indepth_scan )
{
/*
* Need to update the progress during a subtitle scan
*/
hb_state_t state;
#define p state.param.working
state.state = HB_STATE_WORKING;
p.progress = (double)chapter / (double)r->job->chapter_end;
if( p.progress > 1.0 )
{
p.progress = 1.0;
}
p.rate_avg = 0.0;
p.hours = -1;
p.minutes = -1;
p.seconds = -1;
hb_set_state( r->job->h, &state );
}
(hb_demux[r->title->demuxer])( buf, list, &r->demux );
while( ( buf = hb_list_item( list, 0 ) ) )
{
hb_list_rem( list, buf );
fifos = GetFifoForId( r->job, buf->id );
if ( fifos && ! r->saw_video && !r->job->indepth_scan )
{
// The first data packet with a PTS from an audio or video stream
// that we're decoding defines 'time zero'. Discard packets until
// we get one.
if ( buf->start != -1 && buf->renderOffset != -1 &&
( buf->id == r->title->video_id || is_audio( r, buf->id ) ) )
{
// force a new scr offset computation
r->scr_changes = r->demux.scr_changes - 1;
// create a stream state if we don't have one so the
// offset will get computed correctly.
id_to_st( r, buf, 1 );
r->saw_video = 1;
hb_log( "reader: first SCR %"PRId64" id 0x%x DTS %"PRId64,
r->demux.last_scr, buf->id, buf->renderOffset );
}
else
{
fifos = NULL;
}
}
if( fifos )
{
if ( buf->renderOffset != -1 )
{
if ( r->scr_changes != r->demux.scr_changes )
{
// This is the first audio or video packet after an SCR
// change. Compute a new scr offset that would make this
// packet follow the last of this stream with the
// correct average spacing.
stream_timing_t *st = id_to_st( r, buf, 0 );
// if this is the video stream and we don't have
// audio yet or this is an audio stream
// generate a new scr
if ( st->is_audio ||
( st == r->stream_timing && !r->saw_audio ) )
{
new_scr_offset( r, buf );
}
else
{
// defer the scr change until we get some
// audio since audio has a timestamp per
// frame but video & subtitles don't. Clear
// the timestamps so the decoder will generate
// them from the frame durations.
buf->start = -1;
buf->renderOffset = -1;
}
}
}
if ( buf->start != -1 )
{
int64_t start = buf->start - r->scr_offset;
if ( !r->start_found )
UpdateState( r, start );
if ( !r->start_found &&
start >= r->pts_to_start )
{
// pts_to_start point found
r->start_found = 1;
}
// This log is handy when you need to debug timing problems
//hb_log("id %x scr_offset %ld start %ld --> %ld",
// buf->id, r->scr_offset, buf->start,
// buf->start - r->scr_offset);
buf->start -= r->scr_offset;
}
if ( buf->renderOffset != -1 )
{
// This packet is referenced to the same SCR as the last.
// Adjust timestamp to remove the System Clock Reference
// offset then update the average inter-packet time
// for this stream.
buf->renderOffset -= r->scr_offset;
update_ipt( r, buf );
}
else
{
update_ipt( r, buf );
}
if ( !r->start_found )
{
hb_buffer_close( &buf );
continue;
}
buf->sequence = r->sequence++;
/* if there are mutiple output fifos, send a copy of the
* buffer down all but the first (we have to not ship the
* original buffer or we'll race with the thread that's
* consuming the buffer & inject garbage into the data stream). */
for( n = 1; fifos[n] != NULL; n++)
{
hb_buffer_t *buf_copy = hb_buffer_init( buf->size );
hb_buffer_copy_settings( buf_copy, buf );
memcpy( buf_copy->data, buf->data, buf->size );
push_buf( r, fifos[n], buf_copy );
}
push_buf( r, fifos[0], buf );
}
else
{
hb_buffer_close( &buf );
}
}
}
// send empty buffers downstream to video & audio decoders to signal we're done.
if( !*r->die && !r->job->done )
{
push_buf( r, r->job->fifo_mpeg2, hb_buffer_init(0) );
hb_audio_t *audio;
for( n = 0; (audio = hb_list_item( r->job->title->list_audio, n)); ++n )
{
if ( audio->priv.fifo_in )
push_buf( r, audio->priv.fifo_in, hb_buffer_init(0) );
}
hb_subtitle_t *subtitle;
for( n = 0; (subtitle = hb_list_item( r->job->title->list_subtitle, n)); ++n )
{
if ( subtitle->fifo_in && subtitle->source == VOBSUB)
push_buf( r, subtitle->fifo_in, hb_buffer_init(0) );
}
}
hb_list_empty( &list );
hb_log( "reader: done. %d scr changes", r->demux.scr_changes );
if ( r->demux.dts_drops )
{
hb_log( "reader: %d drops because DTS out of range", r->demux.dts_drops );
}
}
/***********************************************************************
* hb_work_encCoreAudio_init
***********************************************************************
*
**********************************************************************/
int encCoreAudioInit(hb_work_object_t *w, hb_job_t *job, enum AAC_MODE mode)
{
hb_work_private_t *pv = calloc(1, sizeof(hb_work_private_t));
hb_audio_t *audio = w->audio;
AudioStreamBasicDescription input, output;
UInt32 tmp, tmpsiz = sizeof(tmp);
OSStatus err;
w->private_data = pv;
pv->job = job;
// pass the number of channels used into the private work data
pv->nchannels =
hb_mixdown_get_discrete_channel_count(audio->config.out.mixdown);
bzero(&input, sizeof(AudioStreamBasicDescription));
input.mSampleRate = (Float64)audio->config.out.samplerate;
input.mFormatID = kAudioFormatLinearPCM;
input.mFormatFlags = (kLinearPCMFormatFlagIsFloat|kAudioFormatFlagsNativeEndian);
input.mBytesPerPacket = 4 * pv->nchannels;
input.mFramesPerPacket = 1;
input.mBytesPerFrame = input.mBytesPerPacket * input.mFramesPerPacket;
input.mChannelsPerFrame = pv->nchannels;
input.mBitsPerChannel = 32;
bzero(&output, sizeof(AudioStreamBasicDescription));
switch (mode)
{
case AAC_MODE_HE:
output.mFormatID = kAudioFormatMPEG4AAC_HE;
break;
case AAC_MODE_LC:
default:
output.mFormatID = kAudioFormatMPEG4AAC;
break;
}
output.mSampleRate = (Float64)audio->config.out.samplerate;
output.mChannelsPerFrame = pv->nchannels;
// let CoreAudio decide the rest
// initialise encoder
err = AudioConverterNew(&input, &output, &pv->converter);
if (err != noErr)
{
// Retry without the samplerate
bzero(&output, sizeof(AudioStreamBasicDescription));
switch (mode)
{
case AAC_MODE_HE:
output.mFormatID = kAudioFormatMPEG4AAC_HE;
break;
case AAC_MODE_LC:
default:
output.mFormatID = kAudioFormatMPEG4AAC;
break;
}
output.mChannelsPerFrame = pv->nchannels;
err = AudioConverterNew(&input, &output, &pv->converter);
if (err != noErr)
{
hb_log("Error creating an AudioConverter err=%"PRId64" output.mBytesPerFrame=%"PRIu64"",
(int64_t)err, (uint64_t)output.mBytesPerFrame);
*job->done_error = HB_ERROR_UNKNOWN;
*job->die = 1;
return -1;
}
}
// set encoder quality to maximum
tmp = kAudioConverterQuality_Max;
AudioConverterSetProperty(pv->converter, kAudioConverterCodecQuality,
sizeof(tmp), &tmp);
if (audio->config.out.bitrate > 0)
{
// set encoder bitrate control mode to constrained variable
tmp = kAudioCodecBitRateControlMode_VariableConstrained;
AudioConverterSetProperty(pv->converter,
kAudioCodecPropertyBitRateControlMode,
sizeof(tmp), &tmp);
// get available bitrates
AudioValueRange *bitrates;
ssize_t bitrateCounts;
err = AudioConverterGetPropertyInfo(pv->converter,
kAudioConverterApplicableEncodeBitRates,
&tmpsiz, NULL);
bitrates = malloc(tmpsiz);
err = AudioConverterGetProperty(pv->converter,
kAudioConverterApplicableEncodeBitRates,
&tmpsiz, bitrates);
bitrateCounts = tmpsiz / sizeof(AudioValueRange);
// set bitrate
tmp = audio->config.out.bitrate * 1000;
if (tmp < bitrates[0].mMinimum)
tmp = bitrates[0].mMinimum;
if (tmp > bitrates[bitrateCounts-1].mMinimum)
tmp = bitrates[bitrateCounts-1].mMinimum;
free(bitrates);
if (tmp != audio->config.out.bitrate * 1000)
{
hb_log("encCoreAudioInit: sanitizing track %d audio bitrate %d to %"PRIu32"",
audio->config.out.track, audio->config.out.bitrate, tmp / 1000);
}
AudioConverterSetProperty(pv->converter,
kAudioConverterEncodeBitRate,
sizeof(tmp), &tmp);
}
else if (audio->config.out.quality >= 0)
{
if (mode != AAC_MODE_LC)
{
hb_error("encCoreAudioInit: internal error, VBR set but not applicable");
return 1;
}
// set encoder bitrate control mode to variable
tmp = kAudioCodecBitRateControlMode_Variable;
AudioConverterSetProperty(pv->converter,
kAudioCodecPropertyBitRateControlMode,
sizeof(tmp), &tmp);
// set quality
tmp = audio->config.out.quality;
AudioConverterSetProperty(pv->converter,
kAudioCodecPropertySoundQualityForVBR,
sizeof(tmp), &tmp);
}
else
{
hb_error("encCoreAudioInit: internal error, bitrate/quality not set");
return 1;
}
// get real input
tmpsiz = sizeof(input);
AudioConverterGetProperty(pv->converter,
kAudioConverterCurrentInputStreamDescription,
&tmpsiz, &input);
// get real output
tmpsiz = sizeof(output);
AudioConverterGetProperty(pv->converter,
kAudioConverterCurrentOutputStreamDescription,
&tmpsiz, &output);
// set sizes
pv->isamplesiz = input.mBytesPerPacket;
pv->isamples = output.mFramesPerPacket;
pv->osamplerate = output.mSampleRate;
audio->config.out.samples_per_frame = pv->isamples;
// channel remapping
pv->remap = hb_audio_remap_init(AV_SAMPLE_FMT_FLT, &hb_aac_chan_map,
audio->config.in.channel_map);
if (pv->remap == NULL)
{
hb_error("encCoreAudioInit: hb_audio_remap_init() failed");
}
uint64_t layout = hb_ff_mixdown_xlat(audio->config.out.mixdown, NULL);
hb_audio_remap_set_channel_layout(pv->remap, layout);
// get maximum output size
AudioConverterGetProperty(pv->converter,
kAudioConverterPropertyMaximumOutputPacketSize,
&tmpsiz, &tmp);
pv->omaxpacket = tmp;
// get magic cookie (elementary stream descriptor)
tmp = HB_CONFIG_MAX_SIZE;
AudioConverterGetProperty(pv->converter,
kAudioConverterCompressionMagicCookie,
&tmp, w->config->extradata.bytes);
// CoreAudio returns a complete ESDS, but we only need
// the DecoderSpecific info.
UInt8* buffer = NULL;
ReadESDSDescExt(w->config->extradata.bytes, &buffer, &tmpsiz, 0);
w->config->extradata.length = tmpsiz;
memmove(w->config->extradata.bytes, buffer, w->config->extradata.length);
free(buffer);
pv->list = hb_list_init();
pv->buf = NULL;
return 0;
}
int encvorbisInit(hb_work_object_t *w, hb_job_t *job)
{
hb_work_private_t *pv = calloc(1, sizeof(hb_work_private_t));
hb_audio_t *audio = w->audio;
w->private_data = pv;
pv->job = job;
int i;
ogg_packet header[3];
hb_log("encvorbis: opening libvorbis");
/* init */
for (i = 0; i < 3; i++)
{
// Zero vorbis headers so that we don't crash in mk_laceXiph
// when vorbis_encode_setup_managed fails.
memset(w->config->vorbis.headers[i], 0, sizeof(ogg_packet));
}
vorbis_info_init(&pv->vi);
pv->out_discrete_channels =
hb_mixdown_get_discrete_channel_count(audio->config.out.mixdown);
if (audio->config.out.bitrate > 0)
{
if (vorbis_encode_setup_managed(&pv->vi, pv->out_discrete_channels,
audio->config.out.samplerate, -1,
audio->config.out.bitrate * 1000, -1))
{
hb_error("encvorbis: vorbis_encode_setup_managed() failed");
*job->die = 1;
return -1;
}
}
else if (audio->config.out.quality != HB_INVALID_AUDIO_QUALITY)
{
// map VBR quality to Vorbis API (divide by 10)
if (vorbis_encode_setup_vbr(&pv->vi, pv->out_discrete_channels,
audio->config.out.samplerate,
audio->config.out.quality / 10))
{
hb_error("encvorbis: vorbis_encode_setup_vbr() failed");
*job->die = 1;
return -1;
}
}
if (vorbis_encode_ctl(&pv->vi, OV_ECTL_RATEMANAGE2_SET, NULL) ||
vorbis_encode_setup_init(&pv->vi))
{
hb_error("encvorbis: vorbis_encode_ctl(ratemanage2_set) OR vorbis_encode_setup_init() failed");
*job->die = 1;
return -1;
}
/* add a comment */
vorbis_comment_init(&pv->vc);
vorbis_comment_add_tag(&pv->vc, "Encoder", "HandBrake");
vorbis_comment_add_tag(&pv->vc, "LANGUAGE", w->config->vorbis.language);
/* set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init(&pv->vd, &pv->vi);
vorbis_block_init(&pv->vd, &pv->vb);
/* get the 3 headers */
vorbis_analysis_headerout(&pv->vd, &pv->vc,
&header[0], &header[1], &header[2]);
for (i = 0; i < 3; i++)
{
memcpy(w->config->vorbis.headers[i], &header[i], sizeof(ogg_packet));
memcpy(w->config->vorbis.headers[i] + sizeof(ogg_packet),
header[i].packet, header[i].bytes);
}
pv->input_samples = pv->out_discrete_channels * OGGVORBIS_FRAME_SIZE;
audio->config.out.samples_per_frame = OGGVORBIS_FRAME_SIZE;
pv->buf = malloc(pv->input_samples * sizeof(float));
pv->list = hb_list_init();
// channel remapping
uint64_t layout = hb_ff_mixdown_xlat(audio->config.out.mixdown, NULL);
pv->remap_table = hb_audio_remap_build_table(layout, &hb_vorbis_chan_map,
audio->config.in.channel_map);
if (pv->remap_table == NULL)
{
hb_error("encvorbisInit: hb_audio_remap_build_table() failed");
*job->die = 1;
return -1;
}
return 0;
}
/***********************************************************************
* hb_work_encfaac_init
***********************************************************************
*
**********************************************************************/
int encfaacInit( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
hb_audio_t * audio = w->audio;
faacEncConfigurationPtr cfg;
uint8_t * bytes;
unsigned long length;
w->private_data = pv;
pv->job = job;
/* pass the number of channels used into the private work data */
pv->out_discrete_channels = hb_mixdown_get_discrete_channel_count(audio->config.out.mixdown);
/* if the sample rate is 'auto' and that has given us an invalid output */
/* rate, map it to the next highest output rate or 48K if above the highest. */
int rate_index = find_samplerate(audio->config.out.samplerate);
if ( audio->config.out.samplerate != valid_rates[rate_index] )
{
int rate = valid_rates[valid_rates[rate_index]? rate_index : rate_index - 1];
hb_log( "encfaac changing output samplerate from %d to %d",
audio->config.out.samplerate, rate );
audio->config.out.samplerate = rate;
/* if the new rate is over the max bandwidth per channel limit */
/* lower the bandwidth. */
double bw = audio->config.out.bitrate * 1000 / pv->out_discrete_channels;
if ( bw > (double)rate * (6144./1024.) )
{
int newbr = (double)rate * (6.144/1024.) * pv->out_discrete_channels;
hb_log( "encfaac changing output bitrate from %d to %d",
audio->config.out.bitrate, newbr );
audio->config.out.bitrate = newbr;
}
}
pv->faac = faacEncOpen( audio->config.out.samplerate, pv->out_discrete_channels,
&pv->input_samples, &pv->output_bytes );
pv->buf = malloc( pv->input_samples * sizeof( float ) );
pv->obuf = malloc( pv->output_bytes );
pv->framedur = 90000.0 * pv->input_samples /
( audio->config.out.samplerate * pv->out_discrete_channels );
audio->config.out.samples_per_frame = pv->input_samples / pv->out_discrete_channels;
cfg = faacEncGetCurrentConfiguration( pv->faac );
cfg->mpegVersion = MPEG4;
cfg->aacObjectType = LOW;
cfg->allowMidside = 1;
// channel remapping, LFE
uint64_t layout;
int *remap_table;
layout = hb_ff_mixdown_xlat(audio->config.out.mixdown, NULL);
remap_table = hb_audio_remap_build_table(layout, &hb_aac_chan_map,
audio->config.in.channel_map);
if (remap_table != NULL)
{
// faac does its own remapping
memcpy(cfg->channel_map, remap_table,
pv->out_discrete_channels * sizeof(int));
free(remap_table);
}
cfg->useLfe = !!(layout & AV_CH_LOW_FREQUENCY);
cfg->useTns = 0;
cfg->bitRate = audio->config.out.bitrate * 1000 / pv->out_discrete_channels; /* Per channel */
cfg->bandWidth = 0;
cfg->outputFormat = 0;
cfg->inputFormat = FAAC_INPUT_FLOAT;
if( !faacEncSetConfiguration( pv->faac, cfg ) )
{
hb_log( "faacEncSetConfiguration failed" );
*job->die = 1;
return 0;
}
if( faacEncGetDecoderSpecificInfo( pv->faac, &bytes, &length ) < 0 )
{
hb_log( "faacEncGetDecoderSpecificInfo failed" );
*job->die = 1;
return 0;
}
memcpy( w->config->extradata.bytes, bytes, length );
w->config->extradata.length = length;
free( bytes );
pv->list = hb_list_init();
return 0;
}
static int encavcodecaInit( hb_work_object_t * w, hb_job_t * job )
{
AVCodec * codec;
AVCodecContext * context;
hb_audio_t * audio = w->audio;
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
w->private_data = pv;
pv->job = job;
pv->out_discrete_channels = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown);
codec = avcodec_find_encoder( w->codec_param );
if( !codec )
{
hb_log( "encavcodecaInit: avcodec_find_encoder "
"failed" );
return 1;
}
context = avcodec_alloc_context3(codec);
AVDictionary *av_opts = NULL;
if ( w->codec_param == CODEC_ID_AAC )
{
av_dict_set( &av_opts, "stereo_mode", "ms_off", 0 );
}
if ( w->codec_param == CODEC_ID_AC3 )
{
if( audio->config.out.mixdown == HB_AMIXDOWN_DOLBY ||
audio->config.out.mixdown == HB_AMIXDOWN_DOLBYPLII )
{
av_dict_set( &av_opts, "dsur_mode", "on", 0 );
}
}
context->channel_layout = AV_CH_LAYOUT_STEREO;
switch( audio->config.out.mixdown )
{
case HB_AMIXDOWN_MONO:
context->channel_layout = AV_CH_LAYOUT_MONO;
pv->layout = HB_INPUT_CH_LAYOUT_MONO;
break;
case HB_AMIXDOWN_STEREO:
case HB_AMIXDOWN_DOLBY:
case HB_AMIXDOWN_DOLBYPLII:
context->channel_layout = AV_CH_LAYOUT_STEREO;
pv->layout = HB_INPUT_CH_LAYOUT_STEREO;
break;
case HB_AMIXDOWN_6CH:
context->channel_layout = AV_CH_LAYOUT_5POINT1;
pv->layout = HB_INPUT_CH_LAYOUT_3F2R | HB_INPUT_CH_LAYOUT_HAS_LFE;
break;
default:
hb_log("encavcodecaInit: bad mixdown" );
break;
}
if( audio->config.out.bitrate > 0 )
context->bit_rate = audio->config.out.bitrate * 1000;
else if( audio->config.out.quality >= 0 )
{
context->global_quality = audio->config.out.quality * FF_QP2LAMBDA;
context->flags |= CODEC_FLAG_QSCALE;
}
if( audio->config.out.compression_level >= 0 )
context->compression_level = audio->config.out.compression_level;
context->sample_rate = audio->config.out.samplerate;
context->channels = pv->out_discrete_channels;
// Try to set format to float. Fallback to whatever is supported.
hb_ff_set_sample_fmt( context, codec );
if( hb_avcodec_open( context, codec, &av_opts, 0 ) )
{
hb_log( "encavcodecaInit: avcodec_open failed" );
return 1;
}
// avcodec_open populates the opts dictionary with the
// things it didn't recognize.
AVDictionaryEntry *t = NULL;
while( ( t = av_dict_get( av_opts, "", t, AV_DICT_IGNORE_SUFFIX ) ) )
{
hb_log( "encavcodecaInit: Unknown avcodec option %s", t->key );
}
av_dict_free( &av_opts );
pv->context = context;
audio->config.out.samples_per_frame = pv->samples_per_frame = context->frame_size;
pv->input_samples = pv->samples_per_frame * pv->out_discrete_channels;
// Set a reasonable maximum output size
pv->output_bytes = context->frame_size *
av_get_bytes_per_sample(context->sample_fmt) *
context->channels;
pv->buf = malloc( pv->input_samples * sizeof( float ) );
pv->list = hb_list_init();
if ( context->extradata )
{
memcpy( w->config->extradata.bytes, context->extradata, context->extradata_size );
w->config->extradata.length = context->extradata_size;
}
return 0;
}
/***********************************************************************
* hb_work_encfaac_init
***********************************************************************
*
**********************************************************************/
int encfaacInit( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
hb_audio_t * audio = w->audio;
faacEncConfigurationPtr cfg;
uint8_t * bytes;
unsigned long length;
w->private_data = pv;
pv->job = job;
/* pass the number of channels used into the private work data */
pv->out_discrete_channels = hb_mixdown_get_discrete_channel_count(audio->config.out.mixdown);
pv->faac = faacEncOpen( audio->config.out.samplerate, pv->out_discrete_channels,
&pv->input_samples, &pv->output_bytes );
pv->buf = malloc( pv->input_samples * sizeof( float ) );
pv->obuf = malloc( pv->output_bytes );
pv->framedur = 90000.0 * pv->input_samples /
( audio->config.out.samplerate * pv->out_discrete_channels );
audio->config.out.samples_per_frame = pv->input_samples / pv->out_discrete_channels;
cfg = faacEncGetCurrentConfiguration( pv->faac );
cfg->mpegVersion = MPEG4;
cfg->aacObjectType = LOW;
cfg->allowMidside = 1;
/* channel configuration & remapping */
uint64_t layout = hb_ff_mixdown_xlat(audio->config.out.mixdown, NULL);
hb_audio_remap_build_table(&hb_aac_chan_map, audio->config.in.channel_map,
layout, cfg->channel_map);
switch (audio->config.out.mixdown)
{
case HB_AMIXDOWN_7POINT1:
cfg->channelConfiguration = 0;
cfg->numFrontChannels = 3;
cfg->numSideChannels = 2;
cfg->numBackChannels = 2;
cfg->numLFEChannels = 1;
break;
case HB_AMIXDOWN_6POINT1:
cfg->channelConfiguration = 0;
cfg->numFrontChannels = 3;
cfg->numSideChannels = 0;
cfg->numBackChannels = 3;
cfg->numLFEChannels = 1;
break;
case HB_AMIXDOWN_5_2_LFE:
cfg->channelConfiguration = 7;
break;
default:
cfg->channelConfiguration =
hb_mixdown_get_discrete_channel_count(audio->config.out.mixdown);
break;
}
cfg->useTns = 0;
cfg->bitRate = audio->config.out.bitrate * 1000 / pv->out_discrete_channels; /* Per channel */
cfg->bandWidth = 0;
cfg->outputFormat = 0;
cfg->inputFormat = FAAC_INPUT_FLOAT;
if( !faacEncSetConfiguration( pv->faac, cfg ) )
{
hb_log( "faacEncSetConfiguration failed" );
*job->die = 1;
return 0;
}
if( faacEncGetDecoderSpecificInfo( pv->faac, &bytes, &length ) < 0 )
{
hb_log( "faacEncGetDecoderSpecificInfo failed" );
*job->die = 1;
return 0;
}
memcpy( w->config->extradata.bytes, bytes, length );
w->config->extradata.length = length;
free( bytes );
pv->list = hb_list_init();
return 0;
}
/***********************************************************************
* hb_work_decdca_init
***********************************************************************
* Allocate the work object, initialize libdca
**********************************************************************/
static int decdcaInit( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
hb_audio_t * audio = w->audio;
w->private_data = pv;
pv->job = job;
pv->list = hb_list_init();
pv->state = dca_init( 0 );
pv->level = 1.0;
/* Decide what format we want out of libdca;
* work.c has already done some of this deduction for us in do_job().
* Dolby Surround and Pro Logic II are a bit tricky. */
int layout = (audio->config.in.channel_layout & ~AV_CH_LOW_FREQUENCY);
switch (audio->config.out.mixdown)
{
case HB_AMIXDOWN_6CH:
pv->flags_out = (DCA_3F2R|DCA_LFE);
break;
case HB_AMIXDOWN_DOLBYPLII:
{
if (layout == AV_CH_LAYOUT_5POINT0)
{
// Dolby Pro Logic II output is supported
pv->flags_out = (DCA_3F2R|DCA_OUT_DPLII);
}
else if (layout == AV_CH_LAYOUT_4POINT0)
{
// Dolby Surround output and DCA_3F1R downmix are supported
pv->flags_out = (DCA_3F1R|DCA_OUT_DPLI);
}
else if (layout == AV_CH_LAYOUT_STEREO ||
layout == AV_CH_LAYOUT_STEREO_DOWNMIX)
{
// Dolby Surround output not supported OR
// Dolby Surround input just gets passed through as is
pv->flags_out = DCA_STEREO;
}
else
{
// Dolby Surround output is supported, but DCA_3F1R downmix isn't
pv->flags_out = DCA_DOLBY;
}
} break;
case HB_AMIXDOWN_DOLBY:
{
if (layout == AV_CH_LAYOUT_5POINT0 || layout == AV_CH_LAYOUT_4POINT0)
{
// Dolby Surround output and DCA_3F1R downmix are supported
pv->flags_out = (DCA_3F1R|DCA_OUT_DPLI);
}
else if (layout == AV_CH_LAYOUT_STEREO ||
layout == AV_CH_LAYOUT_STEREO_DOWNMIX)
{
// Dolby Surround output not supported OR
// Dolby Surround input just gets passed through as is
pv->flags_out = DCA_STEREO;
}
else
{
// Dolby Surround output is supported, but DCA_3F1R downmix isn't
pv->flags_out = DCA_DOLBY;
}
} break;
case HB_AMIXDOWN_MONO:
pv->flags_out = DCA_MONO;
break;
default:
pv->flags_out = DCA_STEREO;
break;
}
/* pass the number of channels used into the private work data */
pv->out_discrete_channels = hb_mixdown_get_discrete_channel_count( audio->config.out.mixdown );
return 0;
}
static int filter_pre_init( av_qsv_context* qsv, hb_filter_private_t * pv ){
mfxStatus sts = MFX_ERR_NONE;
int i=0;
if(!qsv) return 3;
av_qsv_space *prev_vpp = 0;
if(!qsv->vpp_space){
qsv->vpp_space = av_qsv_list_init(HAVE_THREADS);
// note some change as : when no size changes -> no VPP used
// impact on : prev_vpp
}
if(!pv->vpp_space){
for(i=0; i<av_qsv_list_count(qsv->vpp_space);i++){
av_qsv_space *qsv_vpp = av_qsv_list_item( qsv->vpp_space, i );
if(qsv_vpp->type == AV_QSV_VPP_USER){
pv->vpp_space = qsv_vpp;
break;
}
else
if(qsv_vpp->type == AV_QSV_VPP_DEFAULT){
prev_vpp = qsv_vpp;
}
}
}
if(!pv->vpp_space){
pv->vpp_space = calloc( 1, sizeof( av_qsv_space ));
pv->vpp_space->type = AV_QSV_VPP_USER;
av_qsv_list_add( qsv->vpp_space, pv->vpp_space );
av_qsv_add_context_usage(qsv,HAVE_THREADS);
}
else
if(pv->vpp_space->is_init_done ) return 1;
if(!qsv->dec_space || !qsv->dec_space->is_init_done) return 2;
av_qsv_space *qsv_vpp = pv->vpp_space;
AV_QSV_ZERO_MEMORY(qsv_vpp->m_mfxVideoParam);
if (prev_vpp)
{
memcpy( &qsv_vpp->m_mfxVideoParam.vpp, &prev_vpp->m_mfxVideoParam.vpp, sizeof(prev_vpp->m_mfxVideoParam.vpp));
}
else
{
AV_QSV_ZERO_MEMORY(qsv_vpp->m_mfxVideoParam);
// FrameRate is important for VPP to start with
if( qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN == 0 &&
qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD == 0 ){
qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN = pv->job->title->vrate.num;
qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD = pv->job->title->vrate.den;
}
qsv_vpp->m_mfxVideoParam.vpp.In.FourCC = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
qsv_vpp->m_mfxVideoParam.vpp.In.ChromaFormat = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
qsv_vpp->m_mfxVideoParam.vpp.In.CropX = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropX;
qsv_vpp->m_mfxVideoParam.vpp.In.CropY = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropY;
qsv_vpp->m_mfxVideoParam.vpp.In.CropW = pv->job->title->geometry.width;
qsv_vpp->m_mfxVideoParam.vpp.In.CropH = pv->job->title->geometry.height;
qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtN = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN;
qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtD = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD;
qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioW = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioH = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
qsv_vpp->m_mfxVideoParam.vpp.In.Width = AV_QSV_ALIGN16(pv->job->title->geometry.width);
qsv_vpp->m_mfxVideoParam.vpp.In.Height = (MFX_PICSTRUCT_PROGRESSIVE == qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct)?
AV_QSV_ALIGN16(pv->job->title->geometry.height) : AV_QSV_ALIGN32(pv->job->title->geometry.height);
qsv_vpp->m_mfxVideoParam.vpp.Out.FourCC = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
qsv_vpp->m_mfxVideoParam.vpp.Out.ChromaFormat = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropX = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropX;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropY = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropY;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropW = pv->job->title->geometry.width;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropH = pv->job->title->geometry.height;
qsv_vpp->m_mfxVideoParam.vpp.Out.PicStruct = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtN = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN;
qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtD = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD;
qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioW = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioH = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
qsv_vpp->m_mfxVideoParam.vpp.Out.Width = AV_QSV_ALIGN16(pv->job->title->geometry.width);
qsv_vpp->m_mfxVideoParam.vpp.Out.Height = (MFX_PICSTRUCT_PROGRESSIVE == qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct)?
AV_QSV_ALIGN16(pv->job->title->geometry.height) : AV_QSV_ALIGN32(pv->job->title->geometry.height);
memset(&qsv_vpp->request, 0, sizeof(mfxFrameAllocRequest)*2);
}
qsv_vpp->m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
qsv_vpp->surface_num = FFMIN(prev_vpp ? prev_vpp->surface_num : qsv->dec_space->surface_num/2, AV_QSV_SURFACE_NUM);
for(i = 0; i < qsv_vpp->surface_num; i++){
qsv_vpp->p_surfaces[i] = av_mallocz( sizeof(mfxFrameSurface1) );
AV_QSV_CHECK_POINTER(qsv_vpp->p_surfaces[i], MFX_ERR_MEMORY_ALLOC);
memcpy(&(qsv_vpp->p_surfaces[i]->Info), &(qsv_vpp->m_mfxVideoParam.vpp.Out), sizeof(mfxFrameInfo));
}
qsv_vpp->sync_num = FFMIN(prev_vpp ? prev_vpp->sync_num : qsv->dec_space->sync_num, AV_QSV_SYNC_NUM);
for (i = 0; i < qsv_vpp->sync_num; i++){
qsv_vpp->p_syncp[i] = av_mallocz(sizeof(av_qsv_sync));
AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i], MFX_ERR_MEMORY_ALLOC);
qsv_vpp->p_syncp[i]->p_sync = av_mallocz(sizeof(mfxSyncPoint));
AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i]->p_sync, MFX_ERR_MEMORY_ALLOC);
}
memset(&qsv_vpp->ext_opaque_alloc, 0, sizeof(mfxExtOpaqueSurfaceAlloc));
qsv_vpp->m_mfxVideoParam.NumExtParam = qsv_vpp->p_ext_param_num = 1;
qsv_vpp->p_ext_params = av_mallocz(sizeof(mfxExtBuffer *)*qsv_vpp->p_ext_param_num);
AV_QSV_CHECK_POINTER(qsv_vpp->p_ext_params, MFX_ERR_MEMORY_ALLOC);
qsv_vpp->m_mfxVideoParam.ExtParam = qsv_vpp->p_ext_params;
qsv_vpp->ext_opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
qsv_vpp->ext_opaque_alloc.Header.BufferSz = sizeof(mfxExtOpaqueSurfaceAlloc);
qsv_vpp->p_ext_params[0] = (mfxExtBuffer*)&qsv_vpp->ext_opaque_alloc;
if(prev_vpp){
qsv_vpp->ext_opaque_alloc.In.Surfaces = prev_vpp->p_surfaces;
qsv_vpp->ext_opaque_alloc.In.NumSurface = prev_vpp->surface_num;
}
else{
qsv_vpp->ext_opaque_alloc.In.Surfaces = qsv->dec_space->p_surfaces;
qsv_vpp->ext_opaque_alloc.In.NumSurface = qsv->dec_space->surface_num;
}
qsv_vpp->ext_opaque_alloc.In.Type = qsv->dec_space->request[0].Type;
qsv_vpp->ext_opaque_alloc.Out.Surfaces = qsv_vpp->p_surfaces;
qsv_vpp->ext_opaque_alloc.Out.NumSurface = qsv_vpp->surface_num;
qsv_vpp->ext_opaque_alloc.Out.Type = qsv->dec_space->request[0].Type;
pv->qsv_user = hb_list_init();
qsv_filter_t *plugin = av_mallocz( sizeof(qsv_filter_t) );
plugin->pv = pv;
plugin->plug.pthis = plugin;
plugin->plug.PluginInit = qsv_PluginInit;
plugin->plug.PluginClose = qsv_PluginClose;
plugin->plug.GetPluginParam = qsv_GetPluginParam;
plugin->plug.Submit = qsv_Submit;
plugin->plug.Execute = qsv_Execute;
plugin->plug.FreeResources = qsv_FreeResources;
hb_list_add(pv->qsv_user,plugin);
sts=MFXVideoUSER_Register(qsv->mfx_session,0,&plugin->plug);
AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
plugin_init(plugin,&qsv_vpp->m_mfxVideoParam);
qsv_vpp->is_init_done = 1;
return 0;
}
static void ScanFunc( void * _data )
{
hb_scan_t * data = (hb_scan_t *) _data;
hb_title_t * title;
int i;
int feature = 0;
data->bd = NULL;
data->dvd = NULL;
data->stream = NULL;
/* Try to open the path as a DVD. If it fails, try as a file */
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 ) );
if( data->title_index )
{
/* Scan this title only */
hb_list_add( data->list_title, hb_dvd_title_scan( data->dvd,
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, 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 );
}
}
}
}
else
{
hb_title_t * title = hb_title_init( data->path, 0 );
if ( (data->stream = hb_stream_open( data->path, title, 1 ) ) != NULL )
{
title = hb_stream_title_scan( data->stream, title );
if ( title )
hb_list_add( data->list_title, title );
}
else
{
hb_title_close( &title );
hb_log( "scan: unrecognized file type" );
return;
}
}
for( i = 0; i < hb_list_count( data->list_title ); )
{
int j;
hb_state_t state;
hb_audio_t * audio;
if ( *data->die )
{
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 ) :
data->bd ? hb_bd_title_count( data->bd ) :
data->batch ? hb_batch_title_count( data->batch ) :
hb_list_count(data->list_title);
hb_set_state( data->h, &state );
#undef p
/* Decode previews */
/* this will also detect more AC3 / DTS information */
if( !DecodePreviews( data, title ) )
{
/* TODO: free things */
hb_list_rem( data->list_title, title );
for( j = 0; j < hb_list_count( title->list_audio ); j++)
{
audio = hb_list_item( title->list_audio, j );
if ( audio->priv.scan_cache )
{
hb_fifo_flush( audio->priv.scan_cache );
hb_fifo_close( &audio->priv.scan_cache );
}
}
hb_title_close( &title );
continue;
}
/* 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->priv.scan_cache )
{
hb_fifo_flush( audio->priv.scan_cache );
hb_fifo_close( &audio->priv.scan_cache );
}
if( !audio->config.in.bitrate )
{
hb_log( "scan: removing audio 0x%x because no bitrate found",
audio->id );
hb_list_rem( title->list_audio, audio );
free( audio );
continue;
}
j++;
}
if ( data->dvd || data->bd )
{
// 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->source == PGSSUB )
{
subtitle->width = title->width;
subtitle->height = title->height;
}
}
}
i++;
}
/* Init jobs templates */
for( i = 0; i < hb_list_count( data->list_title ); i++ )
{
hb_job_t * job;
title = hb_list_item( data->list_title, i );
job = calloc( sizeof( hb_job_t ), 1 );
title->job = job;
job->title = title;
job->feature = feature;
/* Set defaults settings */
job->chapter_start = 1;
job->chapter_end = hb_list_count( title->list_chapter );
/* Autocrop by default. Gnark gnark */
memcpy( job->crop, title->crop, 4 * sizeof( int ) );
/* Preserve a source's pixel aspect, if it's available. */
if( title->pixel_aspect_width && title->pixel_aspect_height )
{
job->anamorphic.par_width = title->pixel_aspect_width;
job->anamorphic.par_height = title->pixel_aspect_height;
}
if( title->aspect != 0 && title->aspect != 1. &&
!job->anamorphic.par_width && !job->anamorphic.par_height)
{
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];
hb_fix_aspect( job, HB_KEEP_WIDTH );
if( job->height > title->height - job->crop[0] - job->crop[1] )
{
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 );
job->keep_ratio = 1;
job->vcodec = HB_VCODEC_FFMPEG_MPEG4;
job->vquality = -1.0;
job->vbitrate = 1000;
job->pass = 0;
job->vrate = title->rate;
job->vrate_base = title->rate_base;
job->list_audio = hb_list_init();
job->list_subtitle = hb_list_init();
job->list_filter = 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->batch )
{
hb_batch_close( &data->batch );
}
free( data->path );
free( data );
_data = NULL;
}
