X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=gtk%2Fsrc%2Fhb-backend.c;h=fb76aa7c2fd702df4949f4a104a3256126bf5df3;hb=9460d9624a5cf24126bc39605bc47d43330fcdf4;hp=4f807f85330839c1f4485918e3f05db57d03aceb;hpb=c3fc9b34d0f0266d65f4992da6e3068eb5fe13d1;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/gtk/src/hb-backend.c b/gtk/src/hb-backend.c index 4f807f85..fb76aa7c 100644 --- a/gtk/src/hb-backend.c +++ b/gtk/src/hb-backend.c @@ -25,12 +25,14 @@ #include #include #include "hb.h" -#include "hbversion.h" #include #include #include "hb-backend.h" #include "settings.h" #include "callbacks.h" +#include "subtitlehandler.h" +#include "audiohandler.h" +#include "x264handler.h" #include "preview.h" #include "values.h" #include "lang.h" @@ -39,7 +41,7 @@ typedef struct { const gchar *option; const gchar *shortOpt; - gint ivalue; + gdouble ivalue; const gchar *svalue; } options_map_t; @@ -49,19 +51,74 @@ typedef struct options_map_t *map; } combo_opts_t; -static const gchar *index_str[] = -{ - "0", - "1", - "2", - "3", - "4", - "5", - "6", - "7", - "8", - "9", - "10", +static gchar **index_str = NULL; +static gint index_str_size = 0; + +static void +index_str_init(gint max_index) +{ + int ii; + + if (max_index+1 > index_str_size) + { + index_str = realloc(index_str, (max_index+1) * sizeof(char*)); + for (ii = index_str_size; ii <= max_index; ii++) + { + index_str[ii] = g_strdup_printf("%d", ii); + } + index_str_size = max_index + 1; + } +} + +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"}, + {"Show Notification", "notify", 1, "1"}, + {"Put Computer To Sleep", "sleep", 2, "2"}, + {"Shutdown Computer", "shutdown", 3, "3"}, +}; +combo_opts_t when_complete_opts = +{ + sizeof(d_when_complete_opts)/sizeof(options_map_t), + d_when_complete_opts +}; + +static options_map_t d_par_opts[] = +{ + {"Off", "0", 0, "0"}, + {"Strict", "1", 1, "1"}, + {"Loose", "2", 2, "2"}, + {"Custom", "3", 3, "3"}, +}; +combo_opts_t par_opts = +{ + sizeof(d_par_opts)/sizeof(options_map_t), + d_par_opts +}; + +static options_map_t d_alignment_opts[] = +{ + {"2", "2", 2, "2"}, + {"4", "4", 4, "4"}, + {"8", "8", 8, "8"}, + {"16", "16", 16, "16"}, +}; +combo_opts_t alignment_opts = +{ + sizeof(d_alignment_opts)/sizeof(options_map_t), + d_alignment_opts }; static options_map_t d_logging_opts[] = @@ -76,13 +133,49 @@ combo_opts_t logging_opts = d_logging_opts }; +static options_map_t d_log_longevity_opts[] = +{ + {"Week", "week", 7, "7"}, + {"Month", "month", 30, "30"}, + {"Year", "year", 365, "365"}, + {"Immortal", "immortal", 366, "366"}, +}; +combo_opts_t log_longevity_opts = +{ + sizeof(d_log_longevity_opts)/sizeof(options_map_t), + d_log_longevity_opts +}; + +static options_map_t d_appcast_update_opts[] = +{ + {"Never", "never", 0, "never"}, + {"Daily", "daily", 1, "daily"}, + {"Weekly", "weekly", 2, "weekly"}, + {"Monthly", "monthly", 3, "monthly"}, +}; +combo_opts_t appcast_update_opts = +{ + sizeof(d_appcast_update_opts)/sizeof(options_map_t), + d_appcast_update_opts +}; + +static options_map_t d_vqual_granularity_opts[] = +{ + {"0.2", "0.2", 0.2, "0.2"}, + {"0.25", "0.25", 0.25, "0.25"}, + {"0.5", "0.5", 0.5, "0.5"}, + {"1", "1", 1, "1"}, +}; +combo_opts_t vqual_granularity_opts = +{ + sizeof(d_vqual_granularity_opts)/sizeof(options_map_t), + d_vqual_granularity_opts +}; + static options_map_t d_container_opts[] = { {"MKV", "mkv", HB_MUX_MKV, "mkv"}, {"MP4", "mp4", HB_MUX_MP4, "mp4"}, - {"M4V", "m4v", HB_MUX_MP4, "m4v"}, - {"AVI", "avi", HB_MUX_AVI, "avi"}, - {"OGM", "ogm", HB_MUX_OGM, "ogm"}, }; combo_opts_t container_opts = { @@ -92,7 +185,7 @@ combo_opts_t container_opts = static options_map_t d_detel_opts[] = { - {"None", "none", 0, ""}, + {"Off", "off", 0, ""}, {"Custom", "custom", 1, ""}, {"Default","default",2, NULL}, }; @@ -104,7 +197,7 @@ combo_opts_t detel_opts = static options_map_t d_decomb_opts[] = { - {"None", "none", 0, ""}, + {"Off", "off", 0, ""}, {"Custom", "custom", 1, ""}, {"Default","default",2, NULL}, }; @@ -116,7 +209,7 @@ combo_opts_t decomb_opts = static options_map_t d_deint_opts[] = { - {"None", "none", 0, ""}, + {"Off", "off", 0, ""}, {"Custom", "custom", 1, ""}, {"Fast", "fast", 2, "-1:-1:-1:0:1"}, {"Slow", "slow", 3, "2:-1:-1:0:1"}, @@ -130,7 +223,7 @@ combo_opts_t deint_opts = static options_map_t d_denoise_opts[] = { - {"None", "none", 0, ""}, + {"Off", "off", 0, ""}, {"Custom", "custom", 1, ""}, {"Weak", "weak", 2, "2:1:2:3"}, {"Medium", "medium", 3, "3:2:2:3"}, @@ -145,9 +238,8 @@ combo_opts_t denoise_opts = static options_map_t d_vcodec_opts[] = { {"H.264 (x264)", "x264", HB_VCODEC_X264, ""}, - {"MPEG-4 (XviD)", "xvid", HB_VCODEC_XVID, ""}, - {"MPEG-4 (FFMPEG)", "ffmpeg", HB_VCODEC_FFMPEG, ""}, - {"Theora", "theora", HB_VCODEC_THEORA, ""}, + {"MPEG-4 (FFmpeg)", "ffmpeg", HB_VCODEC_FFMPEG, ""}, + {"VP3 (Theora)", "theora", HB_VCODEC_THEORA, ""}, }; combo_opts_t vcodec_opts = { @@ -157,11 +249,12 @@ combo_opts_t vcodec_opts = static options_map_t d_acodec_opts[] = { - {"AAC (faac)", "faac", HB_ACODEC_FAAC, "faac"}, - {"MP3 (lame)", "lame", HB_ACODEC_LAME, "lame"}, + {"AAC (faac)", "faac", HB_ACODEC_FAAC, "faac"}, + {"MP3 (lame)", "lame", HB_ACODEC_LAME, "lame"}, {"Vorbis", "vorbis", HB_ACODEC_VORBIS, "vorbis"}, - {"AC3 (pass-thru)", "ac3", HB_ACODEC_AC3, "ac3"}, -// {"DTS (pass-thru)", "dts", HB_ACODEC_DCA, "dts"}, + {"AC3 (pass-thru)", "ac3", HB_ACODEC_AC3, "ac3"}, + {"DTS (pass-thru)", "dts", HB_ACODEC_DCA, "dts"}, + {"Choose For Me", "auto", HB_ACODEC_MASK, "auto"}, }; combo_opts_t acodec_opts = { @@ -185,8 +278,8 @@ combo_opts_t direct_opts = static options_map_t d_badapt_opts[] = { {"Off", "0", 0, "0"}, - {"Faster", "1", 1, "1"}, - {"More Effecient", "2", 2, "2"}, + {"Fast", "1", 1, "1"}, + {"Optimal", "2", 2, "2"}, }; combo_opts_t badapt_opts = { @@ -219,6 +312,7 @@ static options_map_t d_subme_opts[] = {"7", "7", 7, "7"}, {"8", "8", 8, "8"}, {"9", "9", 9, "9"}, + {"10", "10", 10, "10"}, }; combo_opts_t subme_opts = { @@ -277,7 +371,14 @@ typedef struct combo_name_map_t combo_name_map[] = { + {"PtoPType", &point_to_point_opts}, + {"WhenComplete", &when_complete_opts}, + {"PicturePAR", &par_opts}, + {"PictureModulus", &alignment_opts}, {"LoggingLevel", &logging_opts}, + {"LogLongevity", &log_longevity_opts}, + {"check_updates", &appcast_update_opts}, + {"VideoQualityGranularity", &vqual_granularity_opts}, {"FileFormat", &container_opts}, {"PictureDeinterlace", &deint_opts}, {"PictureDecomb", &decomb_opts}, @@ -291,12 +392,53 @@ combo_name_map_t combo_name_map[] = {"x264_subme", &subme_opts}, {"x264_analyse", &analyse_opts}, {"x264_trellis", &trellis_opts}, - {"Subtitles", &subtitle_opts}, + {"SubtitleTrack", &subtitle_opts}, {"title", &title_opts}, {"AudioTrack", &audio_track_opts}, {NULL, NULL} }; +const gchar *srt_codeset_table[] = +{ + "ANSI_X3.4-1968", + "ANSI_X3.4-1986", + "ANSI_X3.4", + "ANSI_X3.110-1983", + "ANSI_X3.110", + "ASCII", + "ECMA-114", + "ECMA-118", + "ECMA-128", + "ECMA-CYRILLIC", + "IEC_P27-1", + "ISO-8859-1", + "ISO-8859-2", + "ISO-8859-3", + "ISO-8859-4", + "ISO-8859-5", + "ISO-8859-6", + "ISO-8859-7", + "ISO-8859-8", + "ISO-8859-9", + "ISO-8859-9E", + "ISO-8859-10", + "ISO-8859-11", + "ISO-8859-13", + "ISO-8859-14", + "ISO-8859-15", + "ISO-8859-16", + "UTF-7", + "UTF-8", + "UTF-16", + "UTF-16LE", + "UTF-16BE", + "UTF-32", + "UTF-32LE", + "UTF-32BE", + NULL +}; +#define SRT_TABLE_SIZE (sizeof(srt_codeset_table)/ sizeof(char*)-1) + #if 0 typedef struct iso639_lang_t { @@ -347,21 +489,20 @@ const iso639_lang_t ghb_language_table[] = { "Cree", "", "cr", "cre" }, { "Czech", "", "cs", "ces", "cze" }, { "Danish", "Dansk", "da", "dan" }, + { "German", "Deutsch", "de", "deu", "ger" }, { "Divehi", "", "dv", "div" }, - { "Dutch", "Nederlands", "nl", "nld", "dut" }, { "Dzongkha", "", "dz", "dzo" }, { "English", "English", "en", "eng" }, + { "Spanish", "Espanol", "es", "spa" }, { "Esperanto", "", "eo", "epo" }, { "Estonian", "", "et", "est" }, { "Ewe", "", "ee", "ewe" }, { "Faroese", "", "fo", "fao" }, { "Fijian", "", "fj", "fij" }, - { "Finnish", "Suomi", "fi", "fin" }, { "French", "Francais", "fr", "fra", "fre" }, { "Western Frisian", "", "fy", "fry" }, { "Fulah", "", "ff", "ful" }, { "Georgian", "", "ka", "kat", "geo" }, - { "German", "Deutsch", "de", "deu", "ger" }, { "Gaelic (Scots)", "", "gd", "gla" }, { "Irish", "", "ga", "gle" }, { "Galician", "", "gl", "glg" }, @@ -375,10 +516,10 @@ const iso639_lang_t ghb_language_table[] = { "Herero", "", "hz", "her" }, { "Hindi", "", "hi", "hin" }, { "Hiri Motu", "", "ho", "hmo" }, - { "Hungarian", "Magyar", "hu", "hun" }, + { "Croatian", "Hrvatski", "hr", "hrv", "scr" }, { "Igbo", "", "ig", "ibo" }, - { "Icelandic", "Islenska", "is", "isl", "ice" }, { "Ido", "", "io", "ido" }, + { "Icelandic", "Islenska", "is", "isl", "ice" }, { "Sichuan Yi", "", "ii", "iii" }, { "Inuktitut", "", "iu", "iku" }, { "Interlingue", "", "ie", "ile" }, @@ -412,6 +553,7 @@ const iso639_lang_t ghb_language_table[] = { "Luba-Katanga", "", "lu", "lub" }, { "Ganda", "", "lg", "lug" }, { "Macedonian", "", "mk", "mkd", "mac" }, + { "Hungarian", "Magyar", "hu", "hun" }, { "Marshallese", "", "mh", "mah" }, { "Malayalam", "", "ml", "mal" }, { "Maori", "", "mi", "mri", "mao" }, @@ -423,13 +565,14 @@ const iso639_lang_t ghb_language_table[] = { "Mongolian", "", "mn", "mon" }, { "Nauru", "", "na", "nau" }, { "Navajo", "", "nv", "nav" }, + { "Dutch", "Nederlands", "nl", "nld", "dut" }, { "Ndebele, South", "", "nr", "nbl" }, { "Ndebele, North", "", "nd", "nde" }, { "Ndonga", "", "ng", "ndo" }, { "Nepali", "", "ne", "nep" }, + { "Norwegian", "Norsk", "no", "nor" }, { "Norwegian Nynorsk", "", "nn", "nno" }, { "Norwegian Bokmål", "", "nb", "nob" }, - { "Norwegian", "Norsk", "no", "nor" }, { "Chichewa; Nyanja", "", "ny", "nya" }, { "Occitan", "", "oc", "oci" }, { "Ojibwa", "", "oj", "oji" }, @@ -450,7 +593,6 @@ const iso639_lang_t ghb_language_table[] = { "Sango", "", "sg", "sag" }, { "Sanskrit", "", "sa", "san" }, { "Serbian", "", "sr", "srp", "scc" }, - { "Croatian", "Hrvatski", "hr", "hrv", "scr" }, { "Sinhala", "", "si", "sin" }, { "Slovak", "", "sk", "slk", "slo" }, { "Slovenian", "", "sl", "slv" }, @@ -460,10 +602,10 @@ const iso639_lang_t ghb_language_table[] = { "Sindhi", "", "sd", "snd" }, { "Somali", "", "so", "som" }, { "Sotho, Southern", "", "st", "sot" }, - { "Spanish", "Espanol", "es", "spa" }, { "Sardinian", "", "sc", "srd" }, { "Swati", "", "ss", "ssw" }, { "Sundanese", "", "su", "sun" }, + { "Finnish", "Suomi", "fi", "fin" }, { "Swahili", "", "sw", "swa" }, { "Swedish", "Svenska", "sv", "swe" }, { "Tahitian", "", "ty", "tah" }, @@ -532,7 +674,7 @@ del_tree(const gchar *name, gboolean del_top) const gchar* ghb_version() { - return HB_VERSION; + return hb_get_version(NULL); } void @@ -546,7 +688,6 @@ ghb_vquality_range( gboolean *inverted) { gint vcodec = ghb_settings_combo_int(ud->settings, "VideoEncoder"); - *step = 1; *page = 10; *digits = 0; switch (vcodec) @@ -555,16 +696,20 @@ ghb_vquality_range( { *min = 0; *max = 51; - *step = 0.1; - *digits = 3; + *step = ghb_settings_combo_double(ud->settings, + "VideoQualityGranularity"); + if (*step == 0.2 || *step == 0.5) + *digits = 1; + else if (*step == 0.25) + *digits = 2; *inverted = TRUE; } break; - case HB_VCODEC_XVID: case HB_VCODEC_FFMPEG: { *min = 1; *max = 31; + *step = 1; *inverted = TRUE; } break; @@ -572,6 +717,7 @@ ghb_vquality_range( { *min = 0; *max = 63; + *step = 1; *inverted = FALSE; } break; @@ -579,12 +725,32 @@ ghb_vquality_range( { *min = 0; *max = 100; - *digits = 3; + *step = 1; *inverted = FALSE; } break; } } +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++) + { + if (strcmp(opts->map[ii].shortOpt, str) == 0) + { + result = opts->map[ii].svalue; + break; + } + } + g_free(str); + return result; +} + static gint lookup_generic_int(combo_opts_t *opts, const GValue *gval) { @@ -605,6 +771,26 @@ lookup_generic_int(combo_opts_t *opts, const GValue *gval) return result; } +static gdouble +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++) + { + if (strcmp(opts->map[ii].shortOpt, str) == 0) + { + result = opts->map[ii].ivalue; + break; + } + } + g_free(str); + return result; +} + static const gchar* lookup_generic_option(combo_opts_t *opts, const GValue *gval) { @@ -753,6 +939,33 @@ lookup_audio_rate_option(const GValue *rate) return result; } +gint +ghb_find_closest_audio_bitrate(gint codec, gint rate) +{ + gint ii; + gint low = 32; + gint high = 768; + gint result; + + if (codec == HB_ACODEC_FAAC) + high = 160; + + result = high; + for (ii = 0; ii < hb_audio_bitrates_count; ii++) + { + if (hb_audio_bitrates[ii].rate < low) + continue; + if (hb_audio_bitrates[ii].rate > high) + break; + if (rate <= hb_audio_bitrates[ii].rate) + { + result = hb_audio_bitrates[ii].rate; + break; + } + } + return result; +} + static gint lookup_audio_bitrate_int(const GValue *rate) { @@ -833,7 +1046,10 @@ lookup_audio_lang_option(const GValue *rate) { if (strcmp(ghb_language_table[ii].iso639_2, str) == 0) { - result = ghb_language_table[ii].eng_name; + if (ghb_language_table[ii].native_name[0] != 0) + result = ghb_language_table[ii].native_name; + else + result = ghb_language_table[ii].eng_name; break; } } @@ -841,15 +1057,15 @@ lookup_audio_lang_option(const GValue *rate) return result; } -static GValue* -get_acodec_value(gint val) +GValue* +ghb_lookup_acodec_value(gint val) { GValue *value = NULL; gint ii; for (ii = 0; ii < acodec_opts.count; ii++) { - if (acodec_opts.map[ii].ivalue == val) + if ((int)acodec_opts.map[ii].ivalue == val) { value = ghb_string_value_new(acodec_opts.map[ii].shortOpt); break; @@ -858,25 +1074,6 @@ get_acodec_value(gint val) return value; } -#if 0 -static GValue* -get_abitrate_value(gint val) -{ - GValue *value = NULL; - gint ii; - - for (ii = 0; ii < hb_audio_bitrates_count; ii++) - { - if (hb_audio_bitrates[ii].rate == val) - { - value = ghb_string_value_new(hb_audio_bitrates[ii].string); - break; - } - } - return value; -} -#endif - static GValue* get_amix_value(gint val) { @@ -919,6 +1116,135 @@ ghb_hb_cleanup(gboolean partial) } gint +ghb_subtitle_track_source(signal_user_data_t *ud, gint track) +{ + gint titleindex; + + if (track == -2) + return SRTSUB; + if (track < 0) + return VOBSUB; + titleindex = ghb_settings_combo_int(ud->settings, "title"); + if (titleindex < 0) + return VOBSUB; + + hb_list_t * list; + hb_title_t * title; + hb_subtitle_t * sub; + + if (h_scan == NULL) return VOBSUB; + list = hb_get_titles( h_scan ); + if( !hb_list_count( list ) ) + { + /* No valid title, stop right there */ + return VOBSUB; + } + title = hb_list_item( list, titleindex ); + if (title == NULL) return VOBSUB; // Bad titleindex + sub = hb_list_item( title->list_subtitle, track); + if (sub != NULL) + return sub->source; + else + return VOBSUB; +} + +const char* +ghb_subtitle_track_source_name(signal_user_data_t *ud, gint track) +{ + gint titleindex; + const gchar * name = "Unknown"; + + if (track == -2) + { + name = "SRT"; + goto done; + } + if (track == -1) + { + name = "Bitmap"; + goto done; + } + + titleindex = ghb_settings_combo_int(ud->settings, "title"); + if (titleindex < 0) + goto done; + + hb_list_t * list; + hb_title_t * title; + hb_subtitle_t * sub; + + if (h_scan == NULL) + goto done; + list = hb_get_titles( h_scan ); + if( !hb_list_count( list ) ) + goto done; + + title = hb_list_item( list, titleindex ); + if (title == NULL) + goto done; + + 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; + } + } + +done: + return name; +} + +gchar* +ghb_subtitle_track_lang(signal_user_data_t *ud, gint track) +{ + gint titleindex; + + titleindex = ghb_settings_combo_int(ud->settings, "title"); + if (titleindex < 0) + goto fail; + if (track == -1) + return ghb_get_user_audio_lang(ud, titleindex, 0); + if (track < 0) + goto fail; + + hb_list_t * list; + hb_title_t * title; + hb_subtitle_t * sub; + + if (h_scan == NULL) + goto fail; + + list = hb_get_titles( h_scan ); + if( !hb_list_count( list ) ) + { + /* No valid title, stop right there */ + goto fail; + } + title = hb_list_item( list, titleindex ); + if (title == NULL) // Bad titleindex + goto fail; + sub = hb_list_item( title->list_subtitle, track); + if (sub != NULL) + return g_strdup(sub->iso639_2); + +fail: + return g_strdup("und"); +} + +gint ghb_get_title_number(gint titleindex) { hb_list_t * list; @@ -1029,19 +1355,15 @@ ghb_grey_combo_options(GtkBuilder *builder) grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_LAME, FALSE); grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_VORBIS, FALSE); - gboolean allow_ac3 = TRUE; - allow_ac3 = (container != HB_MUX_OGM); + gboolean allow_dca = TRUE; + allow_dca = (container != HB_MUX_MP4); - if (allow_ac3) - { - grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_AC3, FALSE); + grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_AC3, FALSE); + if (allow_dca) grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_DCA, FALSE); - } else - { - grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_AC3, TRUE); grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_DCA, TRUE); - } + if (audio && audio->in.codec != HB_ACODEC_AC3) { grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_AC3, TRUE); @@ -1066,27 +1388,18 @@ ghb_grey_combo_options(GtkBuilder *builder) grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_VORBIS, TRUE); grey_combo_box_item(builder, "VideoEncoder", HB_VCODEC_THEORA, TRUE); } - else if (container == HB_MUX_AVI) - { - grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_FAAC, TRUE); - grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_VORBIS, TRUE); - grey_combo_box_item(builder, "VideoEncoder", HB_VCODEC_THEORA, TRUE); - } - else if (container == HB_MUX_OGM) - { - grey_combo_box_item(builder, "AudioEncoder", HB_ACODEC_FAAC, TRUE); - } gboolean allow_mono = TRUE; gboolean allow_stereo = TRUE; gboolean allow_dolby = TRUE; gboolean allow_dpl2 = TRUE; gboolean allow_6ch = TRUE; + allow_mono = acodec & ~HB_ACODEC_LAME; + allow_6ch = acodec & ~HB_ACODEC_LAME; if (audio) { - allow_mono = - (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) && - (acodec != HB_ACODEC_LAME); + 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); @@ -1095,9 +1408,8 @@ ghb_grey_combo_options(GtkBuilder *builder) (layout == HB_INPUT_CH_LAYOUT_3F2R) || (layout == HB_INPUT_CH_LAYOUT_DOLBY); allow_dpl2 = (layout == HB_INPUT_CH_LAYOUT_3F2R); - allow_6ch = + allow_6ch = 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); } @@ -1109,6 +1421,18 @@ ghb_grey_combo_options(GtkBuilder *builder) } gint +ghb_get_best_audio_bitrate(gint acodec, gint br, gint channels) +{ + if (acodec & HB_ACODEC_FAAC) + { + int maxbr = channels * 80; + if (br > maxbr) + br = maxbr; + } + return br; +} + +gint ghb_get_best_mix(gint titleindex, gint track, gint acodec, gint mix) { hb_audio_config_t *audio = NULL; @@ -1128,7 +1452,7 @@ ghb_get_best_mix(gint titleindex, gint track, gint acodec, gint mix) { allow_mono = (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) && - (acodec != HB_ACODEC_LAME); + (acodec & ~HB_ACODEC_LAME); 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); @@ -1139,7 +1463,7 @@ ghb_get_best_mix(gint titleindex, gint track, gint acodec, gint mix) allow_dpl2 = (layout == HB_INPUT_CH_LAYOUT_3F2R); allow_6ch = (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) && - (acodec != HB_ACODEC_LAME) && + (acodec & ~HB_ACODEC_LAME) && (layout == HB_INPUT_CH_LAYOUT_3F2R) && (audio->in.channel_layout & HB_INPUT_CH_LAYOUT_HAS_LFE); } @@ -1192,6 +1516,8 @@ init_combo_box(GtkBuilder *builder, const gchar *name) g_debug("init_combo_box() %s\n", name); // First modify the combobox model to allow greying out of options combo = GTK_COMBO_BOX(GHB_WIDGET(builder, name)); + if (combo == NULL) + return; // Store contains: // 1 - String to display // 2 - bool indicating whether the entry is selectable (grey or not) @@ -1199,7 +1525,7 @@ init_combo_box(GtkBuilder *builder, const gchar *name) // 4 - Int value determined by backend // 5 - String value determined by backend store = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_BOOLEAN, - G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); + G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_STRING); gtk_combo_box_set_model(combo, GTK_TREE_MODEL(store)); if (GTK_WIDGET_TYPE(combo) == GTK_TYPE_COMBO_BOX) @@ -1208,7 +1534,7 @@ init_combo_box(GtkBuilder *builder, const gchar *name) cell = GTK_CELL_RENDERER(gtk_cell_renderer_text_new()); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell, - "text", 0, "sensitive", 1, NULL); + "markup", 0, "sensitive", 1, NULL); } else { // Combo box entry @@ -1222,6 +1548,7 @@ audio_samplerate_opts_set(GtkBuilder *builder, const gchar *name, hb_rate_t *rat GtkTreeIter iter; GtkListStore *store; gint ii; + gchar *str; g_debug("audio_samplerate_opts_set ()\n"); store = get_combo_box_store(builder, name); @@ -1229,22 +1556,24 @@ audio_samplerate_opts_set(GtkBuilder *builder, const gchar *name, hb_rate_t *rat // Add an item for "Same As Source" gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, - 0, "Same as source", + 0, "Same as source", 1, TRUE, 2, "source", - 3, 0, + 3, 0.0, 4, "source", -1); for (ii = 0; ii < count; ii++) { gtk_list_store_append(store, &iter); + str = g_strdup_printf("%s", rates[ii].string); gtk_list_store_set(store, &iter, - 0, rates[ii].string, + 0, str, 1, TRUE, 2, rates[ii].string, - 3, rates[ii].rate, + 3, (gdouble)rates[ii].rate, 4, rates[ii].string, -1); + g_free(str); } } @@ -1264,7 +1593,7 @@ video_rate_opts_set(GtkBuilder *builder, const gchar *name, hb_rate_t *rates, gi 0, "Same as source", 1, TRUE, 2, "source", - 3, 0, + 3, 0.0, 4, "source", -1); for (ii = 0; ii < count; ii++) @@ -1289,7 +1618,7 @@ video_rate_opts_set(GtkBuilder *builder, const gchar *name, hb_rate_t *rates, gi 0, option, 1, TRUE, 2, rates[ii].string, - 3, rates[ii].rate, + 3, (gdouble)rates[ii].rate, 4, rates[ii].string, -1); g_free(option); @@ -1302,29 +1631,60 @@ mix_opts_set(GtkBuilder *builder, const gchar *name) GtkTreeIter iter; GtkListStore *store; gint ii; + gchar *str; g_debug("mix_opts_set ()\n"); store = get_combo_box_store(builder, name); gtk_list_store_clear(store); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, - 0, "None", + 0, "None", 1, TRUE, 2, "none", - 3, 0, + 3, 0.0, 4, "none", -1); for (ii = 0; ii < hb_audio_mixdowns_count; ii++) { gtk_list_store_append(store, &iter); + str = g_strdup_printf("%s", + hb_audio_mixdowns[ii].human_readable_name); gtk_list_store_set(store, &iter, - 0, hb_audio_mixdowns[ii].human_readable_name, + 0, str, 1, TRUE, 2, hb_audio_mixdowns[ii].short_name, - 3, hb_audio_mixdowns[ii].amixdown, + 3, (gdouble)hb_audio_mixdowns[ii].amixdown, 4, hb_audio_mixdowns[ii].internal_name, -1); + g_free(str); + } +} + +static void +srt_codeset_opts_set(GtkBuilder *builder, const gchar *name) +{ + GtkTreeIter iter; + GtkListStore *store; + gint ii; + + g_debug("srt_codeset_opts_set ()\n"); + store = get_combo_box_store(builder, name); + gtk_list_store_clear(store); + for (ii = 0; ii < SRT_TABLE_SIZE; ii++) + { + gtk_list_store_append(store, &iter); + gtk_list_store_set(store, &iter, + 0, srt_codeset_table[ii], + 1, TRUE, + 2, srt_codeset_table[ii], + 3, (gdouble)ii, + 4, srt_codeset_table[ii], + -1); } + GtkComboBoxEntry *cbe; + + cbe = GTK_COMBO_BOX_ENTRY(GHB_WIDGET(builder, name)); + //gtk_combo_box_entry_set_text_column(cbe, 0); } static void @@ -1339,12 +1699,19 @@ language_opts_set(GtkBuilder *builder, const gchar *name) gtk_list_store_clear(store); for (ii = 0; ii < LANG_TABLE_SIZE; ii++) { + const gchar *lang; + + if (ghb_language_table[ii].native_name[0] != 0) + lang = ghb_language_table[ii].native_name; + else + lang = ghb_language_table[ii].eng_name; + gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, - 0, ghb_language_table[ii].eng_name, + 0, lang, 1, TRUE, 2, ghb_language_table[ii].iso639_2, - 3, ii, + 3, (gdouble)ii, 4, ghb_language_table[ii].iso639_1, -1); } @@ -1393,7 +1760,7 @@ title_opts_set(GtkBuilder *builder, const gchar *name) 0, "No Titles", 1, TRUE, 2, "none", - 3, -1, + 3, -1.0, 4, "none", -1); title_opts.map[0].option = "No Titles"; @@ -1405,21 +1772,39 @@ title_opts_set(GtkBuilder *builder, const gchar *name) 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, 0, titles[ii], 1, TRUE, 2, titles[ii], - 3, ii, + 3, (gdouble)ii, 4, titles[ii], -1); title_opts.map[ii].option = titles[ii]; @@ -1433,7 +1818,7 @@ title_opts_set(GtkBuilder *builder, const gchar *name) static gboolean find_combo_item_by_int(GtkTreeModel *store, gint value, GtkTreeIter *iter) { - gint ivalue; + gdouble ivalue; gboolean foundit = FALSE; if (gtk_tree_model_get_iter_first (store, iter)) @@ -1441,7 +1826,7 @@ find_combo_item_by_int(GtkTreeModel *store, gint value, GtkTreeIter *iter) do { gtk_tree_model_get(store, iter, 3, &ivalue, -1); - if (value == ivalue) + if (value == (int)ivalue) { foundit = TRUE; break; @@ -1461,6 +1846,7 @@ audio_track_opts_set(GtkBuilder *builder, const gchar *name, gint titleindex) hb_audio_config_t * audio; gint ii; gint count = 0; + gchar *str; g_debug("audio_track_opts_set ()\n"); store = get_combo_box_store(builder, name); @@ -1491,10 +1877,10 @@ audio_track_opts_set(GtkBuilder *builder, const gchar *name, gint titleindex) // No audio. set some default gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, - 0, "No Audio", + 0, "No Audio", 1, TRUE, 2, "none", - 3, -1, + 3, -1.0, 4, "none", -1); audio_track_opts.map[0].option = "No Audio"; @@ -1503,17 +1889,20 @@ audio_track_opts_set(GtkBuilder *builder, const gchar *name, gint titleindex) audio_track_opts.map[0].svalue = "none"; return; } + index_str_init(count-1); for (ii = 0; ii < count; ii++) { audio = (hb_audio_config_t *) hb_list_audio_config_item( title->list_audio, ii ); gtk_list_store_append(store, &iter); + str = g_strdup_printf("%s", audio->lang.description); gtk_list_store_set(store, &iter, - 0, audio->lang.description, + 0, str, 1, TRUE, 2, index_str[ii], - 3, ii, + 3, (gdouble)ii, 4, index_str[ii], -1); + g_free(str); audio_track_opts.map[ii].option = audio->lang.description, audio_track_opts.map[ii].shortOpt = index_str[ii]; audio_track_opts.map[ii].ivalue = ii; @@ -1521,19 +1910,18 @@ audio_track_opts_set(GtkBuilder *builder, const gchar *name, gint titleindex) } } - void -subtitle_opts_set(GtkBuilder *builder, const gchar *name, gint titleindex) +subtitle_track_opts_set(GtkBuilder *builder, const gchar *name, gint titleindex) { GtkTreeIter iter; GtkListStore *store; hb_list_t * list = NULL; hb_title_t * title = NULL; - hb_subtitle_t * subtitle; - gint ii; - gint count = 0; + hb_subtitle_t * subtitle; + gint ii, count = 0; + static char ** options = NULL; - g_debug("subtitle_opts_set () %s\n", name); + g_debug("subtitle_track_opts_set ()\n"); store = get_combo_box_store(builder, name); gtk_list_store_clear(store); if (h_scan != NULL) @@ -1549,74 +1937,77 @@ subtitle_opts_set(GtkBuilder *builder, const gchar *name, gint titleindex) if (subtitle_opts.map) g_free(subtitle_opts.map); if (count > 0) { - subtitle_opts.count = count+2; - subtitle_opts.map = g_malloc((count+2)*sizeof(options_map_t)); + subtitle_opts.count = count+1; + subtitle_opts.map = g_malloc((count+1)*sizeof(options_map_t)); } else { - subtitle_opts.count = LANG_TABLE_SIZE+2; - subtitle_opts.map = g_malloc((LANG_TABLE_SIZE+2)*sizeof(options_map_t)); + subtitle_opts.count = LANG_TABLE_SIZE+1; + subtitle_opts.map = g_malloc((LANG_TABLE_SIZE+1)*sizeof(options_map_t)); } - // Add options for "none" and "autoselect" - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, - 0, "None", - 1, TRUE, - 2, "none", - 3, -2, - 4, "none", - -1); - subtitle_opts.map[0].option = "None"; - subtitle_opts.map[0].shortOpt = "none"; - subtitle_opts.map[0].ivalue = -2; - subtitle_opts.map[0].svalue = "none"; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, - 0, "Autoselect", + 0, "Foreign Audio Search", 1, TRUE, - 2, "auto", - 3, -1, + 2, "-1", + 3, -1.0, 4, "auto", -1); - subtitle_opts.map[0].option = "Same as audio"; - subtitle_opts.map[0].shortOpt = "auto"; + subtitle_opts.map[0].option = "Foreign Audio Search"; + subtitle_opts.map[0].shortOpt = "-1"; subtitle_opts.map[0].ivalue = -1; subtitle_opts.map[0].svalue = "auto"; if (count > 0) { + if (options != NULL) + g_strfreev(options); + options = g_malloc((count+1)*sizeof(gchar*)); + index_str_init(count-1); for (ii = 0; ii < count; ii++) { 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); + subtitle_opts.map[ii+1].option = options[ii]; + subtitle_opts.map[ii+1].shortOpt = index_str[ii]; + subtitle_opts.map[ii+1].ivalue = ii; + subtitle_opts.map[ii+1].svalue = subtitle->iso639_2; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, - 0, subtitle->lang, + 0, options[ii], 1, TRUE, - 2, subtitle->iso639_2, - 3, ii, + 2, index_str[ii], + 3, (gdouble)ii, 4, subtitle->iso639_2, -1); - subtitle_opts.map[ii+2].option = subtitle->lang; - subtitle_opts.map[ii+2].shortOpt = subtitle->iso639_2; - subtitle_opts.map[ii+2].ivalue = ii; - subtitle_opts.map[ii+2].svalue = subtitle->iso639_2; } + options[count] = NULL; } else { + index_str_init(LANG_TABLE_SIZE-1); for (ii = 0; ii < LANG_TABLE_SIZE; ii++) { + const gchar *lang; + + if (ghb_language_table[ii].native_name[0] != 0) + lang = ghb_language_table[ii].native_name; + else + lang = ghb_language_table[ii].eng_name; + + subtitle_opts.map[ii+1].option = lang; + subtitle_opts.map[ii+1].shortOpt = index_str[ii]; + subtitle_opts.map[ii+1].ivalue = ii; + subtitle_opts.map[ii+1].svalue = ghb_language_table[ii].iso639_2; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, - 0, ghb_language_table[ii].eng_name, - 1, TRUE, - 2, ghb_language_table[ii].iso639_2, - 3, ii, - 4, ghb_language_table[ii].iso639_2, - -1); - subtitle_opts.map[ii+2].option = ghb_language_table[ii].eng_name; - subtitle_opts.map[ii+2].shortOpt = ghb_language_table[ii].iso639_2; - subtitle_opts.map[ii+2].ivalue = ii; - subtitle_opts.map[ii+2].svalue = ghb_language_table[ii].iso639_2; + 0, lang, + 1, TRUE, + 2, index_str[ii], + 3, (gdouble)ii, + 4, ghb_language_table[ii].iso639_2, + -1); } } } @@ -1648,56 +2039,105 @@ ghb_longest_title() return titleindex; } +gchar* +ghb_get_source_audio_lang(gint titleindex, gint track) +{ + hb_list_t * list; + hb_title_t * title; + hb_audio_config_t * audio; + gchar *lang = NULL; + + g_debug("ghb_lookup_1st_audio_lang ()\n"); + if (h_scan == NULL) + return NULL; + list = hb_get_titles( h_scan ); + title = (hb_title_t*)hb_list_item( list, titleindex ); + if (title == NULL) + return NULL; + if (hb_list_count( title->list_audio ) <= track) + return NULL; + + audio = hb_list_audio_config_item(title->list_audio, track); + if (audio == NULL) + return NULL; + + lang = g_strdup(audio->lang.iso639_2); + 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; + gboolean *passthru_used; + gint try_acodec; + gint passthru_acodec; + gboolean passthru; 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 fine an item that matches the preferred language and + // Try to find an item that matches the preferred language and // the passthru codec type - if (acodec == HB_ACODEC_AC3 || acodec == HB_ACODEC_DCA) + 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))) { @@ -1708,19 +2148,34 @@ ghb_find_audio_track( } } } + try_acodec = fallback_acodec; + } + else + { + try_acodec = acodec; } if (track > -1) { used[track] = TRUE; return track; } - // Try to fine an item that matches the preferred language + // Try to find an item that matches the preferred language + 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; + } // Find a track that is not visually impaired or dirctor's commentary if ((audio->lang.type < 2) && ((strcmp(lang, audio->lang.iso639_2) == 0) || @@ -1737,23 +2192,28 @@ ghb_find_audio_track( } // Try to fine an item that does not match the preferred language and // matches the passthru codec type - if (acodec == HB_ACODEC_AC3 || acodec == HB_ACODEC_DCA) + 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) { @@ -1762,6 +2222,11 @@ ghb_find_audio_track( } } } + try_acodec = fallback_acodec; + } + else + { + try_acodec = acodec; } if (track > -1) { @@ -1769,12 +2234,22 @@ ghb_find_audio_track( return track; } // Try to fine an item that does not match the preferred language + 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; + 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) { @@ -1790,8 +2265,17 @@ ghb_find_audio_track( // 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; @@ -1805,6 +2289,111 @@ ghb_find_audio_track( return track; } +gint +ghb_find_pref_subtitle_track(const gchar *lang) +{ + gint ii, count; + count = subtitle_opts.count; + for (ii = 0; ii < count; ii++) + { + if (strcmp(lang, subtitle_opts.map[ii].svalue) == 0) + { + return subtitle_opts.map[ii].ivalue; + } + } + return -2; +} + +gint +ghb_find_cc_track(gint titleindex) +{ + hb_list_t * list; + hb_title_t * title; + hb_subtitle_t * subtitle; + gint count, ii; + + g_debug("ghb_find_cc_track ()\n"); + if (h_scan == NULL) return -2; + list = hb_get_titles( h_scan ); + title = (hb_title_t*)hb_list_item( list, titleindex ); + if (title != NULL) + { + count = hb_list_count( title->list_subtitle ); + // Try to find an item that matches the preferred language + for (ii = 0; ii < count; ii++) + { + subtitle = (hb_subtitle_t*)hb_list_item( title->list_subtitle, ii ); + if (subtitle->source == CC608SUB || subtitle->source == CC708SUB) + return ii; + } + } + return -2; +} + +gint +ghb_find_subtitle_track( + gint titleindex, + const gchar * lang, + gboolean burn, + gboolean force, + gint source, + GHashTable * track_indices) +{ + hb_list_t * list; + hb_title_t * title; + hb_subtitle_t * subtitle; + gint count, ii; + gboolean *used; + + g_debug("find_subtitle_track ()\n"); + if (strcmp(lang, "auto") == 0) + return -1; + if (h_scan == NULL) return -1; + list = hb_get_titles( h_scan ); + title = (hb_title_t*)hb_list_item( list, titleindex ); + if (title != NULL) + { + count = hb_list_count( title->list_subtitle ); + used = g_hash_table_lookup(track_indices, lang); + if (used == NULL) + { + used = g_malloc0(count * sizeof(gboolean)); + g_hash_table_insert(track_indices, g_strdup(lang), used); + } + // Try to find an item that matches the preferred language and source + for (ii = 0; ii < count; ii++) + { + if (used[ii]) + continue; + + subtitle = (hb_subtitle_t*)hb_list_item( title->list_subtitle, ii ); + if (source == subtitle->source && + ((strcmp(lang, subtitle->iso639_2) == 0) || + (strcmp(lang, "und") == 0))) + { + used[ii] = TRUE; + return ii; + } + } + // Try to find an item that matches the preferred language + for (ii = 0; ii < count; ii++) + { + if (used[ii]) + continue; + + subtitle = (hb_subtitle_t*)hb_list_item( title->list_subtitle, ii ); + if (((burn || force) && (subtitle->source == VOBSUB)) && + ((strcmp(lang, subtitle->iso639_2) == 0) || + (strcmp(lang, "und") == 0))) + { + used[ii] = TRUE; + return ii; + } + } + } + return -2; +} + static void generic_opts_set(GtkBuilder *builder, const gchar *name, combo_opts_t *opts) { @@ -1829,6 +2418,33 @@ generic_opts_set(GtkBuilder *builder, const gchar *name, combo_opts_t *opts) } } +static void +small_opts_set(GtkBuilder *builder, const gchar *name, combo_opts_t *opts) +{ + GtkTreeIter iter; + GtkListStore *store; + gint ii; + gchar *str; + + g_debug("generic_opts_set ()\n"); + if (name == NULL || opts == NULL) return; + store = get_combo_box_store(builder, name); + gtk_list_store_clear(store); + for (ii = 0; ii < opts->count; ii++) + { + gtk_list_store_append(store, &iter); + str = g_strdup_printf("%s", opts->map[ii].option); + gtk_list_store_set(store, &iter, + 0, str, + 1, TRUE, + 2, opts->map[ii].shortOpt, + 3, opts->map[ii].ivalue, + 4, opts->map[ii].svalue, + -1); + g_free(str); + } +} + combo_opts_t* find_combo_table(const gchar *name) { @@ -1847,6 +2463,8 @@ find_combo_table(const gchar *name) gint ghb_lookup_combo_int(const gchar *name, const GValue *gval) { + if (gval == NULL) + return 0; if (strcmp(name, "AudioBitrate") == 0) return lookup_audio_bitrate_int(gval); else if (strcmp(name, "AudioSamplerate") == 0) @@ -1855,7 +2473,9 @@ ghb_lookup_combo_int(const gchar *name, const GValue *gval) return lookup_video_rate_int(gval); else if (strcmp(name, "AudioMixdown") == 0) return lookup_mix_int(gval); - else if (strcmp(name, "SourceAudioLang") == 0) + else if (strcmp(name, "SrtLanguage") == 0) + return lookup_audio_lang_int(gval); + else if (strcmp(name, "PreferredLanguage") == 0) return lookup_audio_lang_int(gval); else { @@ -1865,9 +2485,36 @@ ghb_lookup_combo_int(const gchar *name, const GValue *gval) return 0; } +gdouble +ghb_lookup_combo_double(const gchar *name, const GValue *gval) +{ + if (gval == NULL) + return 0; + if (strcmp(name, "AudioBitrate") == 0) + return lookup_audio_bitrate_int(gval); + else if (strcmp(name, "AudioSamplerate") == 0) + return lookup_audio_rate_int(gval); + else if (strcmp(name, "VideoFramerate") == 0) + return lookup_video_rate_int(gval); + else if (strcmp(name, "AudioMixdown") == 0) + return lookup_mix_int(gval); + else if (strcmp(name, "SrtLanguage") == 0) + return lookup_audio_lang_int(gval); + else if (strcmp(name, "PreferredLanguage") == 0) + return lookup_audio_lang_int(gval); + else + { + return lookup_generic_double(find_combo_table(name), gval); + } + g_warning("ghb_lookup_combo_double() couldn't find %s", name); + return 0; +} + const gchar* ghb_lookup_combo_option(const gchar *name, const GValue *gval) { + if (gval == NULL) + return NULL; if (strcmp(name, "AudioBitrate") == 0) return lookup_audio_bitrate_option(gval); else if (strcmp(name, "AudioSamplerate") == 0) @@ -1876,30 +2523,61 @@ ghb_lookup_combo_option(const gchar *name, const GValue *gval) return lookup_video_rate_option(gval); else if (strcmp(name, "AudioMixdown") == 0) return lookup_mix_option(gval); - else if (strcmp(name, "SourceAudioLang") == 0) + else if (strcmp(name, "SrtLanguage") == 0) + return lookup_audio_lang_option(gval); + else if (strcmp(name, "PreferredLanguage") == 0) return lookup_audio_lang_option(gval); else { return lookup_generic_option(find_combo_table(name), gval); } g_warning("ghb_lookup_combo_int() couldn't find %s", name); - return 0; + return NULL; +} + +const gchar* +ghb_lookup_combo_string(const gchar *name, const GValue *gval) +{ + if (gval == NULL) + return NULL; + if (strcmp(name, "AudioBitrate") == 0) + return lookup_audio_bitrate_option(gval); + else if (strcmp(name, "AudioSamplerate") == 0) + return lookup_audio_rate_option(gval); + else if (strcmp(name, "VideoFramerate") == 0) + return lookup_video_rate_option(gval); + else if (strcmp(name, "AudioMixdown") == 0) + return lookup_mix_option(gval); + else if (strcmp(name, "SrtLanguage") == 0) + return lookup_audio_lang_option(gval); + else if (strcmp(name, "PreferredLanguage") == 0) + return lookup_audio_lang_option(gval); + else + { + return lookup_generic_string(find_combo_table(name), gval); + } + g_warning("ghb_lookup_combo_int() couldn't find %s", name); + return NULL; } void -ghb_update_ui_combo_box(GtkBuilder *builder, const gchar *name, gint user_data, gboolean all) +ghb_update_ui_combo_box( + signal_user_data_t *ud, + const gchar *name, + gint user_data, + gboolean all) { GtkComboBox *combo = NULL; gint signal_id; gint handler_id = 0; - g_debug("ghb_update_ui_combo_box() %s\n", name); if (name != NULL) { + g_debug("ghb_update_ui_combo_box() %s\n", name); // Clearing a combo box causes a rash of "changed" events, even when // the active item is -1 (inactive). To control things, I'm disabling // the event till things are settled down. - combo = GTK_COMBO_BOX(GHB_WIDGET(builder, name)); + combo = GTK_COMBO_BOX(GHB_WIDGET(ud->builder, name)); signal_id = g_signal_lookup("changed", GTK_TYPE_COMBO_BOX); if (signal_id > 0) { @@ -1915,49 +2593,62 @@ ghb_update_ui_combo_box(GtkBuilder *builder, const gchar *name, gint user_data, } if (all) { - audio_bitrate_opts_set(builder, "AudioBitrate"); - audio_samplerate_opts_set(builder, "AudioSamplerate", hb_audio_rates, hb_audio_rates_count); - video_rate_opts_set(builder, "VideoFramerate", hb_video_rates, hb_video_rates_count); - mix_opts_set(builder, "AudioMixdown"); - language_opts_set(builder, "SourceAudioLang"); - subtitle_opts_set(builder, "Subtitles", user_data); - title_opts_set(builder, "title"); - audio_track_opts_set(builder, "AudioTrack", user_data); - generic_opts_set(builder, "LoggingLevel", &logging_opts); - generic_opts_set(builder, "FileFormat", &container_opts); - generic_opts_set(builder, "PictureDeinterlace", &deint_opts); - generic_opts_set(builder, "PictureDetelecine", &detel_opts); - generic_opts_set(builder, "PictureDecomb", &decomb_opts); - generic_opts_set(builder, "PictureDenoise", &denoise_opts); - generic_opts_set(builder, "VideoEncoder", &vcodec_opts); - generic_opts_set(builder, "AudioEncoder", &acodec_opts); - generic_opts_set(builder, "x264_direct", &direct_opts); - generic_opts_set(builder, "x264_b_adapt", &badapt_opts); - generic_opts_set(builder, "x264_me", &me_opts); - generic_opts_set(builder, "x264_subme", &subme_opts); - generic_opts_set(builder, "x264_analyse", &analyse_opts); - generic_opts_set(builder, "x264_trellis", &trellis_opts); + audio_bitrate_opts_set(ud->builder, "AudioBitrate"); + audio_samplerate_opts_set(ud->builder, "AudioSamplerate", hb_audio_rates, hb_audio_rates_count); + video_rate_opts_set(ud->builder, "VideoFramerate", hb_video_rates, hb_video_rates_count); + mix_opts_set(ud->builder, "AudioMixdown"); + language_opts_set(ud->builder, "SrtLanguage"); + language_opts_set(ud->builder, "PreferredLanguage"); + srt_codeset_opts_set(ud->builder, "SrtCodeset"); + title_opts_set(ud->builder, "title"); + 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, "LoggingLevel", &logging_opts); + generic_opts_set(ud->builder, "LogLongevity", &log_longevity_opts); + generic_opts_set(ud->builder, "check_updates", &appcast_update_opts); + generic_opts_set(ud->builder, "FileFormat", &container_opts); + generic_opts_set(ud->builder, "PictureDeinterlace", &deint_opts); + generic_opts_set(ud->builder, "PictureDetelecine", &detel_opts); + generic_opts_set(ud->builder, "PictureDecomb", &decomb_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); } else { if (strcmp(name, "AudioBitrate") == 0) - audio_bitrate_opts_set(builder, "AudioBitrate"); + audio_bitrate_opts_set(ud->builder, "AudioBitrate"); else if (strcmp(name, "AudioSamplerate") == 0) - audio_samplerate_opts_set(builder, "AudioSamplerate", hb_audio_rates, hb_audio_rates_count); + audio_samplerate_opts_set(ud->builder, "AudioSamplerate", hb_audio_rates, hb_audio_rates_count); else if (strcmp(name, "VideoFramerate") == 0) - video_rate_opts_set(builder, "VideoFramerate", hb_video_rates, hb_video_rates_count); + video_rate_opts_set(ud->builder, "VideoFramerate", hb_video_rates, hb_video_rates_count); else if (strcmp(name, "AudioMixdown") == 0) - mix_opts_set(builder, "AudioMixdown"); - else if (strcmp(name, "SourceAudioLang") == 0) - language_opts_set(builder, "SourceAudioLang"); - else if (strcmp(name, "Subtitles") == 0) - subtitle_opts_set(builder, "Subtitles", user_data); + mix_opts_set(ud->builder, "AudioMixdown"); + else if (strcmp(name, "SrtLanguage") == 0) + language_opts_set(ud->builder, "SrtLanguage"); + else if (strcmp(name, "PreferredLanguage") == 0) + language_opts_set(ud->builder, "PreferredLanguage"); + else if (strcmp(name, "SrtCodeset") == 0) + srt_codeset_opts_set(ud->builder, "SrtCodeset"); else if (strcmp(name, "title") == 0) - title_opts_set(builder, "title"); + title_opts_set(ud->builder, "title"); + else if (strcmp(name, "SubtitleTrack") == 0) + subtitle_track_opts_set(ud->builder, "SubtitleTrack", user_data); else if (strcmp(name, "AudioTrack") == 0) - audio_track_opts_set(builder, "AudioTrack", user_data); + audio_track_opts_set(ud->builder, "AudioTrack", user_data); else - generic_opts_set(builder, name, find_combo_table(name)); + generic_opts_set(ud->builder, name, find_combo_table(name)); } if (handler_id > 0) { @@ -1974,8 +2665,9 @@ init_ui_combo_boxes(GtkBuilder *builder) init_combo_box(builder, "AudioSamplerate"); init_combo_box(builder, "VideoFramerate"); init_combo_box(builder, "AudioMixdown"); - init_combo_box(builder, "SourceAudioLang"); - init_combo_box(builder, "Subtitles"); + init_combo_box(builder, "SrtLanguage"); + init_combo_box(builder, "PreferredLanguage"); + init_combo_box(builder, "SrtCodeset"); init_combo_box(builder, "title"); init_combo_box(builder, "AudioTrack"); for (ii = 0; combo_name_map[ii].name != NULL; ii++) @@ -1985,8 +2677,8 @@ init_ui_combo_boxes(GtkBuilder *builder) } static const char * turbo_opts = - "ref=1:subme=1:me=dia:analyse=none:trellis=0:" - "no-fast-pskip=0:8x8dct=0:weightb=0"; + "ref=1:subme=2:me=dia:analyse=none:trellis=0:" + "no-fast-pskip=0:8x8dct=0"; // Construct the x264 options string // The result is allocated, so someone must free it at some point. @@ -2006,6 +2698,67 @@ ghb_build_x264opts_string(GValue *settings) return result; } +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_title_t * title; + hb_chapter_t * chapter; + gint count; + + g_debug("ghb_get_chapter_duration (title = %d)\n", ti); + *hh = *mm = *ss = 0; + if (h_scan == NULL) return; + list = hb_get_titles( h_scan ); + title = (hb_title_t*)hb_list_item( list, ti ); + if (title == NULL) return; + count = hb_list_count( title->list_chapter ); + if (ii >= count) return; + chapter = hb_list_item(title->list_chapter, ii); + if (chapter == NULL) return; + *hh = chapter->hours; + *mm = chapter->minutes; + *ss = chapter->seconds; +} + GValue* ghb_get_chapters(gint titleindex) { @@ -2054,7 +2807,7 @@ ghb_ac3_in_audio_list(const GValue *audio_list) asettings = ghb_array_get_nth(audio_list, ii); acodec = ghb_settings_combo_int(asettings, "AudioEncoder"); - if (acodec == HB_ACODEC_AC3) + if (acodec & HB_ACODEC_AC3) return TRUE; } return FALSE; @@ -2067,17 +2820,20 @@ audio_bitrate_opts_add(GtkBuilder *builder, const gchar *name, gint rate) GtkListStore *store; gchar *str; - g_debug("audio_rate_opts_add ()\n"); + g_debug("audio_bitrate_opts_add ()\n"); + + if (rate < 8) return; + store = get_combo_box_store(builder, name); if (!find_combo_item_by_int(GTK_TREE_MODEL(store), rate, &iter)) { - str = g_strdup_printf ("%d", rate); + str = g_strdup_printf ("%d", rate); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, str, 1, TRUE, 2, str, - 3, rate, + 3, (gdouble)rate, 4, str, -1); g_free(str); @@ -2085,14 +2841,19 @@ audio_bitrate_opts_add(GtkBuilder *builder, const gchar *name, gint rate) } static void -audio_bitrate_opts_clean(GtkBuilder *builder, const gchar *name, gint last_rate) +audio_bitrate_opts_clean( + GtkBuilder *builder, + const gchar *name, + gint first_rate, + gint last_rate) { GtkTreeIter iter; GtkListStore *store; - gint ivalue; + gdouble ivalue; gboolean done = FALSE; gint ii = 0; guint last = (guint)last_rate; + guint first = (guint)first_rate; g_debug("audio_bitrate_opts_clean ()\n"); store = get_combo_box_store(builder, name); @@ -2106,7 +2867,7 @@ audio_bitrate_opts_clean(GtkBuilder *builder, const gchar *name, gint last_rate) { done = !gtk_list_store_remove(store, &iter); } - else if (ivalue > last) + else if (ivalue < first || ivalue > last) { ii++; gtk_list_store_set(store, &iter, 1, FALSE, -1); @@ -2128,6 +2889,7 @@ audio_bitrate_opts_set(GtkBuilder *builder, const gchar *name) GtkTreeIter iter; GtkListStore *store; gint ii; + gchar *str; g_debug("audio_bitrate_opts_set ()\n"); store = get_combo_box_store(builder, name); @@ -2135,13 +2897,16 @@ audio_bitrate_opts_set(GtkBuilder *builder, const gchar *name) for (ii = 0; ii < hb_audio_bitrates_count; ii++) { gtk_list_store_append(store, &iter); + str = g_strdup_printf ("%s", + hb_audio_bitrates[ii].string); gtk_list_store_set(store, &iter, - 0, hb_audio_bitrates[ii].string, + 0, str, 1, TRUE, 2, hb_audio_bitrates[ii].string, - 3, hb_audio_bitrates[ii].rate, + 3, (gdouble)hb_audio_bitrates[ii].rate, 4, hb_audio_bitrates[ii].string, -1); + g_free(str); } } @@ -2152,20 +2917,23 @@ ghb_set_passthru_bitrate_opts(GtkBuilder *builder, gint bitrate) } void -ghb_set_default_bitrate_opts(GtkBuilder *builder, gint last_rate) +ghb_set_default_bitrate_opts( + GtkBuilder *builder, + gint first_rate, + gint last_rate) { - audio_bitrate_opts_clean(builder, "AudioBitrate", last_rate); + audio_bitrate_opts_clean(builder, "AudioBitrate", first_rate, last_rate); } static ghb_status_t hb_status; void -ghb_combo_init(GtkBuilder *builder) +ghb_combo_init(signal_user_data_t *ud) { // Set up the list model for the combos - init_ui_combo_boxes(builder); + init_ui_combo_boxes(ud->builder); // Populate all the combos - ghb_update_ui_combo_box(builder, NULL, 0, TRUE); + ghb_update_ui_combo_box(ud, NULL, 0, TRUE); } void @@ -2183,6 +2951,11 @@ ghb_backend_close() hb_close(&h_scan); } +void ghb_backend_scan_stop() +{ + hb_scan_stop( h_scan ); +} + void ghb_backend_scan(const gchar *path, gint titleindex, gint preview_count) { @@ -2347,6 +3120,22 @@ ghb_track_status() 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; @@ -2377,6 +3166,7 @@ ghb_track_status() 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: @@ -2415,8 +3205,9 @@ ghb_get_title_info(ghb_title_info_t *tinfo, gint titleindex) 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)); @@ -2435,6 +3226,11 @@ ghb_get_title_info(ghb_title_info_t *tinfo, gint titleindex) tinfo->minutes = title->minutes; tinfo->seconds = title->seconds; tinfo->duration = title->duration; + + tinfo->angle_count = title->angle_count; + tinfo->path = title->path; + tinfo->name = title->name; + tinfo->type = title->type; return TRUE; } @@ -2455,7 +3251,7 @@ gboolean ghb_audio_is_passthru(gint acodec) { g_debug("ghb_audio_is_passthru () \n"); - return (acodec == HB_ACODEC_AC3) || (acodec == HB_ACODEC_DCA); + return (acodec & (HB_ACODEC_AC3 | HB_ACODEC_DCA)); } gint @@ -2464,28 +3260,81 @@ ghb_get_default_acodec() return HB_ACODEC_FAAC; } +static void +picture_settings_deps(signal_user_data_t *ud) +{ + gboolean autoscale, keep_aspect, enable_keep_aspect; + gboolean enable_scale_width, enable_scale_height; + gboolean enable_disp_width, enable_disp_height, enable_par; + gint pic_par; + GtkWidget *widget; + + pic_par = ghb_settings_combo_int(ud->settings, "PicturePAR"); + if (pic_par == 1) + { + ghb_ui_update(ud, "autoscale", ghb_boolean_value(TRUE)); + ghb_ui_update(ud, "PictureModulus", ghb_int_value(2)); + ghb_ui_update(ud, "PictureLooseCrop", ghb_boolean_value(TRUE)); + } + enable_keep_aspect = (pic_par != 1 && pic_par != 2); + if (!enable_keep_aspect) + { + ghb_ui_update(ud, "PictureKeepRatio", ghb_boolean_value(TRUE)); + } + keep_aspect = ghb_settings_get_boolean(ud->settings, "PictureKeepRatio"); + autoscale = ghb_settings_get_boolean(ud->settings, "autoscale"); + + enable_scale_width = !autoscale && (pic_par != 1); + enable_scale_height = !autoscale && (pic_par != 1); + enable_disp_width = (pic_par == 3) && !keep_aspect; + enable_par = (pic_par == 3) && !keep_aspect; + enable_disp_height = FALSE; + + widget = GHB_WIDGET(ud->builder, "PictureModulus"); + gtk_widget_set_sensitive(widget, pic_par != 1); + widget = GHB_WIDGET(ud->builder, "PictureLooseCrop"); + gtk_widget_set_sensitive(widget, pic_par != 1); + widget = GHB_WIDGET(ud->builder, "scale_width"); + gtk_widget_set_sensitive(widget, enable_scale_width); + widget = GHB_WIDGET(ud->builder, "scale_height"); + gtk_widget_set_sensitive(widget, enable_scale_height); + widget = GHB_WIDGET(ud->builder, "PictureDisplayWidth"); + gtk_widget_set_sensitive(widget, enable_disp_width); + widget = GHB_WIDGET(ud->builder, "PictureDisplayHeight"); + gtk_widget_set_sensitive(widget, enable_disp_height); + widget = GHB_WIDGET(ud->builder, "PicturePARWidth"); + gtk_widget_set_sensitive(widget, enable_par); + widget = GHB_WIDGET(ud->builder, "PicturePARHeight"); + gtk_widget_set_sensitive(widget, enable_par); + widget = GHB_WIDGET(ud->builder, "PictureKeepRatio"); + gtk_widget_set_sensitive(widget, enable_keep_aspect); + widget = GHB_WIDGET(ud->builder, "autoscale"); + gtk_widget_set_sensitive(widget, pic_par != 1); +} + void ghb_set_scale(signal_user_data_t *ud, gint mode) { hb_list_t * list; hb_title_t * title; hb_job_t * job; - gboolean keep_aspect, round_dims, anamorphic; + gboolean keep_aspect; + gint pic_par; gboolean autocrop, autoscale, noscale; gint crop[4], width, height, par_width, par_height; gint crop_width, crop_height; gint aspect_n, aspect_d; - gboolean keep_width = (mode == GHB_SCALE_KEEP_WIDTH); - gboolean keep_height = (mode == GHB_SCALE_KEEP_HEIGHT); + gboolean keep_width = (mode & GHB_PIC_KEEP_WIDTH); + gboolean keep_height = (mode & GHB_PIC_KEEP_HEIGHT); gint step; GtkWidget *widget; - gint modshift; - gint modround; + gint mod; gint max_width = 0; gint max_height = 0; + 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 ) ) @@ -2500,74 +3349,104 @@ ghb_set_scale(signal_user_data_t *ud, gint mode) 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); + } + // First configure widgets - round_dims = ghb_settings_get_boolean(ud->settings, "ModDimensions"); - anamorphic = ghb_settings_get_boolean(ud->settings, "anamorphic"); + mod = ghb_settings_combo_int(ud->settings, "PictureModulus"); + pic_par = ghb_settings_combo_int(ud->settings, "PicturePAR"); keep_aspect = ghb_settings_get_boolean(ud->settings, "PictureKeepRatio"); autocrop = ghb_settings_get_boolean(ud->settings, "PictureAutoCrop"); autoscale = ghb_settings_get_boolean(ud->settings, "autoscale"); // "Noscale" is a flag that says we prefer to crop extra to satisfy // alignment constraints rather than scaling to satisfy them. - noscale = ghb_settings_get_boolean(ud->settings, "noscale"); + noscale = ghb_settings_get_boolean(ud->settings, "PictureLooseCrop"); // Align dimensions to either 16 or 2 pixels // The scaler crashes if the dimensions are not divisible by 2 // x264 also will not accept dims that are not multiple of 2 - modshift = round_dims ? 4 : 1; - modround = round_dims ? 8 : 1; if (autoscale) { keep_width = FALSE; keep_height = FALSE; } - if (keep_aspect) - { - keep_height = FALSE; - } // Step needs to be at least 2 because odd widths cause scaler crash - step = round_dims ? 16 : 2; + step = mod; widget = GHB_WIDGET (ud->builder, "scale_width"); gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), step, 16); widget = GHB_WIDGET (ud->builder, "scale_height"); gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), step, 16); + if (noscale) + { + widget = GHB_WIDGET (ud->builder, "PictureTopCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), step, 16); + widget = GHB_WIDGET (ud->builder, "PictureBottomCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), step, 16); + widget = GHB_WIDGET (ud->builder, "PictureLeftCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), step, 16); + widget = GHB_WIDGET (ud->builder, "PictureRightCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), step, 16); + } + else + { + widget = GHB_WIDGET (ud->builder, "PictureTopCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), 1, 16); + widget = GHB_WIDGET (ud->builder, "PictureBottomCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), 1, 16); + widget = GHB_WIDGET (ud->builder, "PictureLeftCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), 1, 16); + widget = GHB_WIDGET (ud->builder, "PictureRightCrop"); + gtk_spin_button_set_increments (GTK_SPIN_BUTTON(widget), 1, 16); + } + ghb_title_info_t tinfo; + ghb_get_title_info (&tinfo, titleindex); if (autocrop) { - ghb_title_info_t tinfo; - - if (ghb_get_title_info (&tinfo, titleindex)) - { - crop[0] = tinfo.crop[0]; - crop[1] = tinfo.crop[1]; - crop[2] = tinfo.crop[2]; - crop[3] = tinfo.crop[3]; - if (noscale) - { - gint need1, need2; - - // Adjust the cropping to accomplish the desired width and height - crop_width = tinfo.width - crop[2] - crop[3]; - crop_height = tinfo.height - crop[0] - crop[1]; - width = (crop_width >> modshift) << modshift; - height = (crop_height >> modshift) << modshift; - need1 = (crop_height - height) / 2; - need2 = crop_height - height - need1; - crop[0] += need1; - crop[1] += need2; - need1 = (crop_width - width) / 2; - need2 = crop_width - width - need1; - crop[2] += need1; - crop[3] += need2; - } - ghb_ui_update(ud, "PictureTopCrop", ghb_int64_value(crop[0])); - ghb_ui_update(ud, "PictureBottomCrop", ghb_int64_value(crop[1])); - ghb_ui_update(ud, "PictureLeftCrop", ghb_int64_value(crop[2])); - ghb_ui_update(ud, "PictureRightCrop", ghb_int64_value(crop[3])); - } + crop[0] = tinfo.crop[0]; + crop[1] = tinfo.crop[1]; + crop[2] = tinfo.crop[2]; + crop[3] = tinfo.crop[3]; + ghb_ui_update(ud, "PictureTopCrop", ghb_int64_value(crop[0])); + ghb_ui_update(ud, "PictureBottomCrop", ghb_int64_value(crop[1])); + ghb_ui_update(ud, "PictureLeftCrop", ghb_int64_value(crop[2])); + ghb_ui_update(ud, "PictureRightCrop", ghb_int64_value(crop[3])); + } + else + { + crop[0] = ghb_settings_get_int(ud->settings, "PictureTopCrop"); + crop[1] = ghb_settings_get_int(ud->settings, "PictureBottomCrop"); + crop[2] = ghb_settings_get_int(ud->settings, "PictureLeftCrop"); + crop[3] = ghb_settings_get_int(ud->settings, "PictureRightCrop"); + } + if (noscale) + { + gint need1, need2; + + // Adjust the cropping to accomplish the desired width and height + crop_width = tinfo.width - crop[2] - crop[3]; + crop_height = tinfo.height - crop[0] - crop[1]; + width = MOD_DOWN(crop_width, mod); + height = MOD_DOWN(crop_height, mod); + + need1 = (crop_height - height) / 2; + need2 = crop_height - height - need1; + crop[0] += need1; + crop[1] += need2; + need1 = (crop_width - width) / 2; + need2 = crop_width - width - need1; + crop[2] += need1; + crop[3] += need2; + ghb_ui_update(ud, "PictureTopCrop", ghb_int64_value(crop[0])); + ghb_ui_update(ud, "PictureBottomCrop", ghb_int64_value(crop[1])); + ghb_ui_update(ud, "PictureLeftCrop", ghb_int64_value(crop[2])); + ghb_ui_update(ud, "PictureRightCrop", ghb_int64_value(crop[3])); } - crop[0] = ghb_settings_get_int(ud->settings, "PictureTopCrop"); - crop[1] = ghb_settings_get_int(ud->settings, "PictureBottomCrop"); - crop[2] = ghb_settings_get_int(ud->settings, "PictureLeftCrop"); - crop[3] = ghb_settings_get_int(ud->settings, "PictureRightCrop"); hb_reduce(&aspect_n, &aspect_d, title->width * title->pixel_aspect_width, title->height * title->pixel_aspect_height); @@ -2577,77 +3456,107 @@ ghb_set_scale(signal_user_data_t *ud, gint mode) { width = crop_width; height = crop_height; - max_width = 0; - max_height = 0; } else { width = ghb_settings_get_int(ud->settings, "scale_width"); height = ghb_settings_get_int(ud->settings, "scale_height"); - max_width = ghb_settings_get_int(ud->settings, "PictureWidth"); - max_height = ghb_settings_get_int(ud->settings, "PictureHeight"); - // Align max dims - max_width = (max_width >> modshift) << modshift; - max_height = (max_height >> modshift) << modshift; - // Adjust dims according to max values - if (!max_height) - { - max_height = crop_height; - } - if (!max_width) - { - max_width = crop_width; - } - height = MIN(height, max_height); - width = MIN(width, max_width); - g_debug("max_width %d, max_height %d\n", max_width, max_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); } + g_debug("max_width %d, max_height %d\n", max_width, max_height); + if (width < 16) width = title->width - crop[2] - crop[3]; if (height < 16) height = title->height - crop[0] - crop[1]; - if (anamorphic) + 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); + + if (pic_par) { - job->anamorphic.mode = autoscale ? 2 : 3; + 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 = round_dims ? 16 : 2; + job->anamorphic.modulus = mod; + job->anamorphic.par_width = title->pixel_aspect_width; + job->anamorphic.par_height = title->pixel_aspect_height; + job->anamorphic.dar_width = 0; + job->anamorphic.dar_height = 0; + + if (keep_height && pic_par == 2) + width = ((double)height * crop_width / crop_height) + mod / 2; job->width = width; job->height = height; - if (max_height) - job->maxHeight = max_height; + job->maxWidth = max_width; + job->maxHeight = max_height; job->crop[0] = crop[0]; job->crop[1] = crop[1]; job->crop[2] = crop[2]; job->crop[3] = crop[3]; + if (job->anamorphic.mode == 3 && !keep_aspect) + { + job->anamorphic.keep_display_aspect = 0; + if (mode & GHB_PIC_KEEP_PAR) + { + job->anamorphic.par_width = + ghb_settings_get_int(ud->settings, "PicturePARWidth"); + job->anamorphic.par_height = + ghb_settings_get_int(ud->settings, "PicturePARHeight"); + } + else + { + job->anamorphic.dar_width = + ghb_settings_get_int(ud->settings, + "PictureDisplayWidth"); + job->anamorphic.dar_height = height; + } + } + else + { + job->anamorphic.keep_display_aspect = 1; + } hb_set_anamorphic_size( job, &width, &height, &par_width, &par_height ); + if (job->anamorphic.mode == 3 && !keep_aspect && + mode & GHB_PIC_KEEP_PAR) + { + // hb_set_anamorphic_size reduces the par, which we + // don't want in this case because the user is + // explicitely specifying it. + par_width = ghb_settings_get_int(ud->settings, + "PicturePARWidth"); + par_height = ghb_settings_get_int(ud->settings, + "PicturePARHeight"); + } } else { - job->anamorphic.mode = 0; + job->anamorphic.mode = pic_par; if (keep_aspect) { gdouble par; gint new_width, new_height; - g_debug("kw %s kh %s\n", keep_width ? "y":"n", keep_height ? "y":"n"); - g_debug("w %d h %d\n", width, height); // Compute pixel aspect ration. par = (gdouble)(title->height * aspect_n) / (title->width * aspect_d); // Must scale so that par becomes 1:1 // Try to keep largest dimension new_height = (crop_height * ((gdouble)width/crop_width) / par); new_width = (crop_width * ((gdouble)height/crop_height) * par); - // Height and width are always multiples of 2, so do the rounding - new_height = ((new_height + 1) >> 1) << 1; - new_width = ((new_width + 1) >> 1) << 1; - if ((max_width && new_width > max_width) || - new_width > title->width) + + if (max_width && new_width > max_width) { height = new_height; } - else if ((max_height && new_height > max_height) || - new_height > title->height) + else if (max_height && new_height > max_height) { width = new_width; } @@ -2669,11 +3578,47 @@ ghb_set_scale(signal_user_data_t *ud, gint mode) } g_debug("new w %d h %d\n", width, height); } - width = ((width + modround) >> modshift) << modshift; - height = ((height + modround) >> modshift) << modshift; + width = MOD_ROUND(width, mod); + height = MOD_ROUND(height, mod); + if (max_height) + height = MIN(height, max_height); + if (max_width) + width = MIN(width, max_width); + par_width = par_height = 1; } ghb_ui_update(ud, "scale_width", ghb_int64_value(width)); ghb_ui_update(ud, "scale_height", ghb_int64_value(height)); + + gint disp_width, dar_width, dar_height; + gchar *str; + + disp_width = (gdouble)(width * par_width / par_height) + 0.5; + hb_reduce(&dar_width, &dar_height, disp_width, height); + + gint iaspect = dar_width * 9 / dar_height; + if (dar_width > 2 * dar_height) + { + str = g_strdup_printf("%.2f : 1", (gdouble)dar_width / dar_height); + } + else if (iaspect <= 16 && iaspect >= 15) + { + str = g_strdup_printf("%.2f : 9", (gdouble)dar_width * 9 / dar_height); + } + else if (iaspect <= 12 && iaspect >= 11) + { + str = g_strdup_printf("%.2f : 3", (gdouble)dar_width * 3 / dar_height); + } + else + { + str = g_strdup_printf("%d : %d", dar_width, dar_height); + } + ghb_ui_update(ud, "display_aspect", ghb_string_value(str)); + g_free(str); + ghb_ui_update(ud, "PicturePARWidth", ghb_int64_value(par_width)); + 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; } static void @@ -2684,25 +3629,61 @@ set_preview_job_settings(hb_job_t *job, GValue *settings) job->crop[2] = ghb_settings_get_int(settings, "PictureLeftCrop"); job->crop[3] = ghb_settings_get_int(settings, "PictureRightCrop"); - gboolean anamorphic, round_dimensions, autoscale; - autoscale = ghb_settings_get_boolean(settings, "autoscale"); - anamorphic = ghb_settings_get_boolean(settings, "anamorphic"); - round_dimensions = ghb_settings_get_boolean(settings, "ModDimensions"); - if (anamorphic) + job->anamorphic.mode = ghb_settings_combo_int(settings, "PicturePAR"); + job->anamorphic.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"); + if (ghb_settings_get_boolean(settings, "show_crop")) { - job->anamorphic.modulus = round_dimensions ? 16 : 2; - job->anamorphic.mode = autoscale ? 2 : 3; + gdouble xscale = (gdouble)job->width / + (gdouble)(job->title->width - job->crop[2] - job->crop[3]); + gdouble yscale = (gdouble)job->height / + (gdouble)(job->title->height - job->crop[0] - job->crop[1]); + + job->width += xscale * (job->crop[2] + job->crop[3]); + job->height += yscale * (job->crop[0] + job->crop[1]); + job->crop[0] = 0; + job->crop[1] = 0; + job->crop[2] = 0; + job->crop[3] = 0; + job->anamorphic.modulus = 2; + } + + gboolean decomb_deint = ghb_settings_get_boolean(settings, "PictureDecombDeinterlace"); + if (decomb_deint) + { + gint decomb = ghb_settings_combo_int(settings, "PictureDecomb"); + job->deinterlace = (decomb == 0) ? 0 : 1; } else { - job->anamorphic.modulus = 2; - job->anamorphic.mode = 0; + gint deint = ghb_settings_combo_int(settings, "PictureDeinterlace"); + job->deinterlace = (deint == 0) ? 0 : 1; + } + + gboolean keep_aspect; + keep_aspect = ghb_settings_get_boolean(settings, "PictureKeepRatio"); + if (job->anamorphic.mode) + { + job->anamorphic.par_width = job->title->pixel_aspect_width; + job->anamorphic.par_height = job->title->pixel_aspect_height; + job->anamorphic.dar_width = 0; + job->anamorphic.dar_height = 0; + + if (job->anamorphic.mode == 3 && !keep_aspect) + { + job->anamorphic.keep_display_aspect = 0; + job->anamorphic.par_width = + ghb_settings_get_int(settings, "PicturePARWidth"); + job->anamorphic.par_height = + ghb_settings_get_int(settings, "PicturePARHeight"); + } + else + { + job->anamorphic.keep_display_aspect = 1; + } } - job->width = ghb_settings_get_int(settings, "scale_width"); - job->height = ghb_settings_get_int(settings, "scale_height"); - gint deint = ghb_settings_combo_int(settings, "PictureDeinterlace"); - gint decomb = ghb_settings_combo_int(settings, "PictureDecomb"); - job->deinterlace = (!decomb && deint == 0) ? 0 : 1; } gint @@ -2758,12 +3739,13 @@ ghb_validate_filters(signal_user_data_t *ud) gint index; gchar *message; - // deinte 4 + gboolean decomb_deint = ghb_settings_get_boolean(ud->settings, "PictureDecombDeinterlace"); + // deinte index = ghb_settings_combo_int(ud->settings, "PictureDeinterlace"); - if (index == 1) + if (!decomb_deint && index == 1) { str = ghb_settings_get_string(ud->settings, "PictureDeinterlaceCustom"); - if (!ghb_validate_filter_string(str, 4)) + if (!ghb_validate_filter_string(str, -1)) { message = g_strdup_printf( "Invalid Deinterlace Settings:\n\n%s\n", @@ -2780,7 +3762,7 @@ ghb_validate_filters(signal_user_data_t *ud) if (index == 1) { str = ghb_settings_get_string(ud->settings, "PictureDetelecineCustom"); - if (!ghb_validate_filter_string(str, 6)) + if (!ghb_validate_filter_string(str, -1)) { message = g_strdup_printf( "Invalid Detelecine Settings:\n\n%s\n", @@ -2792,12 +3774,12 @@ ghb_validate_filters(signal_user_data_t *ud) } g_free(str); } - // decomb 4 + // decomb index = ghb_settings_combo_int(ud->settings, "PictureDecomb"); - if (index == 1) + if (decomb_deint && index == 1) { str = ghb_settings_get_string(ud->settings, "PictureDecombCustom"); - if (!ghb_validate_filter_string(str, 7)) + if (!ghb_validate_filter_string(str, -1)) { message = g_strdup_printf( "Invalid Decomb Settings:\n\n%s\n", @@ -2809,12 +3791,12 @@ ghb_validate_filters(signal_user_data_t *ud) } g_free(str); } - // denois 4 + // denois index = ghb_settings_combo_int(ud->settings, "PictureDenoise"); if (index == 1) { str = ghb_settings_get_string(ud->settings, "PictureDenoiseCustom"); - if (!ghb_validate_filter_string(str, 4)) + if (!ghb_validate_filter_string(str, -1)) { message = g_strdup_printf( "Invalid Denoise Settings:\n\n%s\n", @@ -2837,27 +3819,179 @@ ghb_validate_video(signal_user_data_t *ud) mux = ghb_settings_combo_int(ud->settings, "FileFormat"); vcodec = ghb_settings_combo_int(ud->settings, "VideoEncoder"); - if ((mux == HB_MUX_MP4 || mux == HB_MUX_AVI) && - (vcodec == HB_VCODEC_THEORA)) + if ((mux == HB_MUX_MP4) && (vcodec == HB_VCODEC_THEORA)) { - // mp4|avi/theora combination is not supported. + // mp4/theora combination is not supported. message = g_strdup_printf( - "Theora is not supported in the MP4 and AVI containers.\n\n" + "Theora is not supported in the MP4 container.\n\n" "You should choose a different video codec or container.\n" - "If you continue, XviD will be chosen for you."); + "If you continue, FFMPEG will be chosen for you."); if (!ghb_message_dialog(GTK_MESSAGE_WARNING, message, "Cancel", "Continue")) { g_free(message); return FALSE; } g_free(message); - vcodec = HB_VCODEC_XVID; + vcodec = HB_VCODEC_FFMPEG; ghb_ui_update(ud, "VideoEncoder", ghb_int64_value(vcodec)); } return TRUE; } gboolean +ghb_validate_subtitles(signal_user_data_t *ud) +{ + hb_list_t * list; + hb_title_t * title; + gchar *message; + + if (h_scan == NULL) return FALSE; + list = hb_get_titles( h_scan ); + if( !hb_list_count( list ) ) + { + /* No valid title, stop right there */ + g_message("No title found.\n"); + return FALSE; + } + + gint titleindex; + + 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; + gboolean burned, one_burned = FALSE; + + slist = ghb_settings_get_value(ud->settings, "subtitle_list"); + count = ghb_array_len(slist); + for (ii = 0; ii < count; ii++) + { + settings = ghb_array_get_nth(slist, ii); + source = ghb_settings_get_int(settings, "SubtitleSource"); + burned = ghb_settings_get_boolean(settings, "SubtitleBurned"); + if (burned && one_burned) + { + // MP4 can only handle burned vobsubs. make sure there isn't + // already something burned in the list + message = g_strdup_printf( + "Only one subtitle may be burned into the video.\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; + } + else if (burned) + { + 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; + + filename = ghb_settings_get_string(settings, "SrtFile"); + if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) + { + message = g_strdup_printf( + "Srt file does not exist or not a regular file.\n\n" + "You should choose a valid file.\n" + "If you continue, this subtitle will be ignored."); + if (!ghb_message_dialog(GTK_MESSAGE_WARNING, message, + "Cancel", "Continue")) + { + g_free(message); + return FALSE; + } + g_free(message); + break; + } + } + } + return TRUE; +} + +gint +ghb_select_audio_codec(signal_user_data_t *ud, gint track) +{ + hb_list_t * list; + hb_title_t * title; + hb_audio_config_t *audio; + + if (h_scan == NULL) return -1; + list = hb_get_titles( h_scan ); + if( !hb_list_count( list ) ) + { + return -1; + } + + gint titleindex; + + titleindex = ghb_settings_combo_int(ud->settings, "title"); + title = hb_list_item( list, titleindex ); + if (title == NULL) return -1; + + gint mux = ghb_settings_combo_int(ud->settings, "FileFormat"); + + if (track < 0 || track >= hb_list_count(title->list_audio)) + return -1; + + audio = (hb_audio_config_t *) hb_list_audio_config_item( + title->list_audio, track ); + if (mux == HB_MUX_MP4) + { + if (audio->in.codec == HB_ACODEC_AC3) + return audio->in.codec; + else + return HB_ACODEC_FAAC; + } + else + { + if (audio->in.codec == HB_ACODEC_AC3 || audio->in.codec == HB_ACODEC_DCA) + return audio->in.codec; + else + return HB_ACODEC_LAME; + } +} + +const gchar* +ghb_select_audio_codec_str(signal_user_data_t *ud, gint track) +{ + gint acodec, ii; + + acodec = ghb_select_audio_codec(ud, track); + for (ii = 0; ii < acodec_opts.count; ii++) + { + if (acodec_opts.map[ii].ivalue == acodec) + return acodec_opts.map[ii].option; + } + return "Unknown"; +} + +gboolean ghb_validate_audio(signal_user_data_t *ud) { hb_list_t * list; @@ -2894,25 +4028,26 @@ ghb_validate_audio(signal_user_data_t *ud) asettings = ghb_array_get_nth(audio_list, ii); gint track = ghb_settings_combo_int(asettings, "AudioTrack"); gint codec = ghb_settings_combo_int(asettings, "AudioEncoder"); + if (codec == HB_ACODEC_MASK) + continue; + taudio = (hb_audio_config_t *) hb_list_audio_config_item( title->list_audio, track ); - if ((taudio->in.codec != HB_ACODEC_AC3 && codec == HB_ACODEC_AC3) || - (taudio->in.codec != HB_ACODEC_DCA && codec == HB_ACODEC_DCA)) + if (!(taudio->in.codec & codec) && + (codec & (HB_ACODEC_AC3 | HB_ACODEC_DCA))) { // Not supported. AC3 is passthrough only, so input must be AC3 - char *str; - str = (codec == HB_ACODEC_AC3) ? "AC-3" : "DTS"; message = g_strdup_printf( - "The source does not support %s Pass-Thru.\n\n" + "The source does not support Pass-Thru.\n\n" "You should choose a different audio codec.\n" - "If you continue, one will be chosen for you.", str); + "If you continue, one will be chosen for you."); if (!ghb_message_dialog(GTK_MESSAGE_WARNING, message, "Cancel", "Continue")) { g_free(message); return FALSE; } g_free(message); - if (mux == HB_MUX_AVI) + if (mux == HB_MUX_MKV) { codec = HB_ACODEC_LAME; } @@ -2920,7 +4055,7 @@ ghb_validate_audio(signal_user_data_t *ud) { 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; @@ -2939,40 +4074,10 @@ ghb_validate_audio(signal_user_data_t *ud) a_unsup = "Vorbis"; codec = HB_ACODEC_FAAC; } - } - else if (mux == HB_MUX_AVI) - { - mux_s = "AVI"; - // avi/faac|vorbis combination is not supported. - if (codec == HB_ACODEC_FAAC) - { - a_unsup = "FAAC"; - codec = HB_ACODEC_LAME; - } - if (codec == HB_ACODEC_VORBIS) - { - a_unsup = "Vorbis"; - codec = HB_ACODEC_LAME; - } - } - else if (mux == HB_MUX_OGM) - { - mux_s = "OGM"; - // avi/faac|vorbis combination is not supported. - if (codec == HB_ACODEC_FAAC) - { - a_unsup = "FAAC"; - codec = HB_ACODEC_VORBIS; - } - if (codec == HB_ACODEC_AC3) - { - a_unsup = "AC-3"; - codec = HB_ACODEC_VORBIS; - } if (codec == HB_ACODEC_DCA) { a_unsup = "DTS"; - codec = HB_ACODEC_VORBIS; + codec = HB_ACODEC_FAAC; } } if (a_unsup) @@ -2987,7 +4092,7 @@ ghb_validate_audio(signal_user_data_t *ud) 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"); @@ -2998,7 +4103,7 @@ ghb_validate_audio(signal_user_data_t *ud) gboolean allow_6ch = TRUE; allow_mono = (taudio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) && - (codec != HB_ACODEC_LAME); + (codec & ~HB_ACODEC_LAME); 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); @@ -3009,7 +4114,7 @@ ghb_validate_audio(signal_user_data_t *ud) allow_dpl2 = (layout == HB_INPUT_CH_LAYOUT_3F2R); allow_6ch = (taudio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) && - (codec != HB_ACODEC_LAME) && + (codec & ~HB_ACODEC_LAME) && (layout == HB_INPUT_CH_LAYOUT_3F2R) && (taudio->in.channel_layout & HB_INPUT_CH_LAYOUT_HAS_LFE); @@ -3075,7 +4180,6 @@ ghb_validate_vquality(GValue *settings) max = 30; } break; - case HB_VCODEC_XVID: case HB_VCODEC_FFMPEG: { min = 1; @@ -3145,6 +4249,7 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) job = title->job; if (job == NULL) return; + job->angle = ghb_settings_get_int(js, "angle"); job->start_at_preview = ghb_settings_get_int(js, "start_frame") + 1; if (job->start_at_preview) { @@ -3166,39 +4271,67 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) } 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; if ( job->chapter_markers ) { GValue *chapters; 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); @@ -3211,36 +4344,42 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) job->crop[3] = ghb_settings_get_int(js, "PictureRightCrop"); + gboolean decomb_deint = ghb_settings_get_boolean(js, "PictureDecombDeinterlace"); gint decomb = ghb_settings_combo_int(js, "PictureDecomb"); gint deint = ghb_settings_combo_int(js, "PictureDeinterlace"); - if (!decomb) + if (!decomb_deint) job->deinterlace = (deint != 0) ? 1 : 0; else job->deinterlace = 0; job->grayscale = ghb_settings_get_boolean(js, "VideoGrayScale"); - gboolean autoscale = ghb_settings_get_boolean(js, "autoscale"); - gboolean anamorphic = ghb_settings_get_boolean(js, "anamorphic"); - gboolean round_dimensions = ghb_settings_get_boolean(js, "ModDimensions"); - if (anamorphic) + 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"); + if (job->anamorphic.mode) { - job->anamorphic.mode = autoscale ? 2 : 3; - // Also, x264 requires things to be divisible by 2. - job->anamorphic.modulus = round_dimensions ? 16 : 2; - } - else - { - job->anamorphic.mode = 0; - job->anamorphic.modulus = 2; + job->anamorphic.par_width = title->pixel_aspect_width; + job->anamorphic.par_height = title->pixel_aspect_height; + job->anamorphic.dar_width = 0; + job->anamorphic.dar_height = 0; + + if (job->anamorphic.mode == 3 && !keep_aspect) + { + job->anamorphic.keep_display_aspect = 0; + job->anamorphic.par_width = + ghb_settings_get_int(js, "PicturePARWidth"); + job->anamorphic.par_height = + ghb_settings_get_int(js, "PicturePARHeight"); + } + else + { + job->anamorphic.keep_display_aspect = 1; + } } + /* Add selected filters */ job->filters = hb_list_init(); - gint vrate = ghb_settings_combo_int(js, "VideoFramerate"); - if( vrate == 0 && ghb_settings_combo_int(js, "PictureDetelecine" ) ) - job->vfr = 1; - else - job->vfr = 0; - gint detel = ghb_settings_combo_int(js, "PictureDetelecine"); if ( detel ) { @@ -3254,7 +4393,7 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) hb_filter_detelecine.settings = detel_str; hb_list_add( job->filters, &hb_filter_detelecine ); } - if ( decomb ) + if ( decomb_deint && decomb ) { if (decomb != 1) { @@ -3302,11 +4441,10 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) job->height = ghb_settings_get_int(js, "scale_height"); job->vcodec = ghb_settings_combo_int(js, "VideoEncoder"); - if ((job->mux == HB_MUX_MP4 || job->mux == HB_MUX_AVI) && - (job->vcodec == HB_VCODEC_THEORA)) + if ((job->mux == HB_MUX_MP4 ) && (job->vcodec == HB_VCODEC_THEORA)) { - // mp4|avi/theora combination is not supported. - job->vcodec = HB_VCODEC_XVID; + // mp4/theora combination is not supported. + job->vcodec = HB_VCODEC_FFMPEG; } if ((job->vcodec == HB_VCODEC_X264) && (job->mux == HB_MUX_MP4)) { @@ -3324,13 +4462,8 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) job->vquality = -1.0; job->vbitrate = ghb_settings_get_int(js, "VideoAvgBitrate"); } - // AVI container does not support variable frame rate. - if (job->mux == HB_MUX_AVI) - { - job->vfr = FALSE; - job->cfr = 1; - } + gint vrate = ghb_settings_combo_int(js, "VideoFramerate"); if( vrate == 0 ) { job->vrate = title->rate; @@ -3343,18 +4476,9 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) job->vrate_base = vrate; job->cfr = 1; } - // First remove any audios that are already in the list - // This happens if you are encoding the same title a second time. - gint num_audio_tracks = hb_list_count(job->list_audio); - gint ii; - for(ii = 0; ii < num_audio_tracks; ii++) - { - hb_audio_t *audio = (hb_audio_t*)hb_list_item(job->list_audio, 0); - hb_list_rem(job->list_audio, audio); - } const GValue *audio_list; - gint count; + gint count, ii; gint tcount = 0; audio_list = ghb_settings_get_value(js, "audio_list"); @@ -3372,54 +4496,56 @@ add_job(hb_handle_t *h, GValue *js, gint unique_id, gint titleindex) audio.out.codec = ghb_settings_combo_int(asettings, "AudioEncoder"); taudio = (hb_audio_config_t *) hb_list_audio_config_item( title->list_audio, audio.in.track ); - if ((taudio->in.codec != HB_ACODEC_AC3 && - audio.out.codec == HB_ACODEC_AC3) || - (taudio->in.codec != HB_ACODEC_DCA && - audio.out.codec == HB_ACODEC_DCA)) + if (audio.out.codec & (HB_ACODEC_AC3 | HB_ACODEC_DCA)) { - // Not supported. AC3 is passthrough only, so input must be AC3 - if (job->mux == HB_MUX_AVI) + if (!(taudio->in.codec & (HB_ACODEC_AC3 | HB_ACODEC_DCA))) { - audio.out.codec = HB_ACODEC_LAME; + // Not supported. + // AC3/DTS is passthrough only, so input must be AC3/DTS + if (job->mux == HB_MUX_MKV) + { + audio.out.codec = HB_ACODEC_LAME; + } + else + { + audio.out.codec = HB_ACODEC_FAAC; + } } else { -printf("switching to faac\n"); - audio.out.codec = HB_ACODEC_FAAC; + audio.out.codec &= taudio->in.codec; } } if ((job->mux == HB_MUX_MP4) && - ((audio.out.codec == HB_ACODEC_LAME) || - (audio.out.codec == HB_ACODEC_VORBIS))) + ((audio.out.codec & HB_ACODEC_LAME) || + (audio.out.codec & HB_ACODEC_DCA) || + (audio.out.codec & HB_ACODEC_VORBIS))) { - // mp4/mp3|vorbis combination is not supported. + // mp4/mp3|dts|vorbis combination is not supported. audio.out.codec = HB_ACODEC_FAAC; } - if ((job->mux == HB_MUX_AVI) && - ((audio.out.codec == HB_ACODEC_FAAC) || - (audio.out.codec == HB_ACODEC_VORBIS))) - { - // avi/faac|vorbis combination is not supported. - audio.out.codec = HB_ACODEC_LAME; - } - if ((job->mux == HB_MUX_OGM) && - ((audio.out.codec == HB_ACODEC_FAAC) || - (audio.out.codec == HB_ACODEC_AC3) || - (audio.out.codec == HB_ACODEC_DCA))) - { - // ogm/faac|ac3 combination is not supported. - audio.out.codec = HB_ACODEC_VORBIS; - } audio.out.dynamic_range_compression = ghb_settings_get_double(asettings, "AudioTrackDRCSlider"); + if (audio.out.dynamic_range_compression < 1.0) + audio.out.dynamic_range_compression = 0.0; + // It would be better if this were done in libhb for us, but its not yet. - if (audio.out.codec == HB_ACODEC_AC3 || audio.out.codec == HB_ACODEC_DCA) + if (audio.out.codec & (HB_ACODEC_AC3 | HB_ACODEC_DCA)) { audio.out.mixdown = 0; } else { + int channels; + audio.out.mixdown = ghb_settings_combo_int(asettings, "AudioMixdown"); + if (audio.out.mixdown == HB_AMIXDOWN_MONO) + channels = 1; + else if (audio.out.mixdown == HB_AMIXDOWN_6CH) + channels = 6; + else + channels = 2; + // Make sure the mixdown is valid and pick a new one if not. audio.out.mixdown = ghb_get_best_mix(titleindex, audio.in.track, audio.out.codec, audio.out.mixdown); @@ -3430,6 +4556,9 @@ printf("switching to faac\n"); audio.out.samplerate = taudio->in.samplerate; else audio.out.samplerate = srate; + + audio.out.bitrate = ghb_get_best_audio_bitrate( + audio.out.codec, audio.out.bitrate, channels); } // Add it to the jobs audio list @@ -3450,7 +4579,112 @@ printf("switching to faac\n"); dest_str = ghb_settings_get_string(js, "destination"); job->file = dest_str; - job->crf = ghb_settings_get_boolean(js, "constant_rate_factor"); + + const GValue *subtitle_list; + gint subtitle; + gboolean force, burned, def, one_burned = FALSE; + + ghb_settings_set_boolean(js, "subtitle_scan", FALSE); + subtitle_list = ghb_settings_get_value(js, "subtitle_list"); + count = ghb_array_len(subtitle_list); + for (ii = 0; ii < count; ii++) + { + GValue *ssettings; + gint source; + + ssettings = ghb_array_get_nth(subtitle_list, ii); + + force = ghb_settings_get_boolean(ssettings, "SubtitleForced"); + burned = ghb_settings_get_boolean(ssettings, "SubtitleBurned"); + def = ghb_settings_get_boolean(ssettings, "SubtitleDefaultTrack"); + source = ghb_settings_get_int(ssettings, "SubtitleSource"); + + if (source == SRTSUB) + { + hb_subtitle_config_t sub_config; + gchar *filename, *lang, *code; + + filename = ghb_settings_get_string(ssettings, "SrtFile"); + if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) + { + continue; + } + sub_config.offset = ghb_settings_get_int(ssettings, "SrtOffset"); + lang = ghb_settings_get_string(ssettings, "SrtLanguage"); + code = ghb_settings_get_string(ssettings, "SrtCodeset"); + strncpy(sub_config.src_filename, filename, 128); + strncpy(sub_config.src_codeset, code, 40); + sub_config.force = 0; + sub_config.dest = PASSTHRUSUB; + sub_config.default_track = def; + + hb_srt_add( job, &sub_config, lang); + + g_free(filename); + g_free(lang); + g_free(code); + continue; + } + + subtitle = ghb_settings_get_int(ssettings, "SubtitleTrack"); + if (subtitle == -1) + { + if (!burned && job->mux == HB_MUX_MKV) + { + 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 + if (one_burned) + continue; + job->select_subtitle_config.dest = RENDERSUB; + one_burned = TRUE; + } + job->select_subtitle_config.force = force; + job->select_subtitle_config.default_track = def; + job->indepth_scan = 1; + ghb_settings_set_boolean(js, "subtitle_scan", TRUE); + } + else if (subtitle >= 0) + { + hb_subtitle_t * subt; + 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.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 + if (one_burned) + continue; + one_burned = TRUE; + } + sub_config.force = force; + sub_config.default_track = def; + hb_subtitle_add( job, &sub_config, subtitle ); + } + } + } + // TODO: libhb holds onto a reference to the x264opts and is not // finished with it until encoding the job is done. But I can't // find a way to get at the job before it is removed in order to @@ -3458,47 +4692,15 @@ printf("switching to faac\n"); // The short story is THIS LEAKS. x264opts = ghb_build_x264opts_string(js); - if( x264opts != NULL && *x264opts != '\0' ) - { - job->x264opts = x264opts; - } - else /*avoids a bus error crash when options aren't specified*/ - { - job->x264opts = NULL; - } - gint subtitle; - gchar *slang = ghb_settings_get_string(js, "Subtitles"); - subtitle = -2; // default to none - if (strcmp(slang, "auto") == 0) + if( *x264opts == '\0' ) { - subtitle = -1; + g_free(x264opts); + x264opts = NULL; } - else - { - gint scount; - hb_subtitle_t * subt; - scount = hb_list_count(title->list_subtitle); - for (ii = 0; ii < scount; ii++) - { - subt = (hb_subtitle_t *)hb_list_item(title->list_subtitle, ii); - if (strcmp(slang, subt->iso639_2) == 0) - { - subtitle = ii; - break; - } - } - } - gboolean forced_subtitles = ghb_settings_get_boolean(js, "SubtitlesForced"); - job->subtitle_force = forced_subtitles; - if (subtitle >= 0) - job->subtitle = subtitle; - else - job->subtitle = -1; - if (subtitle == -1) + if (job->indepth_scan == 1) { // Subtitle scan. Look for subtitle matching audio language - char *x264opts_tmp; /* * When subtitle scan is enabled do a fast pre-scan job @@ -3506,27 +4708,15 @@ printf("switching to faac\n"); */ job->pass = -1; job->indepth_scan = 1; - - x264opts_tmp = job->x264opts; job->x264opts = NULL; - job->select_subtitle = malloc(sizeof(hb_subtitle_t*)); - *(job->select_subtitle) = NULL; - /* * Add the pre-scan job */ job->sequence_id = (unique_id & 0xFFFFFF) | (sub_id++ << 24); hb_add( h, job ); - //if (job->x264opts != NULL) - // g_free(job->x264opts); - - job->x264opts = x264opts_tmp; - } - else - { - job->select_subtitle = NULL; } + if( ghb_settings_get_boolean(js, "VideoTwoPass") && !ghb_settings_get_boolean(js, "vquality_type_constant")) { @@ -3535,27 +4725,32 @@ printf("switching to faac\n"); * for the second pass and then off again for the * second. */ - hb_subtitle_t **subtitle_tmp = job->select_subtitle; - job->select_subtitle = NULL; job->pass = 1; job->indepth_scan = 0; - gchar *x264opts2 = NULL; - if (x264opts) - { - x264opts2 = g_strdup(x264opts); - } + /* * If turbo options have been selected then append them * to the x264opts now (size includes one ':' and the '\0') */ if( ghb_settings_get_boolean(js, "VideoTurboTwoPass") ) { - char *tmp_x264opts; + gchar *tmp_x264opts; + gchar *extra_opts; + gint badapt; + badapt = ghb_lookup_badapt(x264opts); + if (badapt == 2) + { + extra_opts = g_strdup_printf("%s", turbo_opts); + } + else + { + extra_opts = g_strdup_printf("%s:weightb=0", turbo_opts); + } + if ( x264opts ) { - tmp_x264opts = g_strdup_printf("%s:%s", x264opts, turbo_opts); - g_free(x264opts); + tmp_x264opts = g_strdup_printf("%s:%s", x264opts, extra_opts); } else { @@ -3563,10 +4758,14 @@ printf("switching to faac\n"); * No x264opts to modify, but apply the turbo options * anyway as they may be modifying defaults */ - tmp_x264opts = g_strdup_printf("%s", turbo_opts); + tmp_x264opts = g_strdup_printf("%s", extra_opts); } - x264opts = tmp_x264opts; + g_free(extra_opts); + job->x264opts = tmp_x264opts; + } + else + { job->x264opts = x264opts; } job->sequence_id = (unique_id & 0xFFFFFF) | (sub_id++ << 24); @@ -3574,7 +4773,6 @@ printf("switching to faac\n"); //if (job->x264opts != NULL) // g_free(job->x264opts); - job->select_subtitle = subtitle_tmp; job->pass = 2; /* * On the second pass we turn off subtitle scan so that we @@ -3583,7 +4781,7 @@ printf("switching to faac\n"); * attribute of the job). */ job->indepth_scan = 0; - job->x264opts = x264opts2; + job->x264opts = x264opts; job->sequence_id = (unique_id & 0xFFFFFF) | (sub_id++ << 24); hb_add( h, job ); //if (job->x264opts != NULL) @@ -3591,6 +4789,7 @@ printf("switching to faac\n"); } else { + job->x264opts = x264opts; job->indepth_scan = 0; job->pass = 0; job->sequence_id = (unique_id & 0xFFFFFF) | (sub_id++ << 24); @@ -3598,6 +4797,25 @@ printf("switching to faac\n"); //if (job->x264opts != NULL) // g_free(job->x264opts); } + + // clean up audio list + gint num_audio_tracks = hb_list_count(job->list_audio); + for(ii = 0; ii < num_audio_tracks; ii++) + { + hb_audio_t *audio = (hb_audio_t*)hb_list_item(job->list_audio, 0); + hb_list_rem(job->list_audio, audio); + free(audio); + } + + // clean up subtitle list + gint num_subtitle_tracks = hb_list_count(job->list_subtitle); + for(ii = 0; ii < num_subtitle_tracks; ii++) + { + hb_subtitle_t *subtitle = hb_list_item(job->list_subtitle, 0); + hb_list_rem(job->list_subtitle, subtitle); + free(subtitle); + } + if (detel_str) g_free(detel_str); if (decomb_str) g_free(decomb_str); if (deint_str) g_free(deint_str); @@ -3672,23 +4890,119 @@ ghb_pause_queue() if( s.state == HB_STATE_PAUSED ) { - hb_resume( h_queue ); + hb_status.queue.state &= ~GHB_STATE_PAUSED; + hb_resume( h_queue ); } else { - hb_pause( h_queue ); + hb_status.queue.state |= GHB_STATE_PAUSED; + hb_pause( h_queue ); } } -#define RED_HEIGHT 720.0 -#define RED_WIDTH 1280.0 +static void +vert_line( + GdkPixbuf * pb, + guint8 r, + guint8 g, + guint8 b, + gint x, + gint y, + gint len, + gint width) +{ + guint8 *pixels = gdk_pixbuf_get_pixels (pb); + guint8 *dst; + gint ii, jj; + gint channels = gdk_pixbuf_get_n_channels (pb); + gint stride = gdk_pixbuf_get_rowstride (pb); + + for (jj = 0; jj < width; jj++) + { + dst = pixels + y * stride + (x+jj) * channels; + for (ii = 0; ii < len; ii++) + { + dst[0] = r; + dst[1] = g; + dst[2] = b; + dst += stride; + } + } +} + +static void +horz_line( + GdkPixbuf * pb, + guint8 r, + guint8 g, + guint8 b, + gint x, + gint y, + gint len, + gint width) +{ + guint8 *pixels = gdk_pixbuf_get_pixels (pb); + guint8 *dst; + gint ii, jj; + gint channels = gdk_pixbuf_get_n_channels (pb); + gint stride = gdk_pixbuf_get_rowstride (pb); + + for (jj = 0; jj < width; jj++) + { + dst = pixels + (y+jj) * stride + x * channels; + for (ii = 0; ii < len; ii++) + { + dst[0] = r; + dst[1] = g; + dst[2] = b; + dst += channels; + } + } +} + +static void +hash_pixbuf( + GdkPixbuf * pb, + gint x, + gint y, + gint w, + gint h, + gint step, + gint orientation) +{ + gint ii, jj; + gint line_width = 8; + struct + { + guint8 r; + guint8 g; + guint8 b; + } c[4] = + {{0x80, 0x80, 0x80},{0xC0, 0x80, 0x70},{0x80, 0xA0, 0x80},{0x70, 0x80, 0xA0}}; + + if (!orientation) + { + // vertical lines + for (ii = x, jj = 0; ii+line_width < x+w; ii += step, jj++) + { + vert_line(pb, c[jj&3].r, c[jj&3].g, c[jj&3].b, ii, y, h, line_width); + } + } + else + { + // horizontal lines + for (ii = y, jj = 0; ii+line_width < y+h; ii += step, jj++) + { + horz_line(pb, c[jj&3].r, c[jj&3].g, c[jj&3].b, x, ii, w, line_width); + } + } +} GdkPixbuf* ghb_get_preview_image( gint titleindex, gint index, signal_user_data_t *ud, - gboolean borders, gint *out_width, gint *out_height) { @@ -3708,70 +5022,25 @@ ghb_get_preview_image( if (title->job == NULL) return NULL; set_preview_job_settings(title->job, settings); - // hb_get_preview can't handle sizes that are larger than the original title - // dimensions - if (title->job->width > title->width) - title->job->width = title->width; - - if (title->job->height > title->height) - title->job->height = title->height; - // And also creates artifacts if the width is not a multiple of 8 - //title->job->width = ((title->job->width + 4) >> 3) << 3; - // And the height must be a multiple of 2 - //title->job->height = ((title->job->height + 1) >> 1) << 1; - - // Make sure we have a big enough buffer to receive the image from libhb. libhb - // creates images with a one-pixel border around the original content. Hence we - // add 2 pixels horizontally and vertically to the buffer size. - gint srcWidth = title->width + 2; - gint srcHeight= title->height + 2; - gint dstWidth = title->width; - gint dstHeight= title->height; - gint borderTop = 1; - gint borderLeft = 1; - if (borders) - { - // |<---------- title->width ----------->| - // | |<---- title->job->width ---->| | - // | | | | - // ....................................... - // ....+-----------------------------+.... - // ....| |....<-- gray border - // ....| |.... - // ....| |.... - // ....| |<------- image - // ....| |.... - // ....| |.... - // ....| |.... - // ....| |.... - // ....| |.... - // ....+-----------------------------+.... - // ....................................... - dstWidth = title->job->width; - dstHeight = title->job->height; - borderTop = (srcHeight - dstHeight) / 2; - borderLeft = (srcWidth - dstWidth) / 2; - g_debug("boarders removed\n"); - } - - g_debug("src %d x %d\n", srcWidth, srcHeight); - g_debug("dst %d x %d\n", dstWidth, dstHeight); - g_debug("job dim %d x %d\n", title->job->width, title->job->height); - g_debug("title crop %d:%d:%d:%d\n", - title->crop[0], - title->crop[1], - title->crop[2], - title->crop[3]); - g_debug("job crop %d:%d:%d:%d\n", - title->job->crop[0], - title->job->crop[1], - title->job->crop[2], - title->job->crop[3]); + // hb_get_preview doesn't compensate for anamorphic, so lets + // calculate scale factors + gint width, height, par_width = 1, par_height = 1; + gint pic_par = ghb_settings_combo_int(settings, "PicturePAR"); + if (pic_par) + { + hb_set_anamorphic_size( title->job, &width, &height, + &par_width, &par_height ); + } + + // Make sure we have a big enough buffer to receive the image from libhb + gint dstWidth = title->job->width; + gint dstHeight= title->job->height; + static guint8 *buffer = NULL; static gint bufferSize = 0; - gint newSize; - newSize = srcWidth * srcHeight * 4; + + newSize = dstWidth * dstHeight * 4; if( bufferSize < newSize ) { bufferSize = newSize; @@ -3780,23 +5049,22 @@ ghb_get_preview_image( hb_get_preview( h_scan, title, index, buffer ); // Create an GdkPixbuf and copy the libhb image into it, converting it from - // libhb's format something suitable. Along the way, we'll strip off the - // border around libhb's image. + // libhb's format something suitable. - // The image data returned by hb_get_preview is 4 bytes per pixel, BGRA format. - // Alpha is ignored. + // The image data returned by hb_get_preview is 4 bytes per pixel, + // BGRA format. Alpha is ignored. GdkPixbuf *preview = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, dstWidth, dstHeight); guint8 *pixels = gdk_pixbuf_get_pixels (preview); guint32 *src = (guint32*)buffer; guint8 *dst = pixels; - src += borderTop * srcWidth; // skip top rows in src to get to first row of dst - src += borderLeft; // skip left pixels in src to get to first pixel of dst + gint ii, jj; gint channels = gdk_pixbuf_get_n_channels (preview); gint stride = gdk_pixbuf_get_rowstride (preview); guint8 *tmp; + for (ii = 0; ii < dstHeight; ii++) { tmp = dst; @@ -3809,49 +5077,72 @@ ghb_get_preview_image( src++; } dst += stride; - src += (srcWidth - dstWidth); // skip to next row in src - } - // Got it, but hb_get_preview doesn't compensate for anamorphic, so lets - // scale - gint width, height, par_width, par_height; - gboolean anamorphic = ghb_settings_get_boolean(settings, "anamorphic"); - if (anamorphic) - { - hb_set_anamorphic_size( title->job, &width, &height, &par_width, &par_height ); - ghb_par_scale(ud, &dstWidth, &dstHeight, par_width, par_height); } - else - { - ghb_par_scale(ud, &dstWidth, &dstHeight, 1, 1); - } - *out_width = dstWidth; - *out_height = dstHeight; + gint w = ghb_settings_get_int(settings, "scale_width"); + gint h = ghb_settings_get_int(settings, "scale_height"); + ghb_par_scale(ud, &w, &h, par_width, par_height); + + gint c0, c1, c2, c3; + c0 = ghb_settings_get_int(settings, "PictureTopCrop"); + c1 = ghb_settings_get_int(settings, "PictureBottomCrop"); + c2 = ghb_settings_get_int(settings, "PictureLeftCrop"); + c3 = ghb_settings_get_int(settings, "PictureRightCrop"); + + gdouble xscale = (gdouble)w / (gdouble)(title->width - c2 - c3); + gdouble yscale = (gdouble)h / (gdouble)(title->height - c0 - c1); + + ghb_par_scale(ud, &dstWidth, &dstHeight, par_width, par_height); + *out_width = w; + *out_height = h; if (ghb_settings_get_boolean(settings, "reduce_hd_preview")) { GdkScreen *ss; gint s_w, s_h; - gint num, den; + gint orig_w, orig_h; + gint factor = 80; + if (ghb_settings_get_boolean(settings, "preview_fullscreen")) + { + factor = 100; + } ss = gdk_screen_get_default(); s_w = gdk_screen_get_width(ss); s_h = gdk_screen_get_height(ss); - num = dstWidth * par_width; - den = dstHeight * par_height; + orig_w = dstWidth; + orig_h = dstHeight; - if (dstWidth > s_w * 80 / 100) + if (dstWidth > s_w * factor / 100) { - dstWidth = s_w * 80 / 100; - dstHeight = dstWidth * den / num; + dstWidth = s_w * factor / 100; + dstHeight = dstHeight * dstWidth / orig_w; } - if (dstHeight > s_h * 80 / 100) + if (dstHeight > s_h * factor / 100) { - dstHeight = s_h * 80 / 100; - dstWidth = dstHeight * num / den; + dstHeight = s_h * factor / 100; + dstWidth = dstWidth * dstHeight / orig_h; } + xscale *= (gdouble)dstWidth / orig_w; + yscale *= (gdouble)dstHeight / orig_h; + w *= (gdouble)dstWidth / orig_w; + h *= (gdouble)dstHeight / orig_h; } - g_debug("scaled %d x %d\n", dstWidth, dstHeight); GdkPixbuf *scaled_preview; scaled_preview = gdk_pixbuf_scale_simple(preview, dstWidth, dstHeight, GDK_INTERP_HYPER); + if (ghb_settings_get_boolean(settings, "show_crop")) + { + c0 *= yscale; + c1 *= yscale; + c2 *= xscale; + c3 *= xscale; + // Top + hash_pixbuf(scaled_preview, c2, 0, w, c0, 32, 0); + // Bottom + hash_pixbuf(scaled_preview, c2, dstHeight-c1, w, c1, 32, 0); + // Left + hash_pixbuf(scaled_preview, 0, c0, c2, h, 32, 1); + // Right + hash_pixbuf(scaled_preview, dstWidth-c3, c0, c3, h, 32, 1); + } g_object_unref (preview); return scaled_preview; } @@ -3886,10 +5177,11 @@ ghb_dvd_volname(const gchar *device) { gchar *name; name = hb_dvd_name((gchar*)device); - if (name != NULL) + if (name != NULL && name[0] != 0) { + name = g_strdup(name); sanitize_volname(name); - return g_strdup(name); + return name; } - return name; + return NULL; }