}
}
+static options_map_t d_point_to_point_opts[] =
+{
+ {"Chapters:", "chapter", 0, "0"},
+ {"Seconds:", "time", 1, "1"},
+ {"Frames:", "frame", 2, "2"},
+};
+combo_opts_t point_to_point_opts =
+{
+ sizeof(d_point_to_point_opts)/sizeof(options_map_t),
+ d_point_to_point_opts
+};
+
static options_map_t d_when_complete_opts[] =
{
{"Do Nothing", "nothing", 0, "0"},
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 =
{
combo_name_map_t combo_name_map[] =
{
+ {"PtoPType", &point_to_point_opts},
{"WhenComplete", &when_complete_opts},
{"PicturePAR", &par_opts},
{"PictureModulus", &alignment_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;
}
gint result;
if (codec == HB_ACODEC_FAAC)
- high = 160;
+ high = 320;
result = high;
for (ii = 0; ii < hb_audio_bitrates_count; ii++)
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;
}
return result;
}
-static GValue*
-get_acodec_value(gint val)
+GValue*
+ghb_lookup_acodec_value(gint val)
{
GValue *value = NULL;
gint ii;
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;
}
static hb_handle_t * h_scan = NULL;
static hb_handle_t * h_queue = NULL;
-extern void hb_get_tempory_directory(hb_handle_t *h, char path[512]);
+extern void hb_get_temporary_directory(char path[512]);
gchar*
ghb_get_tmp_dir()
{
char dir[512];
- hb_get_tempory_directory(h_scan, dir);
+ hb_get_temporary_directory(dir);
return g_strdup(dir);
}
{
char dir[512];
- hb_get_tempory_directory(h_scan, dir);
+ hb_get_temporary_directory(dir);
del_tree(dir, !partial);
}
}
const char*
+ghb_subtitle_source_name(gint source)
+{
+ const gchar * name = "Unknown";
+ switch (source)
+ {
+ case VOBSUB:
+ name = "VOBSUB";
+ break;
+ case TX3GSUB:
+ name = "TX3G";
+ break;
+ case UTF8SUB:
+ name = "UTF8";
+ break;
+ case CC708SUB:
+ case CC608SUB:
+ name = "CC";
+ break;
+ case SRTSUB:
+ name = "SRT";
+ break;
+ case SSASUB:
+ name = "SSA";
+ break;
+ default:
+ break;
+ }
+ return name;
+}
+
+const char*
ghb_subtitle_track_source_name(signal_user_data_t *ud, gint track)
{
gint titleindex;
sub = hb_list_item( title->list_subtitle, track);
if (sub != NULL)
{
- switch (sub->source)
- {
- case VOBSUB:
- name = "Bitmap";
- break;
- case CC708SUB:
- case CC608SUB:
- name = "Text";
- break;
- case SRTSUB:
- name = "SRT";
- break;
- default:
- break;
- }
+ name = ghb_subtitle_source_name(sub->source);
}
done:
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);
}
if (container == HB_MUX_MP4)
{
- grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_LAME, TRUE);
grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_VORBIS, TRUE);
grey_combo_box_item(builder, "VideoEncoder", HB_VCODEC_THEORA, TRUE);
}
gboolean allow_dolby = TRUE;
gboolean allow_dpl2 = TRUE;
gboolean allow_6ch = TRUE;
- allow_mono = acodec & ~HB_ACODEC_LAME;
+ allow_mono = TRUE;
allow_6ch = acodec & ~HB_ACODEC_LAME;
if (audio)
{
- allow_mono = allow_mono &&
- (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA));
gint layout = audio->in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK;
allow_stereo =
((layout == HB_INPUT_CH_LAYOUT_MONO && !allow_mono) || layout >= HB_INPUT_CH_LAYOUT_STEREO);
(layout == HB_INPUT_CH_LAYOUT_DOLBY);
allow_dpl2 = (layout == HB_INPUT_CH_LAYOUT_3F2R);
allow_6ch = allow_6ch &&
- (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) &&
(layout == HB_INPUT_CH_LAYOUT_3F2R) &&
(audio->in.channel_layout & HB_INPUT_CH_LAYOUT_HAS_LFE);
}
{
if (acodec & HB_ACODEC_FAAC)
{
- int maxbr = channels * 80;
+ int maxbr;
+
+ if (channels == 2)
+ maxbr = 320;
+ else
+ maxbr = 768;
if (br > maxbr)
br = maxbr;
}
audio = get_hb_audio(titleindex, track);
if (audio)
{
- allow_mono =
- (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) &&
- (acodec & ~HB_ACODEC_LAME);
+ allow_mono = TRUE;
gint layout = audio->in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK;
allow_stereo =
((layout == HB_INPUT_CH_LAYOUT_MONO && !allow_mono) || layout >= HB_INPUT_CH_LAYOUT_STEREO);
(layout == HB_INPUT_CH_LAYOUT_DOLBY);
allow_dpl2 = (layout == HB_INPUT_CH_LAYOUT_3F2R);
allow_6ch =
- (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) &&
(acodec & ~HB_ACODEC_LAME) &&
(layout == HB_INPUT_CH_LAYOUT_3F2R) &&
(audio->in.channel_layout & HB_INPUT_CH_LAYOUT_HAS_LFE);
for (ii = 0; ii < count; ii++)
{
title = (hb_title_t*)hb_list_item(list, ii);
- if (title->duration != 0)
+ if (title->type == HB_STREAM_TYPE)
{
- titles[ii] = g_strdup_printf ("%d - %02dh%02dm%02ds",
- title->index, title->hours, title->minutes, title->seconds);
+ if (title->duration != 0)
+ {
+ titles[ii] = g_strdup_printf ("%d - %02dh%02dm%02ds - %s",
+ title->index, title->hours, title->minutes, title->seconds,
+ title->name);
+ }
+ else
+ {
+ titles[ii] = g_strdup_printf ("%d - %s",
+ title->index, title->name);
+ }
}
else
{
- titles[ii] = g_strdup_printf ("%d - Unknown Length", title->index);
+ if (title->duration != 0)
+ {
+ titles[ii] = g_strdup_printf ("%d - %02dh%02dm%02ds",
+ title->index, title->hours, title->minutes, title->seconds);
+ }
+ else
+ {
+ titles[ii] = g_strdup_printf ("%d - Unknown Length",
+ title->index);
+ }
}
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
subtitle = (hb_subtitle_t *)hb_list_item(title->list_subtitle, ii);
// Skip subtitles that must be burned if there is already
// a burned subtitle in the list
- options[ii] = g_strdup_printf("%d - %s", ii+1, subtitle->lang);
+#if 0
+ if (subtitle->source == VOBSUB)
+ {
+ options[ii] = g_strdup_printf("%d - %s", ii+1, subtitle->lang);
+ }
+ else
+#endif
+ {
+ options[ii] = g_strdup_printf("%d - %s (%s)", ii+1,
+ subtitle->lang,
+ ghb_subtitle_source_name(subtitle->source));
+ }
subtitle_opts.map[ii+1].option = options[ii];
subtitle_opts.map[ii+1].shortOpt = index_str[ii];
subtitle_opts.map[ii+1].ivalue = ii;
hb_title_t * title;
gint ii;
gint count = 0;
- guint64 longest = 0;
gint titleindex = 0;
+ gint feature;
g_debug("ghb_longest_title ()\n");
if (h_scan == NULL) return 0;
list = hb_get_titles( h_scan );
count = hb_list_count( list );
if (count > 100) count = 100;
+ if (count < 1) return 0;
+ title = (hb_title_t*)hb_list_item(list, 0);
+ feature = title->job->feature;
for (ii = 0; ii < count; ii++)
{
title = (hb_title_t*)hb_list_item(list, ii);
- if (title->duration > longest)
+ if (title->index == feature)
{
- titleindex = ii;
- longest = title->duration;
+ return ii;
}
}
return titleindex;
return lang;
}
+static gboolean*
+get_track_used(gint acodec, GHashTable *track_indices, gint count)
+{
+ gboolean *used;
+
+ used = g_hash_table_lookup(track_indices, &acodec);
+ if (used == NULL)
+ {
+ gint *key;
+
+ used = g_malloc0(count * sizeof(gboolean));
+ key = g_malloc(sizeof(gint));
+ *key = acodec;
+ g_hash_table_insert(track_indices, key, used);
+ }
+ return used;
+}
+
gint
ghb_find_audio_track(
gint titleindex,
const gchar *lang,
gint acodec,
+ gint fallback_acodec,
GHashTable *track_indices)
{
hb_list_t * list;
hb_title_t * title;
- hb_audio_config_t * audio;
+ hb_audio_config_t * audio;
gint ii;
gint count = 0;
gint track = -1;
- gint max_chan = 0;
- gboolean *used;
+ 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;
list = hb_get_titles( h_scan );
- title = (hb_title_t*)hb_list_item( list, titleindex );
+ title = (hb_title_t*)hb_list_item( list, titleindex );
if (title != NULL)
{
count = hb_list_count( title->list_audio );
}
if (count > 10) count = 10;
- used = g_hash_table_lookup(track_indices, &acodec);
- if (used == NULL)
- {
- used = g_malloc0(count * sizeof(gboolean));
- g_hash_table_insert(track_indices, &acodec, used);
- }
// Try to find an item that matches the preferred language and
// the passthru codec type
- if (acodec & (HB_ACODEC_AC3 | HB_ACODEC_DCA))
+ 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;
+ // Is the source track use a passthru capable codec?
+ if (passthru_acodec == 0)
+ continue;
+ used = get_track_used(passthru_acodec, track_indices, count);
+ // Has the track already been used with this codec?
if (used[ii])
continue;
- audio = (hb_audio_config_t*)hb_list_audio_config_item(
- title->list_audio, ii );
channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT(
audio->in.channel_layout);
// Find a track that is not visually impaired or dirctor's
// commentary, and has the highest channel count.
- if ((audio->in.codec & acodec) &&
- (audio->lang.type < 2) &&
+ if ((audio->lang.type < 2) &&
((strcmp(lang, audio->lang.iso639_2) == 0) ||
(strcmp(lang, "und") == 0)))
{
}
}
}
+ try_acodec = fallback_acodec;
+ }
+ else
+ {
+ try_acodec = acodec;
}
if (track > -1)
{
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++)
{
+ // Has the track already been used with this codec?
if (used[ii])
continue;
- audio = (hb_audio_config_t*)hb_list_audio_config_item(
- title->list_audio, 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;
+ if (passthru_acodec && passthru)
+ {
+ passthru_used = get_track_used(passthru_acodec, track_indices, count);
+ // Has the track already been used with this codec for passthru?
+ 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
- if (acodec & (HB_ACODEC_AC3 | HB_ACODEC_DCA))
+ 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;
+ // Is the source track use a passthru capable codec?
+ if (passthru_acodec == 0)
+ continue;
+ used = get_track_used(passthru_acodec, track_indices, count);
+ // Has the track already been used with this codec?
if (used[ii])
continue;
- audio = (hb_audio_config_t*)hb_list_audio_config_item(
- title->list_audio, ii );
channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT(
audio->in.channel_layout);
// Find a track that is not visually impaired or dirctor's
// commentary, and has the highest channel count.
- if ((audio->in.codec & acodec) &&
- (audio->lang.type < 2))
+ if (audio->lang.type < 2)
{
if (channels > max_chan)
{
}
}
}
+ try_acodec = fallback_acodec;
+ }
+ else
+ {
+ try_acodec = acodec;
}
if (track > -1)
{
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++)
{
+ // Has the track already been used with this codec?
if (used[ii])
continue;
- audio = (hb_audio_config_t*)hb_list_audio_config_item(
+ 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);
+ // Has the track already been used with this codec for passthru?
+ if (passthru_used[ii])
+ continue;
+ }
// 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)
// Last ditch, anything goes
for (ii = 0; ii < count; ii++)
{
- audio = (hb_audio_config_t*)hb_list_audio_config_item(
- title->list_audio, 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;
+ if (passthru_acodec && passthru)
+ {
+ passthru_used = get_track_used(passthru_acodec, track_indices, count);
+ // Has the track already been used with this codec for passthru?
+ if (passthru_used[ii])
+ continue;
+ }
+ // Has the track already been used with this codec?
if (!used[ii])
{
track = ii;
continue;
subtitle = (hb_subtitle_t*)hb_list_item( title->list_subtitle, ii );
- if (((burn || force) && (subtitle->source == VOBSUB)) &&
+ if ((!(burn || force) || (subtitle->source == VOBSUB)) &&
((strcmp(lang, subtitle->iso639_2) == 0) ||
(strcmp(lang, "und") == 0)))
{
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)
audio_track_opts_set(ud->builder, "AudioTrack", user_data);
subtitle_track_opts_set(ud->builder, "SubtitleTrack", user_data);
generic_opts_set(ud->builder, "VideoQualityGranularity", &vqual_granularity_opts);
+ generic_opts_set(ud->builder, "PtoPType", &point_to_point_opts);
generic_opts_set(ud->builder, "WhenComplete", &when_complete_opts);
generic_opts_set(ud->builder, "PicturePAR", &par_opts);
generic_opts_set(ud->builder, "PictureModulus", &alignment_opts);
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_part_duration(gint tt, gint sc, gint ec, gint *hh, gint *mm, gint *ss)
+{
+ hb_list_t * list;
+ hb_title_t * title;
+ hb_chapter_t * chapter;
+ gint count, c;
+ gint64 duration;
+
+ *hh = *mm = *ss = 0;
+ if (h_scan == NULL) return;
+ list = hb_get_titles( h_scan );
+ title = (hb_title_t*)hb_list_item( list, tt );
+ if (title == NULL) return;
+
+ *hh = title->hours;
+ *mm = title->minutes;
+ *ss = title->seconds;
+
+ count = hb_list_count(title->list_chapter);
+ if (sc > count) sc = count;
+ if (ec > count) ec = count;
+
+ if (sc == 1 && ec == count)
+ return;
+
+ duration = 0;
+ for (c = sc; c <= ec; c++)
+ {
+ chapter = hb_list_item(title->list_chapter, c-1);
+ duration += chapter->duration;
+ }
+
+ *hh = duration / 90000 / 3600;
+ *mm = ((duration / 90000) % 3600) / 60;
+ *ss = (duration / 90000) % 60;
+}
+
+void
ghb_get_chapter_duration(gint ti, gint ii, gint *hh, gint *mm, gint *ss)
{
hb_list_t * list;
{
hb_close(&h_queue);
hb_close(&h_scan);
+ hb_global_close();
+}
+
+void ghb_backend_scan_stop()
+{
+ hb_scan_stop( h_scan );
}
void
case HB_STATE_WORKING:
hb_status.queue.state |= GHB_STATE_WORKING;
hb_status.queue.state &= ~GHB_STATE_PAUSED;
+ hb_status.queue.state &= ~GHB_STATE_SEARCHING;
+ hb_status.queue.job_cur = p.job_cur;
+ hb_status.queue.job_count = p.job_count;
+ hb_status.queue.progress = p.progress;
+ hb_status.queue.rate_cur = p.rate_cur;
+ hb_status.queue.rate_avg = p.rate_avg;
+ hb_status.queue.hours = p.hours;
+ hb_status.queue.minutes = p.minutes;
+ hb_status.queue.seconds = p.seconds;
+ hb_status.queue.unique_id = p.sequence_id & 0xFFFFFF;
+ break;
+
+ case HB_STATE_SEARCHING:
+ hb_status.queue.state |= GHB_STATE_SEARCHING;
+ hb_status.queue.state &= ~GHB_STATE_WORKING;
+ hb_status.queue.state &= ~GHB_STATE_PAUSED;
hb_status.queue.job_cur = p.job_cur;
hb_status.queue.job_count = p.job_count;
hb_status.queue.progress = p.progress;
hb_status.queue.state &= ~GHB_STATE_MUXING;
hb_status.queue.state &= ~GHB_STATE_PAUSED;
hb_status.queue.state &= ~GHB_STATE_WORKING;
+ hb_status.queue.state &= ~GHB_STATE_SEARCHING;
switch (p.error)
{
case HB_ERROR_NONE:
return FALSE;
}
- title = hb_list_item( list, titleindex );
+ title = hb_list_item( list, titleindex );
if (title == NULL) return FALSE; // Bad titleindex
+ tinfo->index = titleindex;
tinfo->width = title->width;
tinfo->height = title->height;
memcpy(tinfo->crop, title->crop, 4 * sizeof(int));
tinfo->duration = title->duration;
tinfo->angle_count = title->angle_count;
+ tinfo->path = title->path;
+ tinfo->name = title->name;
+ tinfo->type = title->type;
return TRUE;
}
static gboolean busy = FALSE;
g_debug("ghb_set_scale ()\n");
+ picture_settings_deps(ud);
if (h_scan == NULL) return;
list = hb_get_titles( h_scan );
if( !hb_list_count( list ) )
job = title->job;
if (job == NULL) return;
- picture_settings_deps(ud);
if (busy) return;
busy = TRUE;
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->anamorphic.modulus = mod;
+ job->modulus = mod;
job->anamorphic.par_width = title->pixel_aspect_width;
job->anamorphic.par_height = title->pixel_aspect_height;
job->anamorphic.dar_width = 0;
job->crop[3] = ghb_settings_get_int(settings, "PictureRightCrop");
job->anamorphic.mode = ghb_settings_combo_int(settings, "PicturePAR");
- job->anamorphic.modulus =
+ job->modulus =
ghb_settings_combo_int(settings, "PictureModulus");
job->width = ghb_settings_get_int(settings, "scale_width");
job->height = ghb_settings_get_int(settings, "scale_height");
job->crop[1] = 0;
job->crop[2] = 0;
job->crop[3] = 0;
- job->anamorphic.modulus = 2;
+ job->modulus = 2;
}
gboolean decomb_deint = ghb_settings_get_boolean(settings, "PictureDecombDeinterlace");
titleindex = ghb_settings_combo_int(ud->settings, "title");
title = hb_list_item( list, titleindex );
if (title == NULL) return FALSE;
- gint mux = ghb_settings_combo_int(ud->settings, "FileFormat");
const GValue *slist, *settings;
gint count, ii, source;
{
one_burned = TRUE;
}
- if (!burned && mux == HB_MUX_MP4 && source == VOBSUB)
- {
- // MP4 can only handle burned vobsubs. make sure there isn't
- // already something burned in the list
- message = g_strdup_printf(
- "Your chosen container does not support soft bitmap subtitles.\n\n"
- "You should change your subtitle selections.\n"
- "If you continue, some subtitles will be lost.");
- if (!ghb_message_dialog(GTK_MESSAGE_WARNING, message,
- "Cancel", "Continue"))
- {
- g_free(message);
- return FALSE;
- }
- g_free(message);
- break;
- }
if (source == SRTSUB)
{
gchar *filename;
{
codec = HB_ACODEC_FAAC;
}
- value = get_acodec_value(codec);
+ value = ghb_lookup_acodec_value(codec);
ghb_settings_take_value(asettings, "AudioEncoder", value);
}
gchar *a_unsup = NULL;
if (mux == HB_MUX_MP4)
{
mux_s = "MP4";
- // mp4/mp3|vorbis combination is not supported.
- if (codec == HB_ACODEC_LAME)
- {
- a_unsup = "MP3";
- codec = HB_ACODEC_FAAC;
- }
+ // mp4/vorbis|DTS combination is not supported.
if (codec == HB_ACODEC_VORBIS)
{
a_unsup = "Vorbis";
return FALSE;
}
g_free(message);
- value = get_acodec_value(codec);
+ value = ghb_lookup_acodec_value(codec);
ghb_settings_take_value(asettings, "AudioEncoder", value);
}
gint mix = ghb_settings_combo_int (asettings, "AudioMixdown");
gboolean allow_dolby = TRUE;
gboolean allow_dpl2 = TRUE;
gboolean allow_6ch = TRUE;
- allow_mono =
- (taudio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) &&
- (codec & ~HB_ACODEC_LAME);
+ allow_mono = TRUE;
gint layout = taudio->in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK;
allow_stereo =
((layout == HB_INPUT_CH_LAYOUT_MONO && !allow_mono) || layout >= HB_INPUT_CH_LAYOUT_STEREO);
(layout == HB_INPUT_CH_LAYOUT_DOLBY);
allow_dpl2 = (layout == HB_INPUT_CH_LAYOUT_3F2R);
allow_6ch =
- (taudio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) &&
(codec & ~HB_ACODEC_LAME) &&
(layout == HB_INPUT_CH_LAYOUT_3F2R) &&
(taudio->in.channel_layout & HB_INPUT_CH_LAYOUT_HAS_LFE);
}
if (!job->start_at_preview)
{
- gint chapter_start, chapter_end;
- chapter_start = ghb_settings_get_int(js, "start_chapter");
- chapter_end = ghb_settings_get_int(js, "end_chapter");
+ gint start, end;
gint num_chapters = hb_list_count(title->list_chapter);
- job->chapter_start = MIN( num_chapters, chapter_start );
- job->chapter_end = MAX( job->chapter_start, chapter_end );
+ gint duration = title->duration / 90000;
+ job->chapter_start = 1;
+ job->chapter_end = num_chapters;
+
+ if (ghb_settings_combo_int(js, "PtoPType") == 0)
+ {
+ start = ghb_settings_get_int(js, "start_point");
+ end = ghb_settings_get_int(js, "end_point");
+ job->chapter_start = MIN( num_chapters, start );
+ job->chapter_end = MAX( job->chapter_start, end );
+ }
+ if (ghb_settings_combo_int(js, "PtoPType") == 1)
+ {
+ job->chapter_start = 1;
+ job->chapter_end = num_chapters;
+ start = ghb_settings_get_int(js, "start_point");
+ end = ghb_settings_get_int(js, "end_point");
+ job->pts_to_start = (int64_t)MIN(duration-1, start) * 90000;
+ job->pts_to_stop = (int64_t)MAX(start+1, end) * 90000 -
+ job->pts_to_start;
+ }
+ if (ghb_settings_combo_int(js, "PtoPType") == 2)
+ {
+ job->chapter_start = 1;
+ job->chapter_end = num_chapters;
+ start = ghb_settings_get_int(js, "start_point");
+ end = ghb_settings_get_int(js, "end_point");
+ gint64 max_frames;
+ max_frames = (gint64)duration * title->rate / title->rate_base;
+ job->frame_to_start = (int64_t)MIN(max_frames-1, start-1);
+ job->frame_to_stop = (int64_t)MAX(start, end-1) -
+ job->frame_to_start;
+ }
job->chapter_markers = ghb_settings_get_boolean(js, "ChapterMarkers");
if (job->chapter_start == job->chapter_end)
job->chapter_markers = 0;
GValue *chapter;
gint chap;
gint count;
-
+
chapters = ghb_settings_get_value(js, "chapter_list");
count = ghb_array_len(chapters);
- for(chap = chapter_start; chap <= chapter_end; chap++)
+ for(chap = 0; chap < count; chap++)
{
hb_chapter_t * chapter_s;
gchar *name;
-
+
name = NULL;
- if (chap-1 < count)
- {
- chapter = ghb_array_get_nth(chapters, chap-1);
- name = ghb_value_string(chapter);
- }
+ chapter = ghb_array_get_nth(chapters, chap);
+ name = ghb_value_string(chapter);
if (name == NULL)
{
- name = g_strdup_printf ("Chapter %2d", chap);
+ name = g_strdup_printf ("Chapter %2d", chap+1);
}
- chapter_s = hb_list_item( job->title->list_chapter, chap - 1);
+ chapter_s = hb_list_item( job->title->list_chapter, chap);
strncpy(chapter_s->title, name, 1023);
chapter_s->title[1023] = '\0';
g_free(name);
gboolean keep_aspect;
keep_aspect = ghb_settings_get_boolean(js, "PictureKeepRatio");
job->anamorphic.mode = ghb_settings_combo_int(js, "PicturePAR");
- job->anamorphic.modulus = ghb_settings_combo_int(js, "PictureModulus");
+ job->modulus = ghb_settings_combo_int(js, "PictureModulus");
if (job->anamorphic.mode)
{
job->anamorphic.par_width = title->pixel_aspect_width;
{
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;
}
}
if ((job->mux == HB_MUX_MP4) &&
- ((audio.out.codec & HB_ACODEC_LAME) ||
- (audio.out.codec & HB_ACODEC_DCA) ||
+ ((audio.out.codec & HB_ACODEC_DCA) ||
(audio.out.codec & HB_ACODEC_VORBIS)))
{
// mp4/mp3|dts|vorbis combination is not supported.
subtitle = ghb_settings_get_int(ssettings, "SubtitleTrack");
if (subtitle == -1)
{
- if (!burned && job->mux == HB_MUX_MKV)
+ if (!burned)
{
job->select_subtitle_config.dest = PASSTHRUSUB;
}
- else if (!burned && job->mux == HB_MUX_MP4)
- {
- // Skip any non-burned vobsubs when output is mp4
- continue;
- }
else if (burned)
{
// Only allow one subtitle to be burned into the video
hb_subtitle_config_t sub_config;
subt = (hb_subtitle_t *)hb_list_item(title->list_subtitle, subtitle);
- sub_config = subt->config;
if (subt != NULL)
{
- if (!burned && job->mux == HB_MUX_MKV &&
- subt->format == PICTURESUB)
+ sub_config = subt->config;
+ if (!burned && subt->format == PICTURESUB)
{
sub_config.dest = PASSTHRUSUB;
}
- else if (!burned && job->mux == HB_MUX_MP4 &&
- subt->format == PICTURESUB)
- {
- // Skip any non-burned vobsubs when output is mp4
- continue;
- }
else if ( burned && subt->format == PICTURESUB )
{
// Only allow one subtitle to be burned into the video