d_badapt_opts
};
+static options_map_t d_bpyramid_opts[] =
+{
+ {"Off", "none", 0, "none"},
+ {"Strict", "strict", 1, "strict"},
+ {"Normal", "normal", 2, "normal"},
+};
+combo_opts_t bpyramid_opts =
+{
+ sizeof(d_bpyramid_opts)/sizeof(options_map_t),
+ d_bpyramid_opts
+};
+
+static options_map_t d_weightp_opts[] =
+{
+ {"Off", "0", 0, "0"},
+ {"Blind", "1", 1, "1"},
+ {"Smart", "2", 2, "2"},
+};
+combo_opts_t weightp_opts =
+{
+ sizeof(d_weightp_opts)/sizeof(options_map_t),
+ d_weightp_opts
+};
+
static options_map_t d_me_opts[] =
{
{"Diamond", "dia", 0, "dia"},
static options_map_t d_subme_opts[] =
{
- {"1", "1", 1, "1"},
- {"2", "2", 2, "2"},
- {"3", "3", 3, "3"},
- {"4", "4", 4, "4"},
- {"5", "5", 5, "5"},
- {"6", "6", 6, "6"},
- {"7", "7", 7, "7"},
- {"8", "8", 8, "8"},
- {"9", "9", 9, "9"},
- {"10", "10", 10, "10"},
+ {"0: SAD, no subpel", "0", 0, "0"},
+ {"1: SAD, qpel", "1", 1, "1"},
+ {"2: SATD, qpel", "2", 2, "2"},
+ {"3: SATD: multi-qpel", "3", 3, "3"},
+ {"4: SATD, qpel on all", "4", 4, "4"},
+ {"5: SATD, multi-qpel on all", "5", 5, "5"},
+ {"6: RD in I/P-frames", "6", 6, "6"},
+ {"7: RD in all frames", "7", 7, "7"},
+ {"8: RD refine in I/P-frames", "8", 8, "8"},
+ {"9: RD refine in all frames", "9", 9, "9"},
+ {"10: QPRD in all frames", "10", 10, "10"},
};
combo_opts_t subme_opts =
{
static options_map_t d_analyse_opts[] =
{
- {"Some", "some", 0, "some"},
+ {"Most", "p8x8,b8x8,i8x8,i4x4", 0, "p8x8,b8x8,i8x8,i4x4"},
{"None", "none", 1, "none"},
- {"All", "all", 2, "all"},
- {"Custom", "custom", 3, "all"},
+ {"Some", "i4x4,i8x8", 2, "i4x4,i8x8"},
+ {"All", "all", 3, "all"},
+ {"Custom", "custom", 4, "all"},
};
combo_opts_t analyse_opts =
{
static options_map_t d_trellis_opts[] =
{
- {"Disabled", "0", 0, "0"},
- {"Final Macro Block", "1", 1, "1"},
- {"Always", "2", 2, "2"},
+ {"Off", "0", 0, "0"},
+ {"Encode only", "1", 1, "1"},
+ {"Always", "2", 2, "2"},
};
combo_opts_t trellis_opts =
{
{"AudioEncoder", &acodec_opts},
{"x264_direct", &direct_opts},
{"x264_b_adapt", &badapt_opts},
+ {"x264_bpyramid", &bpyramid_opts},
+ {"x264_weighted_pframes", &weightp_opts},
{"x264_me", &me_opts},
{"x264_subme", &subme_opts},
{"x264_analyse", &analyse_opts},
}
}
+gint
+find_combo_entry(combo_opts_t *opts, const GValue *gval)
+{
+ gint ii;
+
+ if (G_VALUE_TYPE(gval) == G_TYPE_STRING)
+ {
+ gchar *str;
+ str = ghb_value_string(gval);
+ for (ii = 0; ii < opts->count; ii++)
+ {
+ if (strcmp(opts->map[ii].shortOpt, str) == 0)
+ {
+ break;
+ }
+ }
+ g_free(str);
+ return ii;
+ }
+ else if (G_VALUE_TYPE(gval) == G_TYPE_DOUBLE)
+ {
+ gdouble val;
+ val = ghb_value_double(gval);
+ for (ii = 0; ii < opts->count; ii++)
+ {
+ if (opts->map[ii].ivalue == val)
+ {
+ break;
+ }
+ }
+ return ii;
+ }
+ else if (G_VALUE_TYPE(gval) == G_TYPE_INT ||
+ G_VALUE_TYPE(gval) == G_TYPE_BOOLEAN ||
+ G_VALUE_TYPE(gval) == G_TYPE_INT64)
+ {
+ gint64 val;
+ val = ghb_value_int64(gval);
+ for (ii = 0; ii < opts->count; ii++)
+ {
+ if ((gint64)opts->map[ii].ivalue == val)
+ {
+ break;
+ }
+ }
+ return ii;
+ }
+ return opts->count;
+}
+
static const gchar*
lookup_generic_string(combo_opts_t *opts, const GValue *gval)
{
gint ii;
- gchar *str;
const gchar *result = "";
- str = ghb_value_string(gval);
- for (ii = 0; ii < opts->count; ii++)
+ ii = find_combo_entry(opts, gval);
+ if (ii < opts->count)
{
- if (strcmp(opts->map[ii].shortOpt, str) == 0)
- {
- result = opts->map[ii].svalue;
- break;
- }
+ result = opts->map[ii].svalue;
}
- g_free(str);
return result;
}
lookup_generic_int(combo_opts_t *opts, const GValue *gval)
{
gint ii;
- gchar *str;
gint result = -1;
- str = ghb_value_string(gval);
- for (ii = 0; ii < opts->count; ii++)
+ ii = find_combo_entry(opts, gval);
+ if (ii < opts->count)
{
- if (strcmp(opts->map[ii].shortOpt, str) == 0)
- {
- result = opts->map[ii].ivalue;
- break;
- }
+ result = opts->map[ii].ivalue;
}
- g_free(str);
return result;
}
lookup_generic_double(combo_opts_t *opts, const GValue *gval)
{
gint ii;
- gchar *str;
gdouble result = -1;
- str = ghb_value_string(gval);
- for (ii = 0; ii < opts->count; ii++)
+ ii = find_combo_entry(opts, gval);
+ if (ii < opts->count)
{
- if (strcmp(opts->map[ii].shortOpt, str) == 0)
- {
- result = opts->map[ii].ivalue;
- break;
- }
+ result = opts->map[ii].ivalue;
}
- g_free(str);
return result;
}
lookup_generic_option(combo_opts_t *opts, const GValue *gval)
{
gint ii;
- gchar *str;
const gchar *result = "";
- str = ghb_value_string(gval);
- for (ii = 0; ii < opts->count; ii++)
+ ii = find_combo_entry(opts, gval);
+ if (ii < opts->count)
{
- if (strcmp(opts->map[ii].shortOpt, str) == 0)
- {
- result = opts->map[ii].option;
- break;
- }
+ result = opts->map[ii].option;
}
- g_free(str);
return result;
}
lookup_mix_int(const GValue *mix)
{
gint ii;
- gchar *str;
gint result = 0;
- str = ghb_value_string(mix);
- for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
+ if (G_VALUE_TYPE(mix) == G_TYPE_STRING)
{
- if (strcmp(hb_audio_mixdowns[ii].short_name, str) == 0)
+ gchar * str = ghb_value_string(mix);
+ for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
{
- result = hb_audio_mixdowns[ii].amixdown;
- break;
+ if (strcmp(hb_audio_mixdowns[ii].short_name, str) == 0)
+ {
+ result = hb_audio_mixdowns[ii].amixdown;
+ break;
+ }
+ }
+ g_free(str);
+ }
+ else if (G_VALUE_TYPE(mix) == G_TYPE_INT ||
+ G_VALUE_TYPE(mix) == G_TYPE_INT64 ||
+ G_VALUE_TYPE(mix) == G_TYPE_DOUBLE)
+ {
+ gint val = ghb_value_int(mix);
+ for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
+ {
+ if (hb_audio_mixdowns[ii].amixdown == val)
+ {
+ result = hb_audio_mixdowns[ii].amixdown;
+ break;
+ }
}
}
- g_free(str);
return result;
}
lookup_mix_option(const GValue *mix)
{
gint ii;
- gchar *str;
gchar *result = "None";
- str = ghb_value_string(mix);
- for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
+ if (G_VALUE_TYPE(mix) == G_TYPE_STRING)
{
- if (strcmp(hb_audio_mixdowns[ii].short_name, str) == 0)
+ gchar *str = ghb_value_string(mix);
+ for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
{
- result = hb_audio_mixdowns[ii].human_readable_name;
- break;
+ if (strcmp(hb_audio_mixdowns[ii].short_name, str) == 0)
+ {
+ result = hb_audio_mixdowns[ii].human_readable_name;
+ break;
+ }
+ }
+ g_free(str);
+ }
+ else if (G_VALUE_TYPE(mix) == G_TYPE_INT ||
+ G_VALUE_TYPE(mix) == G_TYPE_INT64 ||
+ G_VALUE_TYPE(mix) == G_TYPE_DOUBLE)
+ {
+ gint val = ghb_value_int(mix);
+ for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
+ {
+ if (hb_audio_mixdowns[ii].amixdown == val)
+ {
+ result = hb_audio_mixdowns[ii].human_readable_name;
+ break;
+ }
+ }
+ }
+ return result;
+}
+
+static const gchar*
+lookup_mix_string(const GValue *mix)
+{
+ gint ii;
+ gchar *result = "None";
+
+
+ if (G_VALUE_TYPE(mix) == G_TYPE_STRING)
+ {
+ gchar *str = ghb_value_string(mix);
+ for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
+ {
+ if (strcmp(hb_audio_mixdowns[ii].short_name, str) == 0)
+ {
+ result = hb_audio_mixdowns[ii].short_name;
+ break;
+ }
+ }
+ g_free(str);
+ }
+ else if (G_VALUE_TYPE(mix) == G_TYPE_INT ||
+ G_VALUE_TYPE(mix) == G_TYPE_INT64 ||
+ G_VALUE_TYPE(mix) == G_TYPE_DOUBLE)
+ {
+ gint val = ghb_value_int(mix);
+ for (ii = 0; ii < hb_audio_mixdowns_count; ii++)
+ {
+ if (hb_audio_mixdowns[ii].amixdown == val)
+ {
+ result = hb_audio_mixdowns[ii].short_name;
+ break;
+ }
}
}
- g_free(str);
return result;
}
lookup_audio_rate_int(const GValue *rate)
{
gint ii;
- gchar *str;
gint result = 0;
- // Coincidentally, the string "source" will return 0
- // which is our flag to use "same as source"
- str = ghb_value_string(rate);
- for (ii = 0; ii < hb_audio_rates_count; ii++)
+ if (G_VALUE_TYPE(rate) == G_TYPE_STRING)
{
- if (strcmp(hb_audio_rates[ii].string, str) == 0)
+ // Coincidentally, the string "source" will return 0
+ // which is our flag to use "same as source"
+ gchar * str = ghb_value_string(rate);
+ for (ii = 0; ii < hb_audio_rates_count; ii++)
{
- result = hb_audio_rates[ii].rate;
- break;
+ if (strcmp(hb_audio_rates[ii].string, str) == 0)
+ {
+ result = hb_audio_rates[ii].rate;
+ break;
+ }
+ }
+ g_free(str);
+ }
+ else if (G_VALUE_TYPE(rate) == G_TYPE_INT ||
+ G_VALUE_TYPE(rate) == G_TYPE_INT64 ||
+ G_VALUE_TYPE(rate) == G_TYPE_DOUBLE)
+ {
+ for (ii = 0; ii < hb_audio_rates_count; ii++)
+ {
+ gint val = ghb_value_int(rate);
+ if (val == hb_audio_rates[ii].rate)
+ {
+ result = hb_audio_rates[ii].rate;
+ break;
+ }
}
}
- g_free(str);
return result;
}
lookup_audio_rate_option(const GValue *rate)
{
gint ii;
- gchar *str;
const gchar *result = "Same as source";
- // Coincidentally, the string "source" will return 0
- // which is our flag to use "same as source"
- str = ghb_value_string(rate);
- for (ii = 0; ii < hb_audio_rates_count; ii++)
+ if (G_VALUE_TYPE(rate) == G_TYPE_STRING)
{
- if (strcmp(hb_audio_rates[ii].string, str) == 0)
+ // Coincidentally, the string "source" will return 0
+ // which is our flag to use "same as source"
+ gchar *str = ghb_value_string(rate);
+ for (ii = 0; ii < hb_audio_rates_count; ii++)
{
- result = hb_audio_rates[ii].string;
- break;
+ if (strcmp(hb_audio_rates[ii].string, str) == 0)
+ {
+ result = hb_audio_rates[ii].string;
+ break;
+ }
+ }
+ g_free(str);
+ }
+ else if (G_VALUE_TYPE(rate) == G_TYPE_INT ||
+ G_VALUE_TYPE(rate) == G_TYPE_INT64 ||
+ G_VALUE_TYPE(rate) == G_TYPE_DOUBLE)
+ {
+ for (ii = 0; ii < hb_audio_rates_count; ii++)
+ {
+ gint val = ghb_value_int(rate);
+ if (val == hb_audio_rates[ii].rate)
+ {
+ result = hb_audio_rates[ii].string;
+ break;
+ }
}
}
- g_free(str);
return result;
}
return result;
}
+gint
+ghb_find_closest_audio_rate(gint rate)
+{
+ gint ii;
+ gint result;
+
+ result = 0;
+ for (ii = 0; ii < hb_audio_rates_count; ii++)
+ {
+ if (rate <= hb_audio_rates[ii].rate)
+ {
+ result = hb_audio_rates[ii].rate;
+ break;
+ }
+ }
+ return result;
+}
+
static gint
lookup_audio_bitrate_int(const GValue *rate)
{
gint ii;
- gchar *str;
gint result = 0;
- // Coincidentally, the string "source" will return 0
- // which is our flag to use "same as source"
- str = ghb_value_string(rate);
- for (ii = 0; ii < hb_audio_bitrates_count; ii++)
+ if (G_VALUE_TYPE(rate) == G_TYPE_STRING)
{
- if (strcmp(hb_audio_bitrates[ii].string, str) == 0)
+ // Coincidentally, the string "source" will return 0
+ // which is our flag to use "same as source"
+ gchar *str = ghb_value_string(rate);
+ for (ii = 0; ii < hb_audio_bitrates_count; ii++)
{
- result = hb_audio_bitrates[ii].rate;
- break;
+ if (strcmp(hb_audio_bitrates[ii].string, str) == 0)
+ {
+ result = hb_audio_bitrates[ii].rate;
+ break;
+ }
+ }
+ g_free(str);
+ }
+ else if (G_VALUE_TYPE(rate) == G_TYPE_INT ||
+ G_VALUE_TYPE(rate) == G_TYPE_INT64 ||
+ G_VALUE_TYPE(rate) == G_TYPE_DOUBLE)
+ {
+ gint val = ghb_value_int(rate);
+ for (ii = 0; ii < hb_audio_bitrates_count; ii++)
+ {
+ if (hb_audio_bitrates[ii].rate == val)
+ {
+ result = hb_audio_bitrates[ii].rate;
+ break;
+ }
}
}
- g_free(str);
return result;
}
lookup_audio_bitrate_option(const GValue *rate)
{
gint ii;
- gchar *str;
const gchar *result = "Same as source";
- // Coincidentally, the string "source" will return 0
- // which is our flag to use "same as source"
- str = ghb_value_string(rate);
- for (ii = 0; ii < hb_audio_bitrates_count; ii++)
+ if (G_VALUE_TYPE(rate) == G_TYPE_STRING)
{
- if (strcmp(hb_audio_bitrates[ii].string, str) == 0)
+ // Coincidentally, the string "source" will return 0
+ // which is our flag to use "same as source"
+ gchar *str = ghb_value_string(rate);
+ for (ii = 0; ii < hb_audio_bitrates_count; ii++)
{
- result = hb_audio_bitrates[ii].string;
- break;
+ if (strcmp(hb_audio_bitrates[ii].string, str) == 0)
+ {
+ result = hb_audio_bitrates[ii].string;
+ break;
+ }
+ }
+ g_free(str);
+ }
+ else if (G_VALUE_TYPE(rate) == G_TYPE_INT ||
+ G_VALUE_TYPE(rate) == G_TYPE_INT64 ||
+ G_VALUE_TYPE(rate) == G_TYPE_DOUBLE)
+ {
+ gint val = ghb_value_int(rate);
+ for (ii = 0; ii < hb_audio_bitrates_count; ii++)
+ {
+ if (hb_audio_bitrates[ii].rate == val)
+ {
+ result = hb_audio_bitrates[ii].string;
+ break;
+ }
}
}
- g_free(str);
return result;
}
if ((int)acodec_opts.map[ii].ivalue == val)
{
value = ghb_string_value_new(acodec_opts.map[ii].shortOpt);
- break;
+ return value;
}
}
+ value = ghb_string_value_new("auto");
return value;
}
container = ghb_lookup_combo_int("FileFormat", gval);
ghb_value_free(gval);
- grey_combo_box_item(builder, "x264_analyse", 3, TRUE);
+ grey_combo_box_item(builder, "x264_analyse", 4, TRUE);
grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_FAAC, FALSE);
grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_LAME, FALSE);
grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_VORBIS, FALSE);
gint ii;
gint count = 0;
gint track = -1;
- gint max_chan = 0;
+ gint max_chan;
gboolean *used = NULL;
gboolean *passthru_used;
gint try_acodec;
gint passthru_acodec;
gboolean passthru;
+ gint channels;
g_debug("find_audio_track ()\n");
if (h_scan == NULL) return -1;
if (count > 10) count = 10;
// Try to find an item that matches the preferred language and
// the passthru codec type
+ max_chan = 0;
passthru = (acodec & (HB_ACODEC_AC3 | HB_ACODEC_DCA)) != 0;
if (passthru)
{
for (ii = 0; ii < count; ii++)
{
- gint channels;
-
audio = (hb_audio_config_t*)hb_list_audio_config_item(
title->list_audio, ii );
passthru_acodec = (HB_ACODEC_AC3 | HB_ACODEC_DCA) & audio->in.codec;
return track;
}
// Try to find an item that matches the preferred language
+ max_chan = 0;
used = get_track_used(try_acodec, track_indices, count);
for (ii = 0; ii < count; ii++)
{
if (passthru_used[ii])
continue;
}
+ channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT(
+ audio->in.channel_layout);
// Find a track that is not visually impaired or dirctor's commentary
if ((audio->lang.type < 2) &&
((strcmp(lang, audio->lang.iso639_2) == 0) ||
(strcmp(lang, "und") == 0)))
{
- track = ii;
- break;
+ if (channels > max_chan)
+ {
+ track = ii;
+ max_chan = channels;
+ }
}
}
if (track > -1)
}
// Try to fine an item that does not match the preferred language and
// matches the passthru codec type
+ max_chan = 0;
if (passthru)
{
for (ii = 0; ii < count; ii++)
{
- gint channels;
-
audio = (hb_audio_config_t*)hb_list_audio_config_item(
title->list_audio, ii );
passthru_acodec = (HB_ACODEC_AC3 | HB_ACODEC_DCA) & audio->in.codec;
return track;
}
// Try to fine an item that does not match the preferred language
+ max_chan = 0;
used = get_track_used(try_acodec, track_indices, count);
for (ii = 0; ii < count; ii++)
{
audio = (hb_audio_config_t*)hb_list_audio_config_item(
title->list_audio, ii );
passthru_acodec = (HB_ACODEC_AC3 | HB_ACODEC_DCA) & audio->in.codec;
+ channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT(
+ audio->in.channel_layout);
if (passthru_acodec && passthru)
{
passthru_used = get_track_used(passthru_acodec, track_indices, count);
// Find a track that is not visually impaired or dirctor's commentary
if (audio->lang.type < 2)
{
- track = ii;
- break;
+ if (channels > max_chan)
+ {
+ track = ii;
+ max_chan = channels;
+ }
}
}
if (track > -1)
gint ii;
gchar *str;
- g_debug("generic_opts_set ()\n");
+ g_debug("small_opts_set ()\n");
if (name == NULL || opts == NULL) return;
store = get_combo_box_store(builder, name);
gtk_list_store_clear(store);
else if (strcmp(name, "VideoFramerate") == 0)
return lookup_video_rate_option(gval);
else if (strcmp(name, "AudioMixdown") == 0)
- return lookup_mix_option(gval);
+ return lookup_mix_string(gval);
else if (strcmp(name, "SrtLanguage") == 0)
return lookup_audio_lang_option(gval);
else if (strcmp(name, "PreferredLanguage") == 0)
generic_opts_set(ud->builder, "PictureDenoise", &denoise_opts);
generic_opts_set(ud->builder, "VideoEncoder", &vcodec_opts);
small_opts_set(ud->builder, "AudioEncoder", &acodec_opts);
- generic_opts_set(ud->builder, "x264_direct", &direct_opts);
- generic_opts_set(ud->builder, "x264_b_adapt", &badapt_opts);
- generic_opts_set(ud->builder, "x264_me", &me_opts);
- generic_opts_set(ud->builder, "x264_subme", &subme_opts);
- generic_opts_set(ud->builder, "x264_analyse", &analyse_opts);
- generic_opts_set(ud->builder, "x264_trellis", &trellis_opts);
+ small_opts_set(ud->builder, "x264_direct", &direct_opts);
+ small_opts_set(ud->builder, "x264_b_adapt", &badapt_opts);
+ small_opts_set(ud->builder, "x264_bpyramid", &bpyramid_opts);
+ small_opts_set(ud->builder, "x264_weighted_pframes", &weightp_opts);
+ small_opts_set(ud->builder, "x264_me", &me_opts);
+ small_opts_set(ud->builder, "x264_subme", &subme_opts);
+ small_opts_set(ud->builder, "x264_analyse", &analyse_opts);
+ small_opts_set(ud->builder, "x264_trellis", &trellis_opts);
}
else
{
}
void
-ghb_backend_scan(const gchar *path, gint titleindex, gint preview_count)
+ghb_backend_scan(const gchar *path, gint titleindex, gint preview_count, uint64_t min_duration)
{
- hb_scan( h_scan, path, titleindex, preview_count, 1 );
+ hb_scan( h_scan, path, titleindex, preview_count, 1, min_duration );
hb_status.scan.state |= GHB_STATE_SCANNING;
// initialize count and cur to something that won't cause FPE
// when computing progress
ghb_backend_queue_scan(const gchar *path, gint titlenum)
{
g_debug("ghb_backend_queue_scan()");
- hb_scan( h_queue, path, titlenum, 10, 0 );
+ hb_scan( h_queue, path, titlenum, 10, 0, 0 );
hb_status.queue.state |= GHB_STATE_SCANNING;
}
gint mod;
gint max_width = 0;
gint max_height = 0;
- static gboolean busy = FALSE;
g_debug("ghb_set_scale ()\n");
picture_settings_deps(ud);
gint titleindex;
titleindex = ghb_settings_combo_int(ud->settings, "title");
- title = hb_list_item( list, titleindex );
+ title = hb_list_item( list, titleindex );
if (title == NULL) return;
job = title->job;
if (job == NULL) return;
- if (busy) return;
- busy = TRUE;
-
- if (!ud->dont_clear_presets && (keep_width || keep_height))
- {
- ghb_settings_set_int(ud->settings, "PictureWidth", 0);
- ghb_settings_set_int(ud->settings, "PictureHeight", 0);
- }
+ if (ud->scale_busy) return;
+ ud->scale_busy = TRUE;
// First configure widgets
mod = ghb_settings_combo_int(ud->settings, "PictureModulus");
{
width = ghb_settings_get_int(ud->settings, "scale_width");
height = ghb_settings_get_int(ud->settings, "scale_height");
- max_width = MOD_DOWN(
- ghb_settings_get_int(ud->settings, "PictureWidth"), mod);
- max_height = MOD_DOWN(
- ghb_settings_get_int(ud->settings, "PictureHeight"), mod);
+ if (mode & GHB_PIC_USE_MAX)
+ {
+ max_width = MOD_DOWN(
+ ghb_settings_get_int(ud->settings, "PictureWidth"), mod);
+ max_height = MOD_DOWN(
+ ghb_settings_get_int(ud->settings, "PictureHeight"), mod);
+ }
}
g_debug("max_width %d, max_height %d\n", max_width, max_height);
width = MOD_ROUND(width, mod);
height = MOD_ROUND(height, mod);
- // Adjust dims according to max values
- if (max_height)
- height = MIN(height, max_height);
- if (max_width)
- width = MIN(width, max_width);
-
+ job->anamorphic.mode = pic_par;
if (pic_par)
{
- job->anamorphic.mode = pic_par;
// The scaler crashes if the dimensions are not divisible by 2
// Align mod 2. And so does something in x264_encoder_headers()
job->modulus = mod;
job->anamorphic.dar_height = 0;
if (keep_height && pic_par == 2)
- width = ((double)height * crop_width / crop_height) + mod / 2;
+ width = ((double)height * crop_width / crop_height);
job->width = width;
job->height = height;
job->maxWidth = max_width;
{
job->anamorphic.keep_display_aspect = 1;
}
+ // hb_set_anamorphic_size will adjust par, dar, and width/height
+ // to conform to job parameters that have been set, including
+ // maxWidth and maxHeight
hb_set_anamorphic_size( job, &width, &height,
&par_width, &par_height );
if (job->anamorphic.mode == 3 && !keep_aspect &&
}
else
{
- job->anamorphic.mode = pic_par;
+ // Adjust dims according to max values
+ if (max_height)
+ height = MIN(height, max_height);
+ if (max_width)
+ width = MIN(width, max_width);
+
if (keep_aspect)
{
gdouble par;
ghb_ui_update(ud, "PicturePARHeight", ghb_int64_value(par_height));
ghb_ui_update(ud, "PictureDisplayWidth", ghb_int64_value(disp_width));
ghb_ui_update(ud, "PictureDisplayHeight", ghb_int64_value(height));
- busy = FALSE;
+ ud->scale_busy = FALSE;
}
static void
{
job->vrate = 27000000;
job->vrate_base = vrate;
- job->cfr = 1;
+ gboolean pfr = ghb_settings_get_boolean(js, "VideoFrameratePFR");
+ if (pfr)
+ job->cfr = 2;
+ else
+ job->cfr = 1;
}
const GValue *audio_list;