GValue*
ghb_resource_parse(const gchar *buf, gssize len)
{
GMarkupParseContext *ctx;
GMarkupParser parser;
parse_data_t pd;
GError *err = NULL;
pd.stack = g_queue_new();
pd.tag_stack = g_queue_new();
pd.key = NULL;
pd.value = NULL;
pd.plist = ghb_dict_value_new();
g_queue_push_head(pd.stack, pd.plist);
pd.closed_top = FALSE;
parser.start_element = start_element;
parser.end_element = end_element;
parser.text = text_data;
parser.passthrough = passthrough;
parser.error = parse_error;
ctx = g_markup_parse_context_new(&parser, 0, &pd, destroy_notify);
g_markup_parse_context_parse(ctx, buf, len, &err);
g_markup_parse_context_end_parse(ctx, &err);
g_markup_parse_context_free(ctx);
g_queue_free(pd.stack);
g_queue_free(pd.tag_stack);
return pd.plist;
}
void
ghb_set_audio(signal_user_data_t *ud, GValue *settings)
{
gint acodec_code;
GValue *alist;
GValue *track, *audio, *acodec, *acodec_actual, *bitrate, *rate,
*mix, *drc, *gain, *quality, *enable_quality;
gint count, ii;
g_debug("set_audio");
// Clear the audio list
ghb_clear_audio_list_settings(ud->settings);
ghb_clear_audio_list_ui(ud->builder);
alist = ghb_settings_get_value(settings, "audio_list");
count = ghb_array_len(alist);
for (ii = 0; ii < count; ii++)
{
audio = ghb_array_get_nth(alist, ii);
track = ghb_settings_get_value(audio, "AudioTrack");
acodec = ghb_settings_get_value(audio, "AudioEncoder");
acodec_actual = ghb_settings_get_value(audio, "AudioEncoderActual");
enable_quality = ghb_settings_get_value(audio, "AudioTrackQualityEnable");
quality = ghb_settings_get_value(audio, "AudioTrackQuality");
bitrate = ghb_settings_get_value(audio, "AudioBitrate");
rate = ghb_settings_get_value(audio, "AudioSamplerate");
mix = ghb_settings_get_value(audio, "AudioMixdown");
gain = ghb_settings_get_value(audio, "AudioTrackGain");
drc = ghb_settings_get_value(audio, "AudioTrackDRCSlider");
acodec_code = ghb_lookup_combo_int("AudioEncoder", acodec);
if (acodec_code != 0)
{
GValue *asettings = ghb_dict_value_new();
ghb_settings_set_value(asettings, "AudioTrack", track);
ghb_settings_set_value(asettings, "AudioEncoder", acodec);
ghb_settings_set_value(asettings, "AudioEncoderActual", acodec_actual);
ghb_settings_set_value(asettings, "AudioTrackQualityEnable", enable_quality);
ghb_settings_set_value(asettings, "AudioTrackQuality", quality);
// This gets set autimatically if the codec is passthru
ghb_settings_set_value(asettings, "AudioBitrate", bitrate);
ghb_settings_set_value(asettings, "AudioSamplerate", rate);
ghb_settings_set_value(asettings, "AudioMixdown", mix);
ghb_settings_set_value(asettings, "AudioTrackGain", gain);
ghb_settings_set_value(asettings, "AudioTrackDRCSlider", drc);
ghb_add_audio_to_settings(ud->settings, asettings);
ghb_add_audio_to_ui(ud->builder, asettings);
ghb_adjust_audio_rate_combos(ud);
}
}
check_list_full(ud);
}
G_MODULE_EXPORT void
audio_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
{
// Add the current audio settings to the list.
GValue *asettings;
GtkWidget *widget;
g_debug("audio_add_clicked_cb ()");
asettings = ghb_dict_value_new();
widget = GHB_WIDGET(ud->builder, "AudioTrack");
ghb_settings_take_value(asettings, "AudioTrack", ghb_widget_value(widget));
widget = GHB_WIDGET(ud->builder, "AudioEncoder");
ghb_settings_take_value(asettings, "AudioEncoder", ghb_widget_value(widget));
ghb_settings_set_value(asettings, "AudioEncoderActual",
ghb_settings_get_value(ud->settings, "AudioEncoderActual"));
widget = GHB_WIDGET(ud->builder, "AudioTrackQualityEnable");
ghb_settings_take_value(asettings, "AudioTrackQualityEnable", ghb_widget_value(widget));
widget = GHB_WIDGET(ud->builder, "AudioTrackQuality");
ghb_settings_take_value(asettings, "AudioTrackQuality", ghb_widget_value(widget));
widget = GHB_WIDGET(ud->builder, "AudioBitrate");
ghb_settings_take_value(asettings, "AudioBitrate", ghb_widget_value(widget));
widget = GHB_WIDGET(ud->builder, "AudioSamplerate");
ghb_settings_take_value(asettings, "AudioSamplerate", ghb_widget_value(widget));
widget = GHB_WIDGET(ud->builder, "AudioMixdown");
ghb_settings_take_value(asettings, "AudioMixdown", ghb_widget_value(widget));
widget = GHB_WIDGET(ud->builder, "AudioTrackGain");
ghb_settings_take_value(asettings, "AudioTrackGain", ghb_widget_value(widget));
widget = GHB_WIDGET(ud->builder, "AudioTrackDRCSlider");
ghb_settings_take_value(asettings, "AudioTrackDRCSlider", ghb_widget_value(widget));
if (!ghb_add_audio_to_settings(ud->settings, asettings))
return;
ghb_add_audio_to_ui(ud->builder, asettings);
check_list_full(ud);
}
static void
start_element(
GMarkupParseContext *ctx,
const gchar *tag,
const gchar **attr_names,
const gchar **attr_values,
gpointer ud,
GError **error)
{
parse_data_t *pd = (parse_data_t*)ud;
union
{
gint id;
gpointer pid;
} id;
gint ii;
// Check to see if the first element found has been closed
// If so, ignore any junk following it.
if (pd->closed_top)
return;
for (ii = 0; ii < TAG_MAP_SZ; ii++)
{
if (strcmp(tag, tag_map[ii].tag) == 0)
{
id.id = tag_map[ii].id;
break;
}
}
if (ii == TAG_MAP_SZ)
{
g_warning("Unrecognized start tag (%s)", tag);
return;
}
g_queue_push_head(pd->tag_stack, id.pid);
GType gtype = 0;
GValue *gval = NULL;
GValue *current = g_queue_peek_head(pd->stack);
switch (id.id)
{
case R_SECTION:
{
const gchar *name;
name = lookup_attr_value("name", attr_names, attr_values);
if (name && strcmp(name, "icons") == 0)
{
gval = ghb_dict_value_new();
if (pd->key) g_free(pd->key);
pd->key = g_strdup(name);
g_queue_push_head(pd->stack, gval);
}
} break;
case R_ICON:
{
gchar *filename;
const gchar *name;
name = lookup_attr_value("file", attr_names, attr_values);
filename = find_file(inc_list, name);
name = lookup_attr_value("name", attr_names, attr_values);
if (filename && name)
{
ghb_rawdata_t *rd;
GdkPixbuf *pb;
GError *err = NULL;
pb = gdk_pixbuf_new_from_file(filename, &err);
if (pb == NULL)
{
g_warning("Failed to open icon file %s: %s", filename, err->message);
break;
}
gval = ghb_dict_value_new();
int colorspace = gdk_pixbuf_get_colorspace(pb);
gboolean alpha = gdk_pixbuf_get_has_alpha(pb);
int width = gdk_pixbuf_get_width(pb);
int height = gdk_pixbuf_get_height(pb);
int bps = gdk_pixbuf_get_bits_per_sample(pb);
int rowstride = gdk_pixbuf_get_rowstride(pb);
ghb_dict_insert(gval, g_strdup("colorspace"),
ghb_int_value_new(colorspace));
ghb_dict_insert(gval, g_strdup("alpha"),
ghb_boolean_value_new(alpha));
ghb_dict_insert(gval, g_strdup("width"),
ghb_int_value_new(width));
ghb_dict_insert(gval, g_strdup("height"),
ghb_int_value_new(height));
ghb_dict_insert(gval, g_strdup("bps"),
ghb_int_value_new(bps));
ghb_dict_insert(gval, g_strdup("rowstride"),
ghb_int_value_new(rowstride));
rd = g_malloc(sizeof(ghb_rawdata_t));
rd->data = gdk_pixbuf_get_pixels(pb);
rd->size = height * rowstride * bps / 8;
GValue *data = ghb_rawdata_value_new(rd);
ghb_dict_insert(gval, g_strdup("data"), data);
if (pd->key) g_free(pd->key);
pd->key = g_strdup(name);
g_free(filename);
}
else
{
g_warning("%s:missing a requried attribute", name);
exit(EXIT_FAILURE);
}
} break;
case R_PLIST:
{
gchar *filename;
const gchar *name;
name = lookup_attr_value("file", attr_names, attr_values);
filename = find_file(inc_list, name);
name = lookup_attr_value("name", attr_names, attr_values);
if (filename && name)
{
gval = ghb_plist_parse_file(filename);
if (pd->key) g_free(pd->key);
pd->key = g_strdup(name);
g_free(filename);
}
else
{
g_warning("%s:missing a requried attribute", name);
exit(EXIT_FAILURE);
}
} break;
case R_STRING:
{
gchar *filename;
const gchar *name;
name = lookup_attr_value("file", attr_names, attr_values);
filename = find_file(inc_list, name);
name = lookup_attr_value("name", attr_names, attr_values);
if (filename && name)
{
gval = read_string_from_file(filename);
if (pd->key) g_free(pd->key);
pd->key = g_strdup(name);
g_free(filename);
}
else
{
g_warning("%s:missing a requried attribute", name);
exit(EXIT_FAILURE);
}
} break;
}
// Add the element to the current container
if (gval)
{ // There's an element to add
if (current == NULL)
{
pd->plist = gval;
return;
}
gtype = G_VALUE_TYPE(current);
if (gtype == ghb_array_get_type())
{
ghb_array_append(current, gval);
}
else if (gtype == ghb_dict_get_type())
{
if (pd->key == NULL)
{
g_warning("No key for dictionary item");
ghb_value_free(gval);
}
else
{
ghb_dict_insert(current, g_strdup(pd->key), gval);
}
}
else
{
g_error("Invalid container type. This shouldn't happen");
}
}
}
static GValue* subtitle_add_track(
signal_user_data_t *ud,
GValue *settings,
const hb_title_t *title,
int track,
int mux,
gboolean default_track,
gboolean srt,
gboolean *burned)
{
int source = 0;
if (track >= 0 && !srt)
{
hb_subtitle_t *subtitle = hb_list_item(title->list_subtitle, track);
source = subtitle->source;
}
else if (srt)
{
source = SRTSUB;
}
if (*burned && !hb_subtitle_can_pass(source, mux))
{
// Can only burn one. Skip others that must be burned.
return NULL;
}
GValue *subsettings = ghb_dict_value_new();
ghb_settings_set_int(subsettings, "SubtitleTrack", track);
ghb_settings_set_int(subsettings, "SubtitleSource", source);
// Set default SRT settings
gchar *pref_lang, *dir, *filename;
pref_lang = ghb_settings_get_string(settings, "PreferredLanguage");
ghb_settings_set_string(subsettings, "SrtLanguage", pref_lang);
g_free(pref_lang);
ghb_settings_set_string(subsettings, "SrtCodeset", "UTF-8");
dir = ghb_settings_get_string(ud->prefs, "SrtDir");
filename = g_strdup_printf("%s/none", dir);
ghb_settings_set_string(subsettings, "SrtFile", filename);
g_free(dir);
g_free(filename);
ghb_settings_set_int(subsettings, "SrtOffset", 0);
subtitle_set_track_description(settings, subsettings);
if (!hb_subtitle_can_pass(source, mux))
{
ghb_settings_set_boolean(subsettings, "SubtitleBurned", TRUE);
*burned = TRUE;
}
else
{
ghb_settings_set_boolean(subsettings, "SubtitleBurned", FALSE);
}
if (track == -1)
{
// Foreign audio search "track"
ghb_settings_set_boolean(subsettings, "SubtitleForced", TRUE);
}
else
{
ghb_settings_set_boolean(subsettings, "SubtitleForced", FALSE);
}
if (default_track)
{
ghb_settings_set_boolean(subsettings, "SubtitleDefaultTrack", TRUE);
}
else
{
ghb_settings_set_boolean(subsettings, "SubtitleDefaultTrack", FALSE);
}
subtitle_add_to_settings(settings, subsettings);
return subsettings;
}
static void
start_element(
GMarkupParseContext *ctx,
const gchar *name,
const gchar **attr_names,
const gchar **attr_values,
gpointer ud,
GError **error)
{
parse_data_t *pd = (parse_data_t*)ud;
union
{
gint id;
gpointer pid;
} id;
gint ii;
// Check to see if the first element found has been closed
// If so, ignore any junk following it.
if (pd->closed_top)
return;
for (ii = 0; ii < TAG_MAP_SZ; ii++)
{
if (strcmp(name, tag_map[ii].tag) == 0)
{
id.id = tag_map[ii].id;
break;
}
}
if (ii == TAG_MAP_SZ)
{
g_warning("Unrecognized start tag (%s)", name);
return;
}
g_queue_push_head(pd->tag_stack, id.pid);
GType gtype = 0;
GValue *gval = NULL;
GValue *current = g_queue_peek_head(pd->stack);
switch (id.id)
{
case P_PLIST:
{ // Ignore
} break;
case P_KEY:
{
if (pd->key) g_free(pd->key);
pd->key = NULL;
} break;
case P_DICT:
{
gval = ghb_dict_value_new();
g_queue_push_head(pd->stack, gval);
} break;
case P_ARRAY:
{
gval = ghb_array_value_new(128);
g_queue_push_head(pd->stack, gval);
} break;
case P_INTEGER:
{
} break;
case P_REAL:
{
} break;
case P_STRING:
{
} break;
case P_DATE:
{
} break;
case P_TRUE:
{
} break;
case P_FALSE:
{
} break;
case P_DATA:
{
} break;
}
// Add the element to the current container
if (gval)
{ // There's an element to add
if (current == NULL)
{
pd->plist = gval;
return;
}
gtype = G_VALUE_TYPE(current);
if (gtype == ghb_array_get_type())
{
ghb_array_append(current, gval);
}
else if (gtype == ghb_dict_get_type())
{
if (pd->key == NULL)
{
g_warning("No key for dictionary item");
ghb_value_free(gval);
}
else
{
ghb_dict_insert(current, g_strdup(pd->key), gval);
}
}
else
{
g_error("Invalid container type. This shouldn't happen");
}
}
}
GValue*
ghb_settings_new()
{
return ghb_dict_value_new();
}
void
ghb_set_pref_audio_settings(gint titleindex, GValue *settings)
{
gint track;
gchar *source_lang;
hb_audio_config_t *aconfig;
GHashTable *track_indices;
gint mux;
const GValue *pref_audio;
const GValue *audio, *drc, *gain, *enable_qual;
gint acodec, bitrate, mix;
gdouble rate, quality;
gint count, ii, list_count;
g_debug("set_pref_audio");
mux = ghb_settings_combo_int(settings, "FileFormat");
track_indices = g_hash_table_new_full(g_int_hash, g_int_equal,
free_audio_hash_key_value, free_audio_hash_key_value);
// Clear the audio list
ghb_clear_audio_list_settings(settings);
// Find "best" audio based on audio preferences
if (!ghb_settings_get_boolean(settings, "AudioDUB"))
{
source_lang = g_strdup(ghb_get_source_audio_lang(titleindex, 0));
}
else
{
source_lang = ghb_settings_get_string(settings, "PreferredLanguage");
}
pref_audio = ghb_settings_get_value(settings, "AudioList");
list_count = 0;
count = ghb_array_len(pref_audio);
for (ii = 0; ii < count; ii++)
{
gint select_acodec;
gint fallback;
audio = ghb_array_get_nth(pref_audio, ii);
acodec = ghb_settings_combo_int(audio, "AudioEncoder");
fallback = ghb_select_fallback(settings, mux, acodec);
gint copy_mask = ghb_get_copy_mask(settings);
select_acodec = ghb_select_audio_codec(mux, NULL, acodec, fallback, copy_mask);
bitrate = ghb_settings_combo_int(audio, "AudioBitrate");
rate = ghb_settings_combo_double(audio, "AudioSamplerate");
mix = ghb_settings_combo_int(audio, "AudioMixdown");
drc = ghb_settings_get_value(audio, "AudioTrackDRCSlider");
gain = ghb_settings_get_value(audio, "AudioTrackGain");
enable_qual = ghb_settings_get_value(audio, "AudioTrackQualityEnable");
quality = ghb_settings_get_double(audio, "AudioTrackQuality");
// If there are multiple audios using the same codec, then
// select sequential tracks for each. The hash keeps track
// of the tracks used for each codec.
track = ghb_find_audio_track(titleindex, source_lang,
select_acodec, fallback, track_indices);
// Check to see if:
// 1. pref codec is passthru
// 2. source codec is not passthru
// 3. next pref is enabled
aconfig = ghb_get_scan_audio_info(titleindex, track);
if (aconfig && ghb_audio_is_passthru (acodec))
{
// HB_ACODEC_* are bit fields. Treat acodec as mask
if (!(aconfig->in.codec & select_acodec & HB_ACODEC_PASS_MASK))
{
if (acodec != HB_ACODEC_AUTO_PASS)
acodec = fallback;
// If we can't substitute the passthru with a suitable
// encoder and
// If there's more audio to process, or we've already
// placed one in the list, then we can skip this one
if (!(select_acodec & fallback) &&
((ii + 1 < count) || (list_count != 0)))
{
// Skip this audio
acodec = 0;
}
}
else
{
select_acodec &= aconfig->in.codec | HB_ACODEC_PASS_FLAG;
}
}
if (titleindex >= 0 && track < 0)
acodec = 0;
if (acodec != 0)
{
GValue *asettings = ghb_dict_value_new();
ghb_settings_set_int(asettings, "AudioTrack", track);
ghb_settings_set_string(asettings, "AudioEncoder",
ghb_lookup_combo_string("AudioEncoder", ghb_int_value(acodec)));
ghb_settings_set_value(asettings, "AudioEncoderActual",
ghb_lookup_audio_encoder_value(select_acodec));
ghb_settings_set_value(asettings, "AudioTrackQualityEnable", enable_qual);
ghb_settings_set_double(asettings, "AudioTrackQuality", quality);
// This gets set autimatically if the codec is passthru
ghb_settings_set_string(asettings, "AudioBitrate",
ghb_lookup_combo_string("AudioBitrate", ghb_int_value(bitrate)));
ghb_settings_set_string(asettings, "AudioSamplerate",
ghb_lookup_combo_string("AudioSamplerate", ghb_int_value(rate)));
mix = ghb_get_best_mix( aconfig, select_acodec, mix);
ghb_settings_set_string(asettings, "AudioMixdown",
ghb_lookup_combo_string("AudioMixdown", ghb_int_value(mix)));
ghb_settings_set_value(asettings, "AudioTrackDRCSlider", drc);
ghb_settings_set_value(asettings, "AudioTrackGain", gain);
ghb_sanitize_audio(settings, asettings);
ghb_add_audio_to_settings(settings, asettings);
}
}
g_free(source_lang);
g_hash_table_destroy(track_indices);
}
int
main(gint argc, gchar *argv[])
{
gint ii, jj;
GValue *top;
gint count = sizeof(dep_map) / sizeof(dependency_t);
g_type_init();
top = ghb_dict_value_new();
for (ii = 0; ii < count; ii++)
{
const gchar *name;
GValue *array;
name = dep_map[ii].widget_name;
if (ghb_dict_lookup(top, name))
continue;
array = ghb_array_value_new(8);
for (jj = 0; jj < count; jj++)
{
if (strcmp(name, dep_map[jj].widget_name) == 0)
{
ghb_array_append(array,
ghb_value_dup(ghb_string_value(dep_map[jj].dep_name)));
}
}
ghb_dict_insert(top, g_strdup(name), array);
}
ghb_plist_write_file("widget.deps", top);
// reverse map
top = ghb_dict_value_new();
for (ii = 0; ii < count; ii++)
{
const gchar *name;
GValue *array;
name = dep_map[ii].dep_name;
if (ghb_dict_lookup(top, name))
continue;
array = ghb_array_value_new(8);
for (jj = 0; jj < count; jj++)
{
if (strcmp(name, dep_map[jj].dep_name) == 0)
{
GValue *data;
data = ghb_array_value_new(3);
ghb_array_append(data, ghb_value_dup(
ghb_string_value(dep_map[jj].widget_name)));
ghb_array_append(data, ghb_value_dup(
ghb_string_value(dep_map[jj].enable_value)));
ghb_array_append(data, ghb_value_dup(
ghb_boolean_value(dep_map[jj].disable_if_equal)));
ghb_array_append(data, ghb_value_dup(
ghb_boolean_value(dep_map[jj].hide)));
ghb_array_append(array, data);
}
}
ghb_dict_insert(top, g_strdup(name), array);
}
ghb_plist_write_file("widget_reverse.deps", top);
return 0;
}
