/***********************************************************************
* hb_work_encx265_init
***********************************************************************
*
**********************************************************************/
int encx265Init(hb_work_object_t *w, hb_job_t *job)
{
hb_work_private_t *pv = calloc(1, sizeof(hb_work_private_t));
pv->next_chapter_pts = AV_NOPTS_VALUE;
pv->delayed_chapters = hb_list_init();
pv->job = job;
w->private_data = pv;
int i, vrate, vrate_base;
x265_nal *nal;
uint32_t nnal;
x265_param *param = pv->param = x265_param_alloc();
if (x265_param_default_preset(param,
job->encoder_preset, job->encoder_tune) < 0)
{
free(pv);
pv = NULL;
return 1;
}
/* If the PSNR or SSIM tunes are in use, enable the relevant metric */
param->bEnablePsnr = param->bEnableSsim = 0;
if (job->encoder_tune != NULL && *job->encoder_tune)
{
char *tmp = strdup(job->encoder_tune);
char *tok = strtok(tmp, ",./-+");
do
{
if (!strncasecmp(tok, "psnr", 4))
{
param->bEnablePsnr = 1;
break;
}
if (!strncasecmp(tok, "ssim", 4))
{
param->bEnableSsim = 1;
break;
}
}
while ((tok = strtok(NULL, ",./-+")) != NULL);
free(tmp);
}
/*
* Some HandBrake-specific defaults; users can override them
* using the encoder_options string.
*/
hb_reduce(&vrate, &vrate_base, job->vrate, job->vrate_base);
param->fpsNum = vrate;
param->fpsDenom = vrate_base;
param->keyframeMin = (int)((double)vrate / (double)vrate_base + 0.5);
param->keyframeMax = param->keyframeMin * 10;
/* iterate through x265_opts and parse the options */
hb_dict_entry_t *entry = NULL;
hb_dict_t *x265_opts = hb_encopts_to_dict(job->encoder_options, job->vcodec);
while ((entry = hb_dict_next(x265_opts, entry)) != NULL)
{
// here's where the strings are passed to libx265 for parsing
int ret = x265_param_parse(param, entry->key, entry->value);
// let x265 sanity check the options for us
switch (ret)
{
case X265_PARAM_BAD_NAME:
hb_log("encx265: unknown option '%s'", entry->key);
break;
case X265_PARAM_BAD_VALUE:
hb_log("encx265: bad argument '%s=%s'", entry->key,
entry->value ? entry->value : "(null)");
break;
default:
break;
}
}
hb_dict_free(&x265_opts);
/*
* Settings which can't be overriden in the encodeer_options string
* (muxer-specific settings, resolution, ratecontrol, etc.).
*/
param->sourceWidth = job->width;
param->sourceHeight = job->height;
if (job->vquality > 0)
{
param->rc.rateControlMode = X265_RC_CRF;
param->rc.rfConstant = job->vquality;
}
else
{
param->rc.rateControlMode = X265_RC_ABR;
param->rc.bitrate = job->vbitrate;
}
/* statsfile (but not 2-pass) */
memset(pv->csvfn, 0, sizeof(pv->csvfn));
if (param->logLevel >= X265_LOG_DEBUG)
{
if (param->csvfn == NULL)
{
hb_get_tempory_filename(job->h, pv->csvfn, "x265.csv");
param->csvfn = pv->csvfn;
}
else
{
strncpy(pv->csvfn, param->csvfn, sizeof(pv->csvfn));
}
}
/* Apply profile and level settings last. */
if (x265_param_apply_profile(param, job->encoder_profile) < 0)
{
free(pv);
pv = NULL;
return 1;
}
/* we should now know whether B-frames are enabled */
job->areBframes = (param->bframes > 0) + (param->bframes > 0 &&
param->bBPyramid > 0);
pv->x265 = x265_encoder_open(param);
if (pv->x265 == NULL)
{
hb_error("encx265: x265_encoder_open failed.");
free(pv);
pv = NULL;
return 1;
}
if (x265_encoder_headers(pv->x265, &nal, &nnal) < 0)
{
hb_error("encx265: x265_encoder_headers failed.");
free(pv);
pv = NULL;
return 1;
}
/*
* x265's output (headers and bitstream) are in Annex B format.
*
* Write the header as is, and let the muxer reformat
* the extradata and output bitstream properly for us.
*/
w->config->h265.headers_length = 0;
for (i = 0; i < nnal; i++)
{
if (w->config->h265.headers_length +
nal[i].sizeBytes > HB_CONFIG_MAX_SIZE)
{
hb_error("encx265: bitstream headers too large");
free(pv);
pv = NULL;
return 1;
}
memcpy(w->config->h265.headers +
w->config->h265.headers_length,
nal[i].payload, nal[i].sizeBytes);
w->config->h265.headers_length += nal[i].sizeBytes;
}
return 0;
}
/***********************************************************************
* hb_work_encx265_init
***********************************************************************
*
**********************************************************************/
int encx265Init(hb_work_object_t *w, hb_job_t *job)
{
hb_work_private_t *pv = calloc(1, sizeof(hb_work_private_t));
int ret, depth;
hb_rational_t vrate;
x265_nal *nal;
uint32_t nnal;
const char * const *profile_names;
pv->next_chapter_pts = AV_NOPTS_VALUE;
pv->delayed_chapters = hb_list_init();
pv->job = job;
w->private_data = pv;
depth = hb_video_encoder_get_depth(job->vcodec);
profile_names = hb_video_encoder_get_profiles(job->vcodec);
pv->api = x265_api_get(depth);
if (pv->api == NULL)
{
hb_error("encx265: x265_api_get failed, bit depth %d.", depth);
goto fail;
}
x265_param *param = pv->param = pv->api->param_alloc();
if (pv->api->param_default_preset(param, job->encoder_preset,
job->encoder_tune) < 0)
{
hb_error("encx265: x265_param_default_preset failed. Preset (%s) Tune (%s)", job->encoder_preset, job->encoder_tune);
goto fail;
}
/* If the PSNR or SSIM tunes are in use, enable the relevant metric */
param->bEnablePsnr = param->bEnableSsim = 0;
if (job->encoder_tune != NULL && *job->encoder_tune)
{
char *tmp = strdup(job->encoder_tune);
char *tok = strtok(tmp, ",./-+");
do
{
if (!strncasecmp(tok, "psnr", 4))
{
param->bEnablePsnr = 1;
break;
}
if (!strncasecmp(tok, "ssim", 4))
{
param->bEnableSsim = 1;
break;
}
}
while ((tok = strtok(NULL, ",./-+")) != NULL);
free(tmp);
}
/*
* Some HandBrake-specific defaults; users can override them
* using the encoder_options string.
*/
hb_reduce(&vrate.num, &vrate.den, job->vrate.num, job->vrate.den);
param->fpsNum = vrate.num;
param->fpsDenom = vrate.den;
param->keyframeMin = (double)job->orig_vrate.num / job->orig_vrate.den +
0.5;
param->keyframeMax = param->keyframeMin * 10;
/*
* Video Signal Type (color description only).
*
* Use x265_param_parse (let x265 determine which bEnable
* flags, if any, should be set in the x265_param struct).
*/
char colorprim[11], transfer[11], colormatrix[11];
switch (job->color_matrix_code)
{
case 1: // ITU BT.601 DVD or SD TV content (NTSC)
strcpy(colorprim, "smpte170m");
strcpy(transfer, "bt709");
strcpy(colormatrix, "smpte170m");
break;
case 2: // ITU BT.601 DVD or SD TV content (PAL)
strcpy(colorprim, "bt470bg");
strcpy(transfer, "bt709");
strcpy(colormatrix, "smpte170m");
break;
case 3: // ITU BT.709 HD content
strcpy(colorprim, "bt709");
strcpy(transfer, "bt709");
strcpy(colormatrix, "bt709");
break;
case 4: // custom
snprintf(colorprim, sizeof(colorprim), "%d", job->color_prim);
snprintf(transfer, sizeof(transfer), "%d", job->color_transfer);
snprintf(colormatrix, sizeof(colormatrix), "%d", job->color_matrix);
break;
default: // detected during scan
snprintf(colorprim, sizeof(colorprim), "%d", job->title->color_prim);
snprintf(transfer, sizeof(transfer), "%d", job->title->color_transfer);
snprintf(colormatrix, sizeof(colormatrix), "%d", job->title->color_matrix);
break;
}
if (param_parse(pv, param, "colorprim", colorprim) ||
param_parse(pv, param, "transfer", transfer) ||
param_parse(pv, param, "colormatrix", colormatrix))
{
goto fail;
}
/* iterate through x265_opts and parse the options */
hb_dict_t *x265_opts;
x265_opts = hb_encopts_to_dict(job->encoder_options, job->vcodec);
hb_dict_iter_t iter;
for (iter = hb_dict_iter_init(x265_opts);
iter != HB_DICT_ITER_DONE;
iter = hb_dict_iter_next(x265_opts, iter))
{
const char *key = hb_dict_iter_key(iter);
hb_value_t *value = hb_dict_iter_value(iter);
char *str = hb_value_get_string_xform(value);
// here's where the strings are passed to libx265 for parsing
// unknown options or bad values are non-fatal, see encx264.c
param_parse(pv, param, key, str);
free(str);
}
hb_dict_free(&x265_opts);
/*
* Reload colorimetry settings in case custom
* values were set in the encoder_options string.
*/
job->color_matrix_code = 4;
job->color_prim = param->vui.colorPrimaries;
job->color_transfer = param->vui.transferCharacteristics;
job->color_matrix = param->vui.matrixCoeffs;
/*
* Settings which can't be overriden in the encodeer_options string
* (muxer-specific settings, resolution, ratecontrol, etc.).
*/
param->bRepeatHeaders = 0;
param->sourceWidth = job->width;
param->sourceHeight = job->height;
/*
* Let x265 determnine whether to use an aspect ratio
* index vs. the extended SAR index + SAR width/height.
*/
char sar[22];
snprintf(sar, sizeof(sar), "%d:%d", job->par.num, job->par.den);
if (param_parse(pv, param, "sar", sar))
{
goto fail;
}
if (job->vquality > 0)
{
param->rc.rateControlMode = X265_RC_CRF;
param->rc.rfConstant = job->vquality;
}
else
{
param->rc.rateControlMode = X265_RC_ABR;
param->rc.bitrate = job->vbitrate;
if (job->pass_id == HB_PASS_ENCODE_1ST ||
job->pass_id == HB_PASS_ENCODE_2ND)
{
char stats_file[1024] = "";
char pass[2];
snprintf(pass, sizeof(pass), "%d", job->pass_id);
hb_get_tempory_filename(job->h, stats_file, "x265.log");
if (param_parse(pv, param, "stats", stats_file) ||
param_parse(pv, param, "pass", pass))
{
goto fail;
}
if (job->pass_id == HB_PASS_ENCODE_1ST && job->fastfirstpass == 0 &&
param_parse(pv, param, "slow-firstpass", "1"))
{
goto fail;
}
}
}
/* statsfile (but not 2-pass) */
memset(pv->csvfn, 0, sizeof(pv->csvfn));
if (param->logLevel >= X265_LOG_DEBUG)
{
if (param->csvfn == NULL)
{
hb_get_tempory_filename(job->h, pv->csvfn, "x265.csv");
param->csvfn = pv->csvfn;
}
else
{
strncpy(pv->csvfn, param->csvfn, sizeof(pv->csvfn));
}
}
/* Apply profile and level settings last. */
if (job->encoder_profile != NULL &&
strcasecmp(job->encoder_profile, profile_names[0]) != 0 &&
pv->api->param_apply_profile(param, job->encoder_profile) < 0)
{
goto fail;
}
/* we should now know whether B-frames are enabled */
job->areBframes = (param->bframes > 0) + (param->bframes > 0 &&
param->bBPyramid > 0);
/* Reset global variables before opening a new encoder */
pv->api->cleanup();
pv->x265 = pv->api->encoder_open(param);
if (pv->x265 == NULL)
{
hb_error("encx265: x265_encoder_open failed.");
goto fail;
}
/*
* x265's output (headers and bitstream) are in Annex B format.
*
* Write the header as is, and let the muxer reformat
* the extradata and output bitstream properly for us.
*/
ret = pv->api->encoder_headers(pv->x265, &nal, &nnal);
if (ret < 0)
{
hb_error("encx265: x265_encoder_headers failed (%d)", ret);
goto fail;
}
if (ret > sizeof(w->config->h265.headers))
{
hb_error("encx265: bitstream headers too large (%d)", ret);
goto fail;
}
memcpy(w->config->h265.headers, nal->payload, ret);
w->config->h265.headers_length = ret;
return 0;
fail:
w->private_data = NULL;
free(pv);
return 1;
}
/***********************************************************************
* 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_ps, * buf_es;
hb_list_t * list_es;
int progressive_count = 0;
int interlaced_preview_count = 0;
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 );
list_es = hb_list_init();
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 );
}
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 ) / ( 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 );
int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
#if defined(USE_FF_MPEG2)
if (vcodec == WORK_DECMPEG2)
{
vcodec = WORK_DECAVCODECV;
title->video_codec_param = CODEC_ID_MPEG2VIDEO;
}
#endif
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;
}
}
else if (data->stream)
{
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;
}
}
(hb_demux[title->demuxer])(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 == 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 ) )
{
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 );
}
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 )
{
/* 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++;
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;
}
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_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976");
}
title->rate_base = 1126125;
}
}
else if( title->rate_base == 900900 && progressive_count >= 6 )
{
/*
* We've already deduced that the frame rate is 23.976, so set it
* back again.
*/
title->rate_base = 1126125;
}
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, title->width, title->height, 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_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 */
#define Y vid_buf->data
int top, bottom, left, right;
int h4 = title->height / 4, w4 = title->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 = title->height / 100;
for ( top = border; top < h4; ++top )
{
if ( ! row_all_dark( title, Y, 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( title, Y, top ) )
break;
}
if ( top >= border )
{
top = 0;
}
}
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, bottom, left ) )
break;
}
for ( right = 0; right < w4; ++right )
{
if ( ! column_all_dark( title, Y, top, bottom, title->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 );
}
}
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->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;
if( title->pixel_aspect_width && 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 );
}
}
// 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] );
}
free( crops );
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;
}
}
