--- /dev/null
+diff -Naur ffmpeg-v0.7-1696-gcae4f4b.orig/libavcodec/avcodec.h ffmpeg-v0.7-1696-gcae4f4b/libavcodec/avcodec.h
+--- ffmpeg-v0.7-1696-gcae4f4b.orig/libavcodec/avcodec.h 2011-11-03 12:29:48.000000000 +0100
++++ ffmpeg-v0.7-1696-gcae4f4b/libavcodec/avcodec.h 2012-04-22 10:59:41.122351884 +0200
+@@ -3193,6 +3193,7 @@
+ unsigned num_rects;
+ AVSubtitleRect **rects;
+ int64_t pts; ///< Same as packet pts, in AV_TIME_BASE
++ uint8_t forced;
+ } AVSubtitle;
+
+ /* packet functions */
+diff -Naur ffmpeg-v0.7-1696-gcae4f4b.orig/libavcodec/pgssubdec.c ffmpeg-v0.7-1696-gcae4f4b/libavcodec/pgssubdec.c
+--- ffmpeg-v0.7-1696-gcae4f4b.orig/libavcodec/pgssubdec.c 2011-11-03 12:29:48.000000000 +0100
++++ ffmpeg-v0.7-1696-gcae4f4b/libavcodec/pgssubdec.c 2012-04-22 13:09:29.499671541 +0200
+@@ -45,6 +45,8 @@
+ int y;
+ int id_number;
+ int object_number;
++ uint8_t composition_flag;
++ int64_t pts;
+ } PGSSubPresentation;
+
+ typedef struct PGSSubPicture {
+@@ -271,7 +273,8 @@
+ * @todo TODO: Implement forcing of subtitles
+ */
+ static void parse_presentation_segment(AVCodecContext *avctx,
+- const uint8_t *buf, int buf_size)
++ const uint8_t *buf, int buf_size,
++ int64_t pts)
+ {
+ PGSSubContext *ctx = avctx->priv_data;
+
+@@ -280,6 +283,8 @@
+ int w = bytestream_get_be16(&buf);
+ int h = bytestream_get_be16(&buf);
+
++ ctx->presentation.pts = pts;
++
+ av_dlog(avctx, "Video Dimensions %dx%d\n",
+ w, h);
+ if (av_image_check_size(w, h, 0, avctx) >= 0)
+@@ -299,16 +304,17 @@
+ buf += 3;
+
+ ctx->presentation.object_number = bytestream_get_byte(&buf);
++ ctx->presentation.composition_flag = 0;
+ if (!ctx->presentation.object_number)
+ return;
+
+ /*
+- * Skip 4 bytes of unknown:
++ * Skip 3 bytes of unknown:
+ * object_id_ref (2 bytes),
+ * window_id_ref,
+- * composition_flag (0x80 - object cropped, 0x40 - object forced)
+ */
+- buf += 4;
++ buf += 3;
++ ctx->presentation.composition_flag = bytestream_get_byte(&buf);
+
+ x = bytestream_get_be16(&buf);
+ y = bytestream_get_be16(&buf);
+@@ -356,6 +362,9 @@
+ */
+
+ memset(sub, 0, sizeof(*sub));
++ sub->pts = ctx->presentation.pts;
++ sub->forced = (ctx->presentation.composition_flag & 0x40) != 0;
++
+ // Blank if last object_number was 0.
+ // Note that this may be wrong for more complex subtitles.
+ if (!ctx->presentation.object_number)
+@@ -441,7 +450,7 @@
+ parse_picture_segment(avctx, buf, segment_length);
+ break;
+ case PRESENTATION_SEGMENT:
+- parse_presentation_segment(avctx, buf, segment_length);
++ parse_presentation_segment(avctx, buf, segment_length, avpkt->pts);
+ break;
+ case WINDOW_SEGMENT:
+ /*
ghb_clear_presets_selection(ud);
ghb_live_reset(ud);
ghb_subtitle_prune(ud);
+ ghb_subtitle_list_refresh_selected(ud);
ghb_audio_list_refresh_selected(ud);
}
return VOBSUB;
}
-const char*
-ghb_subtitle_source_name(gint source)
-{
- const gchar * name = "Unknown";
- switch (source)
- {
- case VOBSUB:
- name = "VOBSUB";
- break;
- case TX3GSUB:
- name = "TX3G";
- break;
- case UTF8SUB:
- name = "UTF8";
- break;
- case CC708SUB:
- case CC608SUB:
- name = "CC";
- break;
- case SRTSUB:
- name = "SRT";
- break;
- case SSASUB:
- name = "SSA";
- break;
- default:
- break;
- }
- return name;
-}
-
const char*
ghb_subtitle_track_source_name(GValue *settings, gint track)
{
sub = hb_list_item( title->list_subtitle, track);
if (sub != NULL)
{
- name = ghb_subtitle_source_name(sub->source);
+ name = hb_subsource_name(sub->source);
}
done:
subtitle = (hb_subtitle_t *)hb_list_item(title->list_subtitle, ii);
options[ii] = g_strdup_printf("%d - %s (%s)", ii+1,
subtitle->lang,
- ghb_subtitle_source_name(subtitle->source));
+ hb_subsource_name(subtitle->source));
subtitle_opts.map[ii+1].option = options[ii];
subtitle_opts.map[ii+1].shortOpt = index_str[ii];
subtitle_opts.map[ii+1].ivalue = ii;
return -2;
}
-static gboolean
-canForce(int source)
-{
- return (source == VOBSUB);
-}
-
-static gboolean
-canBurn(int source)
-{
- return (source == VOBSUB || source == SSASUB);
-}
-
gint
ghb_find_subtitle_track(
gint titleindex,
continue;
subtitle = (hb_subtitle_t*)hb_list_item( title->list_subtitle, ii );
- if (((!force || (force && canForce(subtitle->source))) &&
- (!burn || (burn && canBurn(subtitle->source)))) &&
+ if (((!force || (force && ghb_canForceSub(subtitle->source))) &&
+ (!burn || (burn && ghb_canBurnSub(subtitle->source)))) &&
((strcmp(lang, subtitle->iso639_2) == 0) ||
(strcmp(lang, "und") == 0)))
{
{
sub_config.dest = PASSTHRUSUB;
}
- else if ( burned && canBurn(subt->source) )
+ else if ( burned && ghb_canBurnSub(subt->source) )
{
// Only allow one subtitle to be burned into the video
if (one_burned)
int ghb_get_title_count();
gint ghb_subtitle_track_source(GValue *settings, gint track);
const char* ghb_subtitle_track_source_name(GValue *settings, gint track);
-const char* ghb_subtitle_source_name(gint source);
gchar* ghb_subtitle_track_lang(GValue *settings, gint track);
gboolean ghb_validate_vquality(GValue *settings);
g_free(data);
}
-static gboolean
-canBurn(int source)
+gboolean
+ghb_canPassSub(int source, int mux)
{
- return (source == VOBSUB || source == SSASUB);
+ return hb_subtitle_can_pass(source, mux);
}
-static gboolean
-canForce(int source)
+gboolean
+ghb_canBurnSub(int source)
{
- return (source == VOBSUB);
+ return hb_subtitle_can_burn(source);
+}
+
+gboolean
+ghb_canForceSub(int source)
+{
+ return hb_subtitle_can_force(source);
}
gboolean
{
if (ii != index)
{
-printf("settings burn %d also %d\n", index, ii);
subsettings = ghb_array_get_nth(subtitle_list, ii);
ghb_settings_set_boolean(subsettings, "SubtitleBurned", FALSE);
}
gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
if (ii != index)
{
-printf("ui burn %d also %d\n", index, ii);
subsettings = ghb_array_get_nth(subtitle_list, ii);
ghb_settings_set_boolean(subsettings, "SubtitleBurned", FALSE);
gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, FALSE, -1);
// Add the current subtitle settings to the list.
GValue *subtitle_list;
gint count;
- gboolean burned;
+ gboolean burned, forced;
+ gint source, mux;
const gchar *track;
const gchar *lang;
lang = ghb_settings_combo_string(subsettings, "SubtitleTrack");
ghb_settings_set_string(subsettings, "SubtitleLanguage", lang);
+ mux = ghb_settings_combo_int(settings, "FileFormat");
+ source = ghb_settings_get_int(subsettings, "SubtitleSource");
+ burned = ghb_settings_get_boolean(subsettings, "SubtitleBurned");
+ if (burned && !ghb_canBurnSub(source))
+ {
+ burned = FALSE;
+ ghb_settings_set_boolean(subsettings, "SubtitleBurned", burned);
+ }
+ if (!burned && !ghb_canPassSub(source, mux))
+ {
+ burned = TRUE;
+ ghb_settings_set_boolean(subsettings, "SubtitleBurned", burned);
+ ghb_settings_set_boolean(subsettings, "SubtitleDefaultTrack", FALSE);
+ }
+ forced = ghb_settings_get_boolean(subsettings, "SubtitleForced");
+ if (forced && !ghb_canForceSub(source))
+ {
+ forced = FALSE;
+ ghb_settings_set_boolean(subsettings, "SubtitleForced", forced);
+ }
+
ghb_array_append(subtitle_list, subsettings);
- burned = ghb_settings_get_boolean(subsettings, "SubtitleBurned");
if (burned)
ghb_subtitle_exclusive_burn_settings(settings, count);
return TRUE;
for (ii = 0; ii < count; ii++)
{
subtitle = ghb_value_dup(ghb_array_get_nth(pref_subtitle, ii));
+ gboolean force = ghb_settings_get_boolean(subtitle, "SubtitleForced");
lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
// If there are multiple subtitles using the same language, then
// select sequential tracks for each. The hash keeps track
GValue *subsettings;
gboolean burn;
- track = ghb_find_subtitle_track(titleindex, pref_lang, FALSE, FALSE, VOBSUB, track_indices);
+ track = ghb_find_subtitle_track(titleindex, pref_lang, FALSE, FALSE, PGSSUB, track_indices);
if (track >= -1)
{
int source;
if (track >= 0)
{
int source;
-
subsettings = ghb_dict_value_new();
ghb_settings_set_int(subsettings, "SubtitleTrack", track);
source = ghb_subtitle_track_source(settings, track);
settings = ghb_array_get_nth(subtitle_list, row);
source = ghb_settings_get_int(settings, "SubtitleSource");
- if (!canForce(source))
+ if (!ghb_canForceSub(source))
+ {
return;
+ }
ghb_settings_set_boolean(settings, "SubtitleForced", active);
gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 1, active, -1);
GValue *subtitle_list;
gint count;
GValue *settings;
- gint source;
+ gint source, mux;
g_debug("burned toggled");
tp = gtk_tree_path_new_from_string (path);
settings = ghb_array_get_nth(subtitle_list, row);
source = ghb_settings_get_int(settings, "SubtitleSource");
- if (!canBurn(source))
+ if (!ghb_canBurnSub(source))
+ return;
+ mux = ghb_settings_combo_int(ud->settings, "FileFormat");
+ if (!active && !hb_subtitle_can_pass(source, mux))
return;
ghb_settings_set_boolean(settings, "SubtitleBurned", active);
settings = ghb_array_get_nth(subtitle_list, row);
+ int source, mux;
+ source = ghb_settings_get_int(settings, "SubtitleSource");
+ mux = ghb_settings_combo_int(ud->settings, "FileFormat");
+ if (active && !hb_subtitle_can_pass(source, mux))
+ return;
+
ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active);
gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1);
ghb_live_reset(ud);
}
-static void
-subtitle_list_refresh_selected(signal_user_data_t *ud)
+void
+ghb_subtitle_list_refresh_selected(signal_user_data_t *ud)
{
GtkTreeView *treeview;
GtkTreePath *treepath;
return;
settings = ghb_array_get_nth(subtitle_list, row);
- def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
+ burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
gint i_source;
i_source = ghb_settings_get_int(settings, "SubtitleSource");
- if (!canBurn(i_source))
+ if (!ghb_canBurnSub(i_source))
{
burned = FALSE;
ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
}
- if (!canForce(i_source))
+
+ gint i_mux;
+ i_mux = ghb_settings_combo_int(ud->settings, "FileFormat");
+ if (!burned && !ghb_canPassSub(i_source, i_mux))
+ {
+ burned = TRUE;
+ ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
+ ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", FALSE);
+ }
+
+ forced = ghb_settings_get_boolean(settings, "SubtitleForced");
+ if (!ghb_canForceSub(i_source))
{
- // Force only apply to VOBSUBS
forced = FALSE;
ghb_settings_set_boolean(settings, "SubtitleForced", forced);
}
+ def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
+
if (i_source == SRTSUB)
{
const gchar *lang;
}
g_free(code);
offset = ghb_settings_get_int(settings, "SrtOffset");
-
- forced = FALSE;
- burned = FALSE;
}
else
{
track = g_strdup(
ghb_settings_combo_option(settings, "SubtitleTrack"));
- source = g_strdup(ghb_subtitle_source_name(i_source));
+ source = g_strdup(hb_subsource_name(i_source));
s_track = ghb_settings_get_string(settings, "SubtitleTrack");
-
- forced = ghb_settings_get_boolean(settings, "SubtitleForced");
- burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
}
- if (canBurn(i_source))
+ if (ghb_canBurnSub(i_source))
allow_burn = TRUE;
- if (canForce(i_source))
+ if (ghb_canForceSub(i_source))
allow_force = TRUE;
gtk_list_store_set(GTK_LIST_STORE(store), &iter,
ghb_settings_set_int(settings, "SubtitleSource", source);
lang = ghb_settings_combo_string(settings, "SubtitleTrack");
ghb_settings_set_string(settings, "SubtitleLanguage", lang);
- subtitle_list_refresh_selected(ud);
+ ghb_subtitle_list_refresh_selected(ud);
ghb_live_reset(ud);
}
ghb_live_reset(ud);
if (settings != NULL)
{
ghb_widget_to_setting(settings, widget);
- subtitle_list_refresh_selected(ud);
+ ghb_subtitle_list_refresh_selected(ud);
ghb_live_reset(ud);
}
gchar *filename, *dirname;
ghb_widget_to_setting(settings, widget);
- subtitle_list_refresh_selected(ud);
+ ghb_subtitle_list_refresh_selected(ud);
ghb_live_reset(ud);
const gchar *lang;
ghb_widget_to_setting(settings, widget);
- subtitle_list_refresh_selected(ud);
+ ghb_subtitle_list_refresh_selected(ud);
ghb_live_reset(ud);
GtkTreeIter iter;
GtkListStore *store;
GtkTreeSelection *selection;
- const gchar *track, *source;
+ const gchar *track;
gboolean forced, burned, def;
gchar *s_track;
gint i_source;
s_track = ghb_settings_get_string(settings, "SubtitleTrack");
i_source = ghb_settings_get_int(settings, "SubtitleSource");
- source = ghb_subtitle_source_name(i_source);
- if (canBurn(i_source))
+ if (ghb_canBurnSub(i_source))
allow_burn = TRUE;
- if (canForce(i_source))
+ if (ghb_canForceSub(i_source))
allow_force = TRUE;
gtk_list_store_append(store, &iter);
// Add the current subtitle settings to the list.
GValue *settings;
gboolean burned = FALSE;
- gint track, source;
+ gint track, source, mux;
g_debug("subtitle_add_clicked_cb ()");
settings = ghb_dict_value_new();
ghb_settings_set_int(settings, "SubtitleTrack", track);
source = ghb_subtitle_track_source(ud->settings, track);
+
+ // Initialize to passthru if possible, else burn
+ mux = ghb_settings_combo_int(ud->settings, "FileFormat");
+ burned = !hb_subtitle_can_pass(source, mux);
+
ghb_settings_set_int(settings, "SubtitleSource", source);
ghb_settings_take_value(settings, "SubtitleForced",
ghb_boolean_value_new(FALSE));
ghb_subtitle_prune(signal_user_data_t *ud)
{
GtkTreeView *tv;
- GtkTreeModel *tm;
GValue *subtitle_list;
gint count, ii;
gint first_track = 0, one_burned = 0;
tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
g_return_if_fail(tv != NULL);
- tm = gtk_tree_view_get_model(tv);
for (ii = count-1; ii >= 0; ii--)
{
gboolean burned;
void ghb_reset_subtitles(signal_user_data_t *ud, GValue *settings);
void ghb_subtitle_prune(signal_user_data_t *ud);
gboolean ghb_soft_in_subtitle_list(GValue *subtitle_list);
+gboolean ghb_canBurnSub(int source);
+gboolean ghb_canForceSub(int source);
+gboolean ghb_canPassSub(int source, int mux);
+void ghb_subtitle_list_refresh_selected(signal_user_data_t *ud);
#endif // _SUBTITLEHANDLER_H_
return d->title_count;
}
+static void add_subtitle(int track, hb_list_t *list_subtitle, BLURAY_STREAM_INFO *bdsub, uint32_t codec)
+{
+ hb_subtitle_t * subtitle;
+ iso639_lang_t * lang;
+
+ subtitle = calloc( sizeof( hb_subtitle_t ), 1 );
+
+ subtitle->track = track;
+ subtitle->id = bdsub->pid;
+ lang = lang_for_code2( (char*)bdsub->lang );
+ snprintf( subtitle->lang, sizeof( subtitle->lang ), "%s",
+ strlen(lang->native_name) ? lang->native_name : lang->eng_name);
+ snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ), "%s",
+ lang->iso639_2);
+
+ switch ( bdsub->coding_type )
+ {
+ case BLURAY_STREAM_TYPE_SUB_PG:
+ subtitle->source = PGSSUB;
+ subtitle->format = PICTURESUB;
+ subtitle->config.dest = RENDERSUB;
+ break;
+ default:
+ // Unrecognized, don't add to list
+ free( subtitle );
+ return;
+ }
+ subtitle->reg_desc = STR4_TO_UINT32("HDMV");
+ subtitle->stream_type = bdsub->coding_type;
+ subtitle->codec = codec;
+
+ hb_log( "bd: subtitle id=0x%x, lang=%s, 3cc=%s", subtitle->id,
+ subtitle->lang, subtitle->iso639_2 );
+
+ hb_list_add( list_subtitle, subtitle );
+ return;
+}
+
static void add_audio(int track, hb_list_t *list_audio, BLURAY_STREAM_INFO *bdaudio, int substream_type, uint32_t codec, uint32_t codec_param)
{
hb_audio_t * audio;
audio = calloc( sizeof( hb_audio_t ), 1 );
audio->id = (substream_type << 16) | bdaudio->pid;
+ audio->config.in.reg_desc = STR4_TO_UINT32("HDMV");
audio->config.in.stream_type = bdaudio->coding_type;
audio->config.in.substream_type = substream_type;
audio->config.in.codec = codec;
}
}
+ // Add all the subtitles found in the above clip.
+ for ( ii = 0; ii < ti->clips[audio_clip_index].pg_stream_count; ii++ )
+ {
+ BLURAY_STREAM_INFO * bdpgs;
+
+ bdpgs = &ti->clips[audio_clip_index].pg_streams[ii];
+
+ switch( bdpgs->coding_type )
+ {
+ case BLURAY_STREAM_TYPE_SUB_PG:
+ add_subtitle(ii, title->list_subtitle, bdpgs, WORK_DECPGSSUB);
+ break;
+ default:
+ hb_log( "scan: unknown subtitle pid 0x%x codec 0x%x",
+ bdpgs->pid, bdpgs->coding_type );
+ break;
+ }
+ }
+
/* Chapters */
for ( ii = 0; ii < ti->chapter_count; ii++ )
{
return 0;
}
subtitle->config = *subtitlecfg;
+ subtitle->out_track = hb_list_count(job->list_subtitle) + 1;
hb_list_add(job->list_subtitle, subtitle);
return 1;
}
subtitle->id = (hb_list_count(job->list_subtitle) << 8) | 0xFF;
subtitle->format = TEXTSUB;
subtitle->source = SRTSUB;
+ subtitle->codec = WORK_DECSRTSUB;
language = lang_for_code2( lang );
return retval;
}
+int hb_subtitle_can_force( int source )
+{
+ return source == VOBSUB || source == PGSSUB;
+}
+
+int hb_subtitle_can_burn( int source )
+{
+ return source == VOBSUB || source == PGSSUB || source == SSASUB;
+}
+
+int hb_subtitle_can_pass( int source, int mux )
+{
+ if ( mux == HB_MUX_MKV )
+ {
+ switch( source )
+ {
+ case PGSSUB:
+ case VOBSUB:
+ case SSASUB:
+ case SRTSUB:
+ case UTF8SUB:
+ case TX3GSUB:
+ case CC608SUB:
+ case CC708SUB:
+ return 1;
+
+ default:
+ return 0;
+ }
+ }
+ else if ( mux == HB_MUX_MP4 )
+ {
+ switch( source )
+ {
+ case VOBSUB:
+ case SSASUB:
+ case SRTSUB:
+ case UTF8SUB:
+ case TX3GSUB:
+ case CC608SUB:
+ case CC708SUB:
+ return 1;
+
+ default:
+ return 0;
+ }
+ }
+ else
+ {
+ // Internal error. Should never get here.
+ hb_error("internel error. Bad mux %d\n", mux);
+ return 0;
+ }
+}
+
char * hb_strdup_printf( const char * fmt, ... )
{
int len;
return "TX3G";
case SSASUB:
return "SSA";
+ case PGSSUB:
+ return "PGS";
default:
return "Unknown";
}
int hb_subtitle_add(const hb_job_t * job, const hb_subtitle_config_t * subtitlecfg, int track);
int hb_srt_add(const hb_job_t * job, const hb_subtitle_config_t * subtitlecfg,
const char *lang);
+int hb_subtitle_can_force( int source );
+int hb_subtitle_can_burn( int source );
+int hb_subtitle_can_pass( int source, int mux );
hb_attachment_t *hb_attachment_copy(const hb_attachment_t *src);
{
int id;
int track;
+ int out_track;
hb_subtitle_config_t config;
enum subtype { PICTURESUB, TEXTSUB } format;
- enum subsource { VOBSUB, SRTSUB, CC608SUB, /*unused*/CC708SUB, UTF8SUB, TX3GSUB, SSASUB } source;
+ enum subsource { VOBSUB, SRTSUB, CC608SUB, /*unused*/CC708SUB, UTF8SUB, TX3GSUB, SSASUB, PGSSUB } source;
char lang[1024];
char iso639_2[4];
uint8_t type; /* Closed Caption, Childrens, Directors etc */
// Color lookup table for VOB subtitle tracks. Each entry is in YCbCr format.
// Must be filled out by the demuxer for VOB subtitle tracks.
uint32_t palette[16];
+ uint8_t palette_set;
int width;
int height;
#ifdef __LIBHB__
/* Internal data */
+ PRIVATE uint32_t codec; /* Input "codec" */
+ PRIVATE uint32_t reg_desc; /* registration descriptor of source */
+ PRIVATE uint32_t stream_type; /* stream type from source stream */
+ PRIVATE uint32_t substream_type;/* substream for multiplexed streams */
+
hb_fifo_t * fifo_in; /* SPU ES */
hb_fifo_t * fifo_raw; /* Decoded SPU */
hb_fifo_t * fifo_sync;/* Synced */
extern hb_work_object_t hb_decutf8sub;
extern hb_work_object_t hb_dectx3gsub;
extern hb_work_object_t hb_decssasub;
+extern hb_work_object_t hb_decpgssub;
extern hb_work_object_t hb_encavcodec;
extern hb_work_object_t hb_encx264;
extern hb_work_object_t hb_enctheora;
{
int id;
int enforce_order;
+ int init_index;
char * name;
char * settings;
{
.id = HB_FILTER_CROP_SCALE,
.enforce_order = 1,
+ .init_index = 0,
.name = "Crop and Scale",
.settings = NULL,
.init = hb_crop_scale_init,
{
.id = HB_FILTER_DEBLOCK,
.enforce_order = 1,
+ .init_index = 0,
.name = "Deblock (pp7)",
.settings = NULL,
.init = hb_deblock_init,
if (debug_608)
{
hb_log ("\n- - - SRT caption - - -\n");
- hb_log (timeline);
+ hb_log ("%s", timeline);
}
//fwrite (enc_buffer,enc_buffer_used,1,wb->fh);
XMLRPC_APPEND(wb->enc_buffer,wb->enc_buffer_used);
hb_buffer_t * buf;
hb_audio_t * audio = w->audio;
int i, j, k;
- int64_t pts, pos;
+ int64_t pts;
uint64_t upts, upos;
int num_blocks;
/* Get the whole frame */
hb_list_getbytes( pv->list, pv->frame, pv->size, &upts, &upos );
pts = (int64_t)upts;
- pos = (int64_t)upos;
if ( pts != pv->last_buf_pts )
{
subtitle->format = TEXTSUB;
subtitle->source = CC608SUB;
subtitle->config.dest = PASSTHRUSUB;
+ subtitle->codec = WORK_DECCC608;
subtitle->type = 5;
snprintf( subtitle->lang, sizeof( subtitle->lang ), "Closed Captions");
/*
if( audio )
{
snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ),
- audio->config.lang.iso639_2);
+ "%s", audio->config.lang.iso639_2);
} else {
snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ), "und");
}
{
.id = HB_FILTER_DECOMB,
.enforce_order = 1,
+ .init_index = 0,
.name = "Decomb",
.settings = NULL,
.init = hb_decomb_init,
--- /dev/null
+#include "hb.h"
+#include "hbffmpeg.h"
+
+struct hb_work_private_s
+{
+ AVCodecContext * context;
+ hb_job_t * job;
+ // For PGS subs, when doing passthru, we don't know if we need a
+ // packet until we have processed several packets. So we cache
+ // all the packets we see until libav returns a subtitle with
+ // the information we need.
+ hb_buffer_t * list_pass_buffer;
+ hb_buffer_t * last_pass_buffer;
+ // It is possible for multiple subtitles to be enncapsulated in
+ // one packet. This won't happen for PGS subs, but may for other
+ // types of subtitles. Since I plan to generalize this code to handle
+ // other than PGS, we will need to keep a list of all subtitles seen
+ // while parsing an input packet.
+ hb_buffer_t * list_buffer;
+ hb_buffer_t * last_buffer;
+};
+
+static int decsubInit( hb_work_object_t * w, hb_job_t * job )
+{
+ AVCodec *codec = avcodec_find_decoder( CODEC_ID_HDMV_PGS_SUBTITLE );
+ AVCodecContext *context = avcodec_alloc_context3( codec );
+ context->codec = codec;
+
+ hb_work_private_t * pv;
+ pv = calloc( 1, sizeof( hb_work_private_t ) );
+ w->private_data = pv;
+
+ pv->context = context;
+ pv->job = job;
+
+ return 0;
+}
+
+static int decsubWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
+ hb_buffer_t ** buf_out )
+{
+ hb_work_private_t * pv = w->private_data;
+ hb_buffer_t * in = *buf_in;
+
+ if ( in->size <= 0 )
+ {
+ /* EOF on input stream - send it downstream & say that we're done */
+ if ( pv->list_buffer == NULL )
+ {
+ pv->list_buffer = pv->last_buffer = in;
+ }
+ else
+ {
+ pv->last_buffer->next = in;
+ }
+ *buf_in = NULL;
+ *buf_out = pv->list_buffer;
+ pv->list_buffer = NULL;
+
+ return HB_WORK_DONE;
+ }
+
+ if ( !pv->job->indepth_scan &&
+ w->subtitle->config.dest == PASSTHRUSUB &&
+ hb_subtitle_can_pass( PGSSUB, pv->job->mux ) )
+ {
+ // Append to buffer list. It will be sent to fifo after we determine
+ // if this is a packet we need.
+ if ( pv->list_pass_buffer == NULL )
+ {
+ pv->list_pass_buffer = pv->last_pass_buffer = in;
+ }
+ else
+ {
+ pv->last_pass_buffer->next = in;
+ pv->last_pass_buffer = in;
+ }
+ // We are keeping the buffer, so prevent the filter loop from
+ // deleting it.
+ *buf_in = NULL;
+ }
+
+ AVSubtitle subtitle;
+ memset( &subtitle, 0, sizeof(subtitle) );
+
+ AVPacket avp;
+ av_init_packet( &avp );
+ avp.data = in->data;
+ avp.size = in->size;
+ // libav wants pkt pts in AV_TIME_BASE units
+ avp.pts = av_rescale(in->s.start, AV_TIME_BASE, 90000);
+
+ int has_subtitle = 0;
+
+ do
+ {
+ int usedBytes = avcodec_decode_subtitle2( pv->context, &subtitle, &has_subtitle, &avp );
+ if (usedBytes < 0)
+ {
+ hb_log("unable to decode subtitle with %d bytes.", avp.size);
+ return HB_WORK_OK;
+ }
+
+ if (usedBytes <= avp.size)
+ {
+ avp.data += usedBytes;
+ avp.size -= usedBytes;
+ }
+ else
+ {
+ avp.size = 0;
+ }
+
+ // The sub is "usable" if:
+ // 1. libav returned a sub AND
+ // 2. we are scanning for foreign audio subs OR
+ // 3. we want all subs (e.g. not forced) OR
+ // 4. the sub is forced and we only want forced OR
+ // 5. subtitle clears the previous sub (these are never forced)
+ // subtitle.num_rects == 0
+ uint8_t useable_sub =
+ pv->job->indepth_scan ||
+ subtitle.num_rects == 0 ||
+ !w->subtitle->config.force ||
+ ( w->subtitle->config.force && subtitle.forced );
+
+ if (has_subtitle && useable_sub)
+ {
+ int64_t pts = av_rescale(subtitle.pts, 90000, AV_TIME_BASE);
+ hb_buffer_t * out = NULL;
+
+ if( pv->job->indepth_scan )
+ {
+ if (subtitle.forced)
+ {
+ w->subtitle->forced_hits++;
+ }
+ }
+ else if ( w->subtitle->config.dest == PASSTHRUSUB &&
+ hb_subtitle_can_pass( PGSSUB, pv->job->mux ) )
+ {
+ out = pv->list_pass_buffer;
+ pv->list_pass_buffer = NULL;
+ }
+ else
+ {
+ if (subtitle.num_rects != 0)
+ {
+ unsigned ii;
+ for (ii = 0; ii < subtitle.num_rects; ii++)
+ {
+ AVSubtitleRect *rect = subtitle.rects[ii];
+
+ out = hb_frame_buffer_init(
+ PIX_FMT_YUVA420P, rect->w, rect->h );
+
+ out->s.id = in->s.id;
+ out->sequence = in->sequence;
+ out->s.start = pts;
+ out->s.stop = 0;
+ out->f.x = rect->x;
+ out->f.y = rect->y;
+
+ uint8_t *lum = out->plane[0].data;
+ uint8_t *chromaU = out->plane[1].data;
+ uint8_t *chromaV = out->plane[2].data;
+ uint8_t *alpha = out->plane[3].data;
+
+ int xx, yy;
+ for (yy = 0; yy < rect->h; yy++)
+ {
+ for (xx = 0; xx < rect->w; xx++)
+ {
+ uint32_t argb, yuv;
+ int pixel;
+ uint8_t color;
+
+ pixel = yy * rect->w + xx;
+ color = rect->pict.data[0][pixel];
+ argb = ((uint32_t*)rect->pict.data[1])[color];
+ yuv = hb_rgb2yuv(argb);
+
+ lum[xx] = (yuv >> 16) & 0xff;
+ alpha[xx] = (argb >> 24) & 0xff;
+ if ((xx & 1) == 0 && (yy & 1) == 0)
+ {
+ chromaV[xx>>1] = (yuv >> 8) & 0xff;
+ chromaU[xx>>1] = yuv & 0xff;
+ }
+ }
+ lum += out->plane[0].stride;
+ if ((yy & 1) == 0)
+ {
+ chromaU += out->plane[1].stride;
+ chromaV += out->plane[2].stride;
+ }
+ alpha += out->plane[3].stride;
+ }
+
+ if ( pv->list_buffer == NULL )
+ {
+ pv->list_buffer = pv->last_buffer = out;
+ }
+ else
+ {
+ pv->last_buffer->next = out;
+ pv->last_buffer = out;
+ }
+ out = NULL;
+ }
+ }
+ else
+ {
+ out = hb_buffer_init( 1 );
+
+ out->s.id = in->s.id;
+ out->s.start = pts;
+ out->s.stop = 0;
+ out->f.x = 0;
+ out->f.y = 0;
+ out->f.width = 0;
+ out->f.height = 0;
+ }
+ }
+ if ( pv->list_buffer == NULL )
+ {
+ pv->list_buffer = pv->last_buffer = out;
+ }
+ else
+ {
+ pv->last_buffer->next = out;
+ }
+ while (pv->last_buffer && pv->last_buffer->next)
+ {
+ pv->last_buffer = pv->last_buffer->next;
+ }
+ }
+ else if ( has_subtitle )
+ {
+ hb_buffer_close( &pv->list_pass_buffer );
+ pv->list_pass_buffer = NULL;
+ }
+ if ( has_subtitle )
+ {
+ avsubtitle_free(&subtitle);
+ }
+ } while (avp.size > 0);
+
+ *buf_out = pv->list_buffer;
+ pv->list_buffer = NULL;
+ return HB_WORK_OK;
+}
+
+static void decsubClose( hb_work_object_t * w )
+{
+ hb_work_private_t * pv = w->private_data;
+ avcodec_flush_buffers( pv->context );
+ avcodec_close( pv->context );
+}
+
+hb_work_object_t hb_decpgssub =
+{
+ WORK_DECPGSSUB,
+ "PGS decoder",
+ decsubInit,
+ decsubWork,
+ decsubClose
+};
uint8_t chromaU[4];
uint8_t chromaV[4];
uint8_t alpha[4];
+ uint8_t palette_set;
};
static hb_buffer_t * Decode( hb_work_object_t * );
pv->pts = 0;
// Warn if the input color palette is empty
- int paletteEmpty = 1;
- int i;
- for (i=0; i<16; i++)
+ pv->palette_set = w->subtitle->palette_set;
+ if ( pv->palette_set )
{
- if (w->subtitle->palette[i])
+ // Make sure the entries in the palette are not all 0
+ pv->palette_set = 0;
+ int i;
+ for (i=0; i<16; i++)
{
- paletteEmpty = 0;
- break;
+ if (w->subtitle->palette[i])
+ {
+ pv->palette_set = 1;
+ break;
+ }
}
}
- if (paletteEmpty) {
- hb_log( "decvobsub: input color palette is empty; not demuxed properly?" );
+ if (!pv->palette_set) {
+ hb_log( "decvobsub: input color palette is empty!" );
}
return 0;
{
.id = HB_FILTER_DEINTERLACE,
.enforce_order = 1,
+ .init_index = 0,
.name = "Deinterlace (ffmpeg or yadif/mcdeint)",
.settings = NULL,
.init = hb_deinterlace_init,
{
.id = HB_FILTER_DENOISE,
.enforce_order = 1,
+ .init_index = 0,
.name = "Denoise (hqdn3d)",
.settings = NULL,
.init = hb_denoise_init,
{
.id = HB_FILTER_DETELECINE,
.enforce_order = 1,
+ .init_index = 0,
.name = "Detelecine (pullup)",
.settings = NULL,
.init = hb_detelecine_init,
subtitle->format = PICTURESUB;
subtitle->source = VOBSUB;
subtitle->config.dest = RENDERSUB; // By default render (burn-in) the VOBSUB.
+ subtitle->stream_type = 0xbd;
+ subtitle->substream_type = 0x20 + position;
+ subtitle->codec = WORK_DECVOBSUB;
subtitle->type = lang_extension;
memcpy( subtitle->palette,
vts->vts_pgcit->pgci_srp[pgc_id-1].pgc->palette,
16 * sizeof( uint32_t ) );
+ subtitle->palette_set = 1;
switch( lang_extension )
{
subtitle->format = PICTURESUB;
subtitle->source = VOBSUB;
subtitle->config.dest = RENDERSUB; // By default render (burn-in) the VOBSUB.
+ subtitle->stream_type = 0xbd;
+ subtitle->substream_type = 0x20 + position;
+ subtitle->codec = WORK_DECVOBSUB;
subtitle->type = lang_extension;
memcpy( subtitle->palette,
ifo->vts_pgcit->pgci_srp[title_pgcn-1].pgc->palette,
16 * sizeof( uint32_t ) );
+ subtitle->palette_set = 1;
switch( lang_extension )
{
lavc_opts = hb_encopts_to_dict( job->advanced_opts, job->vcodec );
}
/* iterate through lavc_opts and have avutil parse the options for us */
- int ret;
AVDictionary * av_opts = NULL;
hb_dict_entry_t * entry = NULL;
while( ( entry = hb_dict_next( lavc_opts, entry ) ) )
hb_register( &hb_decutf8sub );
hb_register( &hb_dectx3gsub );
hb_register( &hb_decssasub );
+ hb_register( &hb_decpgssub );
hb_register( &hb_encavcodec );
hb_register( &hb_encx264 );
hb_register( &hb_enctheora );
else if( f->id == filter->id )
{
// Don't allow the same filter to be added twice
+ hb_filter_close( &filter );
return;
}
}
{
subtitle = hb_list_item( title->list_subtitle, i );
if( strcmp( subtitle->iso639_2, audio_lang ) == 0 &&
- subtitle->source == VOBSUB )
+ hb_subtitle_can_force( subtitle->source ) )
{
/*
* Matched subtitle language with audio language, so
hb_dict_t * dict = NULL;
if( encopts && *encopts )
{
- char *cur_opt, *opts_start, *name, *value;
+ char *cur_opt, *opts_start, *value;
+ const char *name;
dict = hb_dict_init( 10 );
if( !dict )
return NULL;
WORK_ENC_CA_HAAC,
WORK_ENCAVCODEC_AUDIO,
WORK_MUX,
- WORK_READER
+ WORK_READER,
+ WORK_DECPGSSUB
};
extern hb_filter_object_t hb_filter_detelecine;
continue;
memset(track, 0, sizeof(mk_TrackConfig));
- switch (subtitle->format)
+ switch (subtitle->source)
{
- case PICTURESUB:
+ case VOBSUB:
track->codecID = MK_SUBTITLE_VOBSUB;
for (j = 0; j < 16; j++)
rgb[j] = hb_yuv2rgb(subtitle->palette[j]);
track->codecPrivate = subidx;
track->codecPrivateSize = len + 1;
break;
- case TEXTSUB:
- if (subtitle->source == SSASUB)
- {
- track->codecID = MK_SUBTITLE_SSA;
- need_fonts = 1;
- track->codecPrivate = subtitle->extradata;
- track->codecPrivateSize = subtitle->extradata_size;
- }
- else
- track->codecID = MK_SUBTITLE_UTF8;
+ case PGSSUB:
+ track->codecID = "S_HDMV/PGS";
+ break;
+ case SSASUB:
+ track->codecID = MK_SUBTITLE_SSA;
+ need_fonts = 1;
+ track->codecPrivate = subtitle->extradata;
+ track->codecPrivateSize = subtitle->extradata_size;
+ break;
+ case CC608SUB:
+ case CC708SUB:
+ case UTF8SUB:
+ case TX3GSUB:
+ track->codecID = MK_SUBTITLE_UTF8;
break;
default:
continue;
void hb_clock_gettime( struct timespec *tp )
{
struct timeval tv;
- time_t sec;
- sec = time( NULL );
gettimeofday( &tv, NULL );
tp->tv_sec = tv.tv_sec;
tp->tv_nsec = tv.tv_usec * 1000;
static void ssa_close( hb_filter_object_t * filter );
+// PGS
+static int pgssub_init ( hb_filter_object_t * filter, hb_filter_init_t * init );
+
+static int pgssub_work ( hb_filter_object_t * filter,
+ hb_buffer_t ** buf_in,
+ hb_buffer_t ** buf_out );
+
+static void pgssub_close( hb_filter_object_t * filter );
+
+
// Entry points
static int hb_rendersub_init( hb_filter_object_t * filter,
hb_filter_init_t * init );
{
.id = HB_FILTER_RENDER_SUB,
.enforce_order = 1,
+ .init_index = 1,
.name = "Subtitle renderer",
.settings = NULL,
.init = hb_rendersub_init,
}
ww = src->f.width;
- if( left + src->f.width > dst->f.width )
+ if( src->f.width - x0 > dst->f.width - left )
{
- ww = dst->f.width - ( left + src->f.width );
+ ww = dst->f.width - left + x0;
}
hh = src->f.height;
- if( top + src->f.height > dst->f.height )
+ if( src->f.height - y0 > dst->f.height - top )
{
- hh = dst->f.height - ( top + src->f.height );
+ hh = dst->f.height - top + y0;
}
-
// Blend luma
for( yy = y0; yy < hh; yy++ )
{
hshift = 1;
if( dst->plane[1].width < dst->plane[0].width )
wshift = 1;
+
for( yy = y0 >> hshift; yy < hh >> hshift; yy++ )
{
u_in = src->plane[1].data + yy * src->plane[1].stride;
int ii;
hb_buffer_t * sub;
- for( ii = 0; ii < hb_list_count( pv->sub_list ); ii++ )
+ for( ii = 0; ii < hb_list_count( pv->sub_list ); )
{
sub = hb_list_item( pv->sub_list, ii );
if( sub->s.stop <= buf->s.start )
{
// Subtitle stop is in the past, delete it
hb_list_rem( pv->sub_list, sub );
+ hb_buffer_close( &sub );
}
else if( sub->s.start <= buf->s.start )
{
ApplySub( pv, buf, sub );
sub = sub->next;
}
+ ii++;
}
else
{
return HB_FILTER_OK;
}
+static void ApplyPGSSubs( hb_filter_private_t * pv, hb_buffer_t * buf )
+{
+ int index;
+ hb_buffer_t * old_sub;
+ hb_buffer_t * sub;
+
+ // Each PGS subtitle supersedes anything that preceded it.
+ // Find the active subtitle (if there is one), and delete
+ // everything before it.
+ for( index = hb_list_count( pv->sub_list ) - 1; index > 0; index-- )
+ {
+ sub = hb_list_item( pv->sub_list, index);
+ if ( sub->s.start <= buf->s.start )
+ {
+ while ( index > 0 )
+ {
+ old_sub = hb_list_item( pv->sub_list, index - 1);
+ hb_list_rem( pv->sub_list, old_sub );
+ hb_buffer_close( &old_sub );
+ index--;
+ }
+ }
+ }
+
+ // Some PGS subtitles have no content and only serve to clear
+ // the screen. If any of these are at the front of our list,
+ // we can now get rid of them.
+ while ( hb_list_count( pv->sub_list ) > 0 )
+ {
+ sub = hb_list_item( pv->sub_list, 0 );
+ if (sub->f.width != 0 && sub->f.height != 0)
+ break;
+
+ hb_list_rem( pv->sub_list, sub );
+ hb_buffer_close( &sub );
+ }
+
+ // Check to see if there's an active subtitle, and apply it.
+ if ( hb_list_count( pv->sub_list ) > 0)
+ {
+ sub = hb_list_item( pv->sub_list, 0 );
+ if ( sub->s.start <= buf->s.start )
+ {
+ while ( sub )
+ {
+ ApplySub( pv, buf, sub );
+ sub = sub->sub;
+ }
+ }
+ }
+}
+
+static int pgssub_init( hb_filter_object_t * filter,
+ hb_filter_init_t * init )
+{
+ hb_filter_private_t * pv = filter->private_data;
+
+ // PGS render filter has no settings
+ memcpy( pv->crop, init->crop, sizeof( int[4] ) );
+
+ pv->sub_list = hb_list_init();
+
+ return 0;
+}
+
+static void pgssub_close( hb_filter_object_t * filter )
+{
+ hb_filter_private_t * pv = filter->private_data;
+
+ if ( !pv )
+ {
+ return;
+ }
+
+ if ( pv->sub_list )
+ hb_list_empty( &pv->sub_list );
+
+ free( pv );
+ filter->private_data = NULL;
+}
+
+static int pgssub_work( hb_filter_object_t * filter,
+ hb_buffer_t ** buf_in,
+ hb_buffer_t ** buf_out)
+{
+ hb_filter_private_t * pv = filter->private_data;
+ hb_buffer_t * in = *buf_in;
+ hb_buffer_t * sub;
+
+ if ( in->size <= 0 )
+ {
+ *buf_in = NULL;
+ *buf_out = in;
+ return HB_FILTER_DONE;
+ }
+
+ // Get any pending subtitles and add them to the active
+ // subtitle list
+ while ( ( sub = hb_fifo_get( filter->subtitle->fifo_out ) ) )
+ {
+ hb_list_add( pv->sub_list, sub );
+ }
+
+ ApplyPGSSubs( pv, in );
+ *buf_in = NULL;
+ *buf_out = in;
+
+ return HB_FILTER_OK;
+}
+
static int hb_rendersub_init( hb_filter_object_t * filter,
hb_filter_init_t * init )
{
return ssa_init( filter, init );
} break;
+ case PGSSUB:
+ {
+ return pgssub_init( filter, init );
+ } break;
+
default:
{
hb_log("rendersub: unsupported subtitle format %d", pv->type );
return ssa_work( filter, buf_in, buf_out );
} break;
+ case PGSSUB:
+ {
+ return pgssub_work( filter, buf_in, buf_out );
+ } break;
+
default:
{
hb_error("rendersub: unsupported subtitle format %d", pv->type );
ssa_close( filter );
} break;
+ case PGSSUB:
+ {
+ pgssub_close( filter );
+ } break;
+
default:
{
hb_error("rendersub: unsupported subtitle format %d", pv->type );
{
.id = HB_FILTER_ROTATE,
.enforce_order = 0,
+ .init_index = 2,
.name = "Rotate (rotate & flip image axes)",
.settings = NULL,
.init = hb_rotate_init,
for( j = 0; j < hb_list_count( title->list_subtitle ); j++ )
{
hb_subtitle_t *subtitle = hb_list_item( title->list_subtitle, j );
- if ( subtitle->source == VOBSUB )
+ if ( subtitle->source == VOBSUB || subtitle->source == PGSSUB )
{
subtitle->width = title->width;
subtitle->height = title->height;
* U - Unknown (to be determined by further processing)
* A - Audio
* V - Video
+ * S - Subtitle
* P - PCR
*/
-typedef enum { N, U, A, V, P } kind_t;
+typedef enum { N, U, A, V, P, S } kind_t;
typedef struct {
kind_t kind; /* not handled / unknown / audio / video */
int codec; /* HB worker object id of codec */
st(0x8a, A, HB_ACODEC_DCA, 0, "DTS"),
- st(0x90, N, 0, 0, "PGS Subtitle"),
+ st(0x90, S, WORK_DECPGSSUB, 0, "PGS Subtitle"),
// 0x91 can be AC3 or BD Interactive Graphics Stream.
st(0x91, U, 0, 0, "AC3/IGS"),
st(0x92, N, 0, 0, "Subtitle"),
static int hb_ts_stream_init(hb_stream_t *stream);
static hb_buffer_t * hb_ts_stream_decode(hb_stream_t *stream);
static void hb_init_audio_list(hb_stream_t *stream, hb_title_t *title);
+static void hb_init_subtitle_list(hb_stream_t *stream, hb_title_t *title);
static int hb_ts_stream_find_pids(hb_stream_t *stream);
static void hb_ps_stream_init(hb_stream_t *stream);
update_ts_streams( d, pid, stream_id_ext, stream_type, A, NULL );
}
+ hb_subtitle_t * subtitle;
+ for ( ii = 0; ( subtitle = hb_list_item( title->list_subtitle, ii ) ); ++ii )
+ {
+ pid = subtitle->id & 0xFFFF;
+ stream_type = subtitle->stream_type;
+
+ update_ts_streams( d, pid, 0, stream_type, S, NULL );
+ }
+
// When scanning, title->job == NULL. We don't need to wait for
// a PCR when scanning. In fact, it trips us up on the first
// preview of every title since we would have to read quite a
// - For program streams read the first 4MB and take every unique
// audio stream we find.
hb_init_audio_list(stream, title);
+ hb_init_subtitle_list(stream, title);
// set the video id, codec & muxer
int idx = pes_index_of_video( stream );
"%s", lang->iso639_2);
}
+// Sort specifies the index in the audio list where you would
+// like sorted items to begin.
+static void pes_add_subtitle_to_title(
+ hb_stream_t *stream,
+ int idx,
+ hb_title_t *title,
+ int sort)
+{
+ hb_pes_stream_t *pes = &stream->pes.list[idx];
+
+ // Sort by id when adding to the list
+ // This assures that they are always displayed in the same order
+ int id = get_id( pes );
+ int i;
+ hb_subtitle_t *tmp = NULL;
+
+ int count = hb_list_count( title->list_subtitle );
+
+ // Don't add the same audio twice. Search for audio.
+ for ( i = 0; i < count; i++ )
+ {
+ tmp = hb_list_item( title->list_subtitle, i );
+ if ( id == tmp->id )
+ return;
+ }
+
+ hb_subtitle_t *subtitle = calloc( sizeof( hb_subtitle_t ), 1 );
+ iso639_lang_t * lang;
+
+ subtitle->track = idx;
+ subtitle->id = id;
+ lang = lang_for_code( pes->lang_code );
+ snprintf( subtitle->lang, sizeof( subtitle->lang ), "%s",
+ strlen(lang->native_name) ? lang->native_name : lang->eng_name);
+ snprintf( subtitle->iso639_2, sizeof( subtitle->iso639_2 ), "%s",
+ lang->iso639_2);
+
+ switch ( pes->codec )
+ {
+ case WORK_DECPGSSUB:
+ subtitle->source = PGSSUB;
+ subtitle->format = PICTURESUB;
+ subtitle->config.dest = RENDERSUB;
+ break;
+ case WORK_DECVOBSUB:
+ subtitle->source = VOBSUB;
+ subtitle->format = PICTURESUB;
+ subtitle->config.dest = RENDERSUB;
+ break;
+ default:
+ // Unrecognized, don't add to list
+ hb_log("unregonized subtitle!");
+ free( subtitle );
+ return;
+ }
+ subtitle->reg_desc = stream->reg_desc;
+ subtitle->stream_type = pes->stream_type;
+ subtitle->substream_type = pes->stream_id_ext;
+ subtitle->codec = pes->codec;
+
+ // Create a default palette since vob files do not include the
+ // vobsub palette.
+ if ( subtitle->source == VOBSUB )
+ {
+ subtitle->palette[0] = 0x108080;
+ subtitle->palette[1] = 0x108080;
+ subtitle->palette[2] = 0x108080;
+ subtitle->palette[3] = 0xbff000;
+
+ subtitle->palette[4] = 0xbff000;
+ subtitle->palette[5] = 0x108080;
+ subtitle->palette[6] = 0x108080;
+ subtitle->palette[7] = 0x108080;
+
+ subtitle->palette[8] = 0xbff000;
+ subtitle->palette[9] = 0x108080;
+ subtitle->palette[10] = 0x108080;
+ subtitle->palette[11] = 0x108080;
+
+ subtitle->palette[12] = 0x108080;
+ subtitle->palette[13] = 0xbff000;
+ subtitle->palette[14] = 0x108080;
+ subtitle->palette[15] = 0x108080;
+ }
+
+ hb_log("stream id 0x%x (type 0x%x substream 0x%x) subtitle 0x%x",
+ pes->stream_id, pes->stream_type, pes->stream_id_ext, subtitle->id);
+
+ // Search for the sort position
+ if ( sort >= 0 )
+ {
+ sort = sort < count ? sort : count;
+ for ( i = sort; i < count; i++ )
+ {
+ tmp = hb_list_item( title->list_subtitle, i );
+ int sid = tmp->id & 0xffff;
+ int ssid = tmp->id >> 16;
+ if ( pes->stream_id < sid )
+ break;
+ else if ( pes->stream_id <= sid &&
+ pes->stream_id_ext <= ssid )
+ {
+ break;
+ }
+ }
+ hb_list_insert( title->list_subtitle, i, subtitle );
+ }
+ else
+ {
+ hb_list_add( title->list_subtitle, subtitle );
+ }
+}
+
// Sort specifies the index in the audio list where you would
// like sorted items to begin.
static void pes_add_audio_to_title(
}
}
+static void hb_init_subtitle_list(hb_stream_t *stream, hb_title_t *title)
+{
+ int ii;
+ int map_idx;
+ int largest = -1;
+
+ // First add all that were found in a map.
+ for ( map_idx = 0; 1; map_idx++ )
+ {
+ for ( ii = 0; ii < stream->pes.count; ii++ )
+ {
+ if ( stream->pes.list[ii].stream_kind == S )
+ {
+ if ( stream->pes.list[ii].map_idx == map_idx )
+ {
+ pes_add_subtitle_to_title( stream, ii, title, -1 );
+ }
+ if ( stream->pes.list[ii].map_idx > largest )
+ largest = stream->pes.list[ii].map_idx;
+ }
+ }
+ if ( map_idx > largest )
+ break;
+ }
+
+ int count = hb_list_count( title->list_audio );
+ // Now add the reset. Sort them by stream id.
+ for ( ii = 0; ii < stream->pes.count; ii++ )
+ {
+ if ( stream->pes.list[ii].stream_kind == S )
+ {
+ pes_add_subtitle_to_title( stream, ii, title, count );
+ }
+ }
+}
+
static void hb_init_audio_list(hb_stream_t *stream, hb_title_t *title)
{
int ii;
stream->ts.list[i].is_pcr ? " (PCR)" : "");
}
}
+ hb_log(" Subtitle PIDS : ");
+ for (i = 0; i < stream->ts.count; i++)
+ {
+ if ( ts_stream_kind( stream, i ) == S )
+ {
+ hb_log( " 0x%x type %s (0x%x)%s",
+ stream->ts.list[i].pid,
+ stream_type_name2(stream,
+ &stream->pes.list[stream->ts.list[i].pes_list]),
+ ts_stream_type( stream, i ),
+ stream->ts.list[i].is_pcr ? " (PCR)" : "");
+ }
+ }
hb_log(" Other PIDS : ");
for (i = 0; i < stream->ts.count; i++)
{
stream->pes.list[i].stream_type );
}
}
+ hb_log(" Subtitle Streams : ");
+ for (i = 0; i < stream->pes.count; i++)
+ {
+ if ( stream->pes.list[i].stream_kind == S )
+ {
+ hb_log( " 0x%x-0x%x type %s (0x%x)",
+ stream->pes.list[i].stream_id,
+ stream->pes.list[i].stream_id_ext,
+ stream_type_name2(stream,
+ &stream->pes.list[i]),
+ stream->pes.list[i].stream_type );
+ }
+ }
hb_log(" Other Streams : ");
for (i = 0; i < stream->pes.count; i++)
{
// Check dvd substream id
if ( ssid >= 0x20 && ssid <= 0x37 )
{
- // Skip dvd subtitles
int idx = update_ps_streams( stream, pes_info.stream_id,
pes_info.bd_substream_id, 0, -1 );
- stream->pes.list[idx].stream_kind = N;
+ stream->pes.list[idx].stream_kind = S;
+ stream->pes.list[idx].codec = WORK_DECVOBSUB;
strncpy(stream->pes.list[idx].codec_name,
"DVD Subtitle", 80);
continue;
// stype == 0 indicates a type not in st2codec table
if ( stype != 0 &&
( ts_stream_kind( stream, ii ) == A ||
+ ts_stream_kind( stream, ii ) == S ||
ts_stream_kind( stream, ii ) == V ) )
{
// Assuming there are no substreams.
// stype == 0 indicates a type not in st2codec table
if ( stype != 0 &&
( stream->pes.list[ii].stream_kind == A ||
+ stream->pes.list[ii].stream_kind == S ||
stream->pes.list[ii].stream_kind == V ) )
{
stream->pes.list[ii].codec = st2codec[stype].codec;
int i;
for (i=0; i<16; i++)
subtitle->palette[i] = hb_rgb2yuv(rgb[i]);
+ subtitle->palette_set = 1;
return 0;
}
else
codec->extradata[j+1] << 16 | // Y
codec->extradata[j+2] << 8 | // Cb
codec->extradata[j+3] << 0; // Cr
+ subtitle->palette_set = 1;
}
if (codec->width <= 0 || codec->height <= 0)
{
subtitle->format = PICTURESUB;
subtitle->source = VOBSUB;
subtitle->config.dest = RENDERSUB; // By default render (burn-in) the VOBSUB.
+ subtitle->codec = WORK_DECVOBSUB;
if ( ffmpeg_parse_vobsub_extradata( codec, subtitle ) )
hb_log( "add_ffmpeg_subtitle: malformed extradata for VOB subtitle track; "
"subtitle colors likely to be wrong" );
subtitle->format = TEXTSUB;
subtitle->source = UTF8SUB;
subtitle->config.dest = PASSTHRUSUB;
+ subtitle->codec = WORK_DECUTF8SUB;
break;
case CODEC_ID_MOV_TEXT: // TX3G
subtitle->format = TEXTSUB;
subtitle->source = TX3GSUB;
subtitle->config.dest = PASSTHRUSUB;
+ subtitle->codec = WORK_DECTX3GSUB;
break;
case CODEC_ID_SSA:
subtitle->format = TEXTSUB;
subtitle->source = SSASUB;
subtitle->config.dest = PASSTHRUSUB;
+ subtitle->codec = WORK_DECSSASUB;
+ break;
+ case CODEC_ID_HDMV_PGS_SUBTITLE:
+ subtitle->format = PICTURESUB;
+ subtitle->source = PGSSUB;
+ subtitle->config.dest = RENDERSUB;
+ subtitle->codec = WORK_DECPGSSUB;
break;
default:
hb_log( "add_ffmpeg_subtitle: unknown subtitle stream type: 0x%x", (int) codec->codec_id );
uint64_t st_counts[4];
uint64_t st_dates[4];
uint64_t st_first;
-
- /* Subtitles */
- hb_buffer_t * sub_list; /* list of subtitles to be passed thru or rendered */
- hb_buffer_t * sub_tail; /* list of subtitles to be passed thru or rendered */
} hb_sync_video_t;
struct hb_work_private_s
{
.id = HB_FILTER_VFR,
.enforce_order = 1,
+ .init_index = 0,
.name = "Framerate Shaper",
.settings = NULL,
.init = hb_vfr_init,
{
/* For SRT, print offset and charset too */
hb_log( " * subtitle track %i, %s (id 0x%x) %s [%s] -> %s%s, offset: %"PRId64", charset: %s",
- subtitle->track, subtitle->lang, subtitle->id, "Text", "SRT", "Pass-Through",
+ subtitle->out_track, subtitle->lang, subtitle->id,
+ "Text", "SRT", "Pass-Through",
subtitle->config.default_track ? ", Default" : "",
subtitle->config.offset, subtitle->config.src_codeset );
}
else
{
- hb_log( " * subtitle track %i, %s (id 0x%x) %s [%s] -> %s%s%s", subtitle->track, subtitle->lang, subtitle->id,
+ hb_log( " * subtitle track %i, %s (id 0x%x) %s [%s] -> %s%s%s",
+ subtitle->out_track, subtitle->lang, subtitle->id,
subtitle->format == PICTURESUB ? "Picture" : "Text",
hb_subsource_name( subtitle->source ),
job->indepth_scan ? "Foreign Audio Search" :
- subtitle->config.dest == RENDERSUB ? "Render/Burn in" : "Pass-Through",
+ subtitle->config.dest == RENDERSUB ?
+ "Render/Burn in" : "Pass-Through",
subtitle->config.force ? ", Forced Only" : "",
subtitle->config.default_track ? ", Default" : "" );
}
interjob->vrate_base = job->vrate_base;
}
+void hb_filter_init_next( hb_list_t * list, int *score, int *ret_pos )
+{
+ int count = hb_list_count( list );
+ int pos = *ret_pos + 1;
+ int ii = 0;
+ if ( pos == 0 )
+ {
+ hb_filter_object_t * filter = hb_list_item( list, pos );
+ if ( filter->init_index == *score )
+ {
+ *ret_pos = pos;
+ return;
+ }
+ pos++;
+ }
+ while (1)
+ {
+ if ( pos == count )
+ {
+ pos = 0;
+ (*score)++;
+ }
+ hb_filter_object_t * filter = hb_list_item( list, pos );
+ if ( filter->init_index == *score )
+ {
+ *ret_pos = pos;
+ return;
+ }
+ pos++;
+ ii++;
+ if (ii > count)
+ {
+ // This is an error that should never happen
+ hb_error("internal error during filter initialization");
+ *ret_pos = -1;
+ return;
+ }
+ }
+}
+
/**
* Job initialization rountine.
* Initializes fifos.
hb_log( "starting job" );
+ /*
+ * Look for the scanned subtitle in the existing subtitle list
+ * select_subtitle implies that we did a scan.
+ */
+ if ( !job->indepth_scan && interjob->select_subtitle &&
+ ( job->pass == 0 || job->pass == 2 ) )
+ {
+ /*
+ * Disable forced subtitles if we didn't find any in the scan
+ * so that we display normal subtitles instead.
+ */
+ if( interjob->select_subtitle->config.force &&
+ interjob->select_subtitle->forced_hits == 0 )
+ {
+ interjob->select_subtitle->config.force = 0;
+ }
+ for( i=0; i < hb_list_count(title->list_subtitle); i++ )
+ {
+ subtitle = hb_list_item( title->list_subtitle, i );
+
+ if( subtitle )
+ {
+ /*
+ * Remove the scanned subtitle from the subtitle list if
+ * it would result in an identical duplicate subtitle track
+ * or an emty track (forced and no forced hits).
+ */
+ if( ( interjob->select_subtitle->id == subtitle->id ) &&
+ ( ( interjob->select_subtitle->forced_hits == 0 &&
+ subtitle->config.force ) ||
+ ( subtitle->config.force == interjob->select_subtitle->config.force ) ) )
+ {
+ *subtitle = *(interjob->select_subtitle);
+ free( interjob->select_subtitle );
+ interjob->select_subtitle = NULL;
+ break;
+ }
+ }
+ }
+
+ if( interjob->select_subtitle )
+ {
+ /*
+ * Its not in the existing list
+ *
+ * Must be second pass of a two pass with subtitle scan enabled, so
+ * add the subtitle that we found on the first pass for use in this
+ * pass.
+ */
+ hb_list_add( title->list_subtitle, interjob->select_subtitle );
+ interjob->select_subtitle = NULL;
+ }
+ }
+
+ if ( !job->indepth_scan )
+ {
+ // Sanitize subtitles
+ uint8_t one_burned = 0;
+ for( i=0; i < hb_list_count(title->list_subtitle); )
+ {
+ subtitle = hb_list_item( title->list_subtitle, i );
+
+ if ( subtitle->config.dest == RENDERSUB )
+ {
+ if ( one_burned )
+ {
+ if ( !hb_subtitle_can_pass(subtitle->source, job->mux) )
+ {
+ hb_log( "More than one subtitle burn-in requested, dropping track %d.", i );
+ hb_list_rem( title->list_subtitle, subtitle );
+ free( subtitle );
+ continue;
+ }
+ else
+ {
+ hb_log( "More than one subtitle burn-in requested. Changing track %d to soft subtitle.", i );
+ subtitle->config.dest = PASSTHRUSUB;
+ }
+ }
+ else if ( !hb_subtitle_can_burn(subtitle->source) )
+ {
+ hb_log( "Subtitle burn-in requested and input track can not be rendered. Changing track %d to soft subtitle.", i );
+ subtitle->config.dest = PASSTHRUSUB;
+ }
+ else
+ {
+ one_burned = 1;
+ }
+ }
+
+ if ( subtitle->config.dest == PASSTHRUSUB &&
+ !hb_subtitle_can_pass(subtitle->source, job->mux) )
+ {
+ if ( !one_burned )
+ {
+ hb_log( "Subtitle pass-thru requested and input track is not compatible with container. Changing track %d to burned-in subtitle.", i );
+ subtitle->config.dest = RENDERSUB;
+ subtitle->config.default_track = 0;
+ one_burned = 1;
+ }
+ else
+ {
+ hb_log( "Subtitle pass-thru requested and input track is not compatible with container. One track already burned, dropping track %d.", i );
+ hb_list_rem( title->list_subtitle, subtitle );
+ free( subtitle );
+ continue;
+ }
+ }
+ /* Adjust output track number, in case we removed one.
+ * Output tracks sadly still need to be in sequential order.
+ * Note: out.track starts at 1, i starts at 0 */
+ subtitle->out_track = ++i;
+ }
+ if ( one_burned )
+ {
+ hb_filter_object_t * filter;
+
+ // Add subtitle rendering filter
+ // Note that if the filter is already in the filter chain, this
+ // has no effect. Note also that this means the front-end is
+ // not required to add the subtitle rendering filter since
+ // we will always try to do it here.
+ filter = hb_filter_init(HB_FILTER_RENDER_SUB);
+ hb_add_filter( job, filter, NULL );
+ }
+ }
+
// Filters have an effect on settings.
// So initialize the filters and update the job.
if( job->list_filter && hb_list_count( job->list_filter ) )
{
hb_filter_init_t init;
+ int pos = -1, score = 0;
init.job = job;
init.pix_fmt = PIX_FMT_YUV420P;
init.cfr = 0;
for( i = 0; i < hb_list_count( job->list_filter ); i++ )
{
- hb_filter_object_t * filter = hb_list_item( job->list_filter, i );
+ // Some filters need to be initialized in a different order
+ // than they are executed in the pipeline. e.g. rendersub
+ // needs to be initialized after cropscale so that it knows
+ // the crop settings, but it needs to be executed before
+ // cropscale. so hb_filter_init_next() finds returns the
+ // position of filters in initialization order.
+ hb_filter_init_next( job->list_filter, &score, &pos );
+ if( pos == -1)
+ {
+ // This is an error that should never happen!
+ break;
+ }
+ hb_filter_object_t * filter = hb_list_item( job->list_filter, pos );
if( filter->init( filter, &init ) )
{
hb_log( "Failure to initialise filter '%s', disabling",
w->fifo_in = job->fifo_mpeg2;
w->fifo_out = job->fifo_raw;
- /*
- * Look for the scanned subtitle in the existing subtitle list
- * select_subtitle implies that we did a scan.
- */
- if ( !job->indepth_scan && interjob->select_subtitle &&
- ( job->pass == 0 || job->pass == 2 ) )
- {
- /*
- * Disable forced subtitles if we didn't find any in the scan
- * so that we display normal subtitles instead.
- */
- if( interjob->select_subtitle->config.force &&
- interjob->select_subtitle->forced_hits == 0 )
- {
- interjob->select_subtitle->config.force = 0;
- }
- for( i=0; i < hb_list_count(title->list_subtitle); i++ )
- {
- subtitle = hb_list_item( title->list_subtitle, i );
-
- if( subtitle )
- {
- /*
- * Remove the scanned subtitle from the subtitle list if
- * it would result in an identical duplicate subtitle track
- * or an emty track (forced and no forced hits).
- */
- if( ( interjob->select_subtitle->id == subtitle->id ) &&
- ( ( interjob->select_subtitle->forced_hits == 0 &&
- subtitle->config.force ) ||
- ( subtitle->config.force == interjob->select_subtitle->config.force ) ) )
- {
- *subtitle = *(interjob->select_subtitle);
- free( interjob->select_subtitle );
- interjob->select_subtitle = NULL;
- break;
- }
- }
- }
-
- if( interjob->select_subtitle )
- {
- /*
- * Its not in the existing list
- *
- * Must be second pass of a two pass with subtitle scan enabled, so
- * add the subtitle that we found on the first pass for use in this
- * pass.
- */
- hb_list_add( title->list_subtitle, interjob->select_subtitle );
- interjob->select_subtitle = NULL;
- }
- }
-
for( i=0; i < hb_list_count(title->list_subtitle); i++ )
{
subtitle = hb_list_item( title->list_subtitle, i );
subtitle->fifo_sync = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
subtitle->fifo_out = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
- if( (!job->indepth_scan || job->select_subtitle_config.force) &&
- subtitle->source == VOBSUB ) {
- /*
- * Don't add threads for subtitles when we are scanning, unless
- * looking for forced subtitles.
- */
- w = hb_get_work( WORK_DECVOBSUB );
- w->fifo_in = subtitle->fifo_in;
- w->fifo_out = subtitle->fifo_raw;
- w->subtitle = subtitle;
- hb_list_add( job->list_work, w );
- }
-
- if( !job->indepth_scan && subtitle->source == CC608SUB )
- {
- w = hb_get_work( WORK_DECCC608 );
- w->fifo_in = subtitle->fifo_in;
- w->fifo_out = subtitle->fifo_raw;
- hb_list_add( job->list_work, w );
- }
-
- if( !job->indepth_scan && subtitle->source == SRTSUB )
- {
- w = hb_get_work( WORK_DECSRTSUB );
- w->fifo_in = subtitle->fifo_in;
- w->fifo_out = subtitle->fifo_raw;
- w->subtitle = subtitle;
- hb_list_add( job->list_work, w );
- }
-
- if( !job->indepth_scan && subtitle->source == UTF8SUB )
- {
- w = hb_get_work( WORK_DECUTF8SUB );
- w->fifo_in = subtitle->fifo_in;
- w->fifo_out = subtitle->fifo_raw;
- hb_list_add( job->list_work, w );
- }
-
- if( !job->indepth_scan && subtitle->source == TX3GSUB )
+ if( job->indepth_scan &&
+ !( job->select_subtitle_config.force &&
+ hb_subtitle_can_force( subtitle->source ) ) )
{
- w = hb_get_work( WORK_DECTX3GSUB );
- w->fifo_in = subtitle->fifo_in;
- w->fifo_out = subtitle->fifo_raw;
- hb_list_add( job->list_work, w );
- }
-
- if( !job->indepth_scan && subtitle->source == SSASUB )
- {
- w = hb_get_work( WORK_DECSSASUB );
- w->fifo_in = subtitle->fifo_in;
- w->fifo_out = subtitle->fifo_raw;
- w->subtitle = subtitle;
- hb_list_add( job->list_work, w );
+ continue;
}
+ w = hb_get_work( subtitle->codec );
+ w->fifo_in = subtitle->fifo_in;
+ w->fifo_out = subtitle->fifo_raw;
+ w->subtitle = subtitle;
+ hb_list_add( job->list_work, w );
}
}
}
else
{
-
- /* for the actual source tracks, we must subtract the non source entries so
- * that the menu index matches the source subtitle_list index for convenience */
- if (i == 0)
- {
- /* for the first track, the source tracks start at menu index 2 ( None is 0,
- * Foreign Language Search is 1) so subtract 2 */
- subtitle = subtitle - 2;
- }
- else
- {
- /* for all other tracks, the source tracks start at menu index 1 (None is 0)
- * so subtract 1. */
-
- subtitle = subtitle - 1;
- }
-
- /* We are setting a source subtitle so access the source subtitle info */
- hb_subtitle_t * subt;
-
- subt = (hb_subtitle_t *)hb_list_item(title->list_subtitle, subtitle);
-
/* if we are getting the subtitles from an external srt file */
if ([[tempObject objectForKey:@"subtitleSourceTrackType"] isEqualToString:@"SRT"])
{
sub_config.default_track = def;
hb_srt_add( job, &sub_config, [[tempObject objectForKey:@"subtitleTrackSrtLanguageIso3"] UTF8String]);
+ continue;
}
- if (subt != NULL)
+ /* for the actual source tracks, we must subtract the non source entries so
+ * that the menu index matches the source subtitle_list index for convenience */
+ if( i == 0 )
+ {
+ /* for the first track, the source tracks start at menu index 2 ( None is 0,
+ * Foreign Language Search is 1) so subtract 2 */
+ subtitle = subtitle - 2;
+ }
+ else
+ {
+ /* for all other tracks, the source tracks start at menu index 1 (None is 0)
+ * so subtract 1. */
+ subtitle = subtitle - 1;
+ }
+
+ /* We are setting a source subtitle so access the source subtitle info */
+ hb_subtitle_t * subt = (hb_subtitle_t *) hb_list_item( title->list_subtitle, subtitle );
+
+ if( subt != NULL )
{
hb_subtitle_config_t sub_config = subt->config;
- if ( !burned && subt->format == PICTURESUB )
+ if( !burned && hb_subtitle_can_pass( subt->source, job->mux ) )
{
sub_config.dest = PASSTHRUSUB;
}
- else if ( burned && subt->format == PICTURESUB )
+ else if( hb_subtitle_can_burn( subt->source ) )
{
// Only allow one subtitle to be burned into the video
- if (one_burned)
+ if( one_burned )
continue;
one_burned = TRUE;
- }
-
- /* Besides VOBSUBS we can also burn in SSA text subs */
- if (subt->source == SSASUB && burned)
- {
sub_config.dest = RENDERSUB;
}
sub_config.force = force;
sub_config.default_track = def;
hb_subtitle_add( job, &sub_config, subtitle );
- }
-
+ }
}
}
i++;
}
else
{
-
- /* for the actual source tracks, we must subtract the non source entries so
- * that the menu index matches the source subtitle_list index for convenience */
- if (i == 0)
- {
- /* for the first track, the source tracks start at menu index 2 ( None is 0,
- * Foreign Language Search is 1) so subtract 2 */
- subtitle = subtitle - 2;
- }
- else
- {
- /* for all other tracks, the source tracks start at menu index 1 (None is 0)
- * so subtract 1. */
-
- subtitle = subtitle - 1;
- }
-
- /* We are setting a source subtitle so access the source subtitle info */
- hb_subtitle_t * subt;
-
- subt = (hb_subtitle_t *)hb_list_item(title->list_subtitle, subtitle);
-
/* if we are getting the subtitles from an external srt file */
if ([[tempObject objectForKey:@"subtitleSourceTrackType"] isEqualToString:@"SRT"])
{
sub_config.default_track = def;
hb_srt_add( job, &sub_config, [[tempObject objectForKey:@"subtitleTrackSrtLanguageIso3"] UTF8String]);
+ continue;
+ }
+
+ /* for the actual source tracks, we must subtract the non source entries so
+ * that the menu index matches the source subtitle_list index for convenience */
+ if( i == 0 )
+ {
+ /* for the first track, the source tracks start at menu index 2 ( None is 0,
+ * Foreign Language Search is 1) so subtract 2 */
+ subtitle = subtitle - 2;
+ }
+ else
+ {
+ /* for all other tracks, the source tracks start at menu index 1 (None is 0)
+ * so subtract 1. */
+ subtitle = subtitle - 1;
}
+ /* We are setting a source subtitle so access the source subtitle info */
+ hb_subtitle_t * subt = (hb_subtitle_t *) hb_list_item( title->list_subtitle, subtitle );
- if (subt != NULL)
+ if( subt != NULL )
{
hb_subtitle_config_t sub_config = subt->config;
- if ( !burned && subt->format == PICTURESUB )
+ if( !burned && hb_subtitle_can_pass( subt->source, job->mux ) )
{
sub_config.dest = PASSTHRUSUB;
}
- else if ( burned )
+ else if( hb_subtitle_can_burn( subt->source ) )
{
// Only allow one subtitle to be burned into the video
- if (one_burned)
+ if( one_burned )
continue;
one_burned = TRUE;
- }
-
- /* Besides VOBSUBS we can also burn in SSA text subs */
- if (subt->source == SSASUB && burned)
- {
sub_config.dest = RENDERSUB;
}
-
+
sub_config.force = force;
sub_config.default_track = def;
hb_subtitle_add( job, &sub_config, subtitle );
- }
-
+ }
}
}
i++;
This file is part of the HandBrake source code.
Homepage: <http://handbrake.fr/>.
It may be used under the terms of the GNU General Public License. */
-//
#import "HBSubtitles.h"
#include "hb.h"
-
-
-
-
-
-
-
@implementation HBSubtitles
- (id)init
{
subtitle = (hb_subtitle_t *) hb_list_item( fTitle->list_subtitle, i );
sub_config = subtitle->config;
- int canBeBurnedIn = subtitle->source == VOBSUB || subtitle->source == SSASUB;
- int supportsForcedFlags = subtitle->source == VOBSUB;
+ int canBeBurnedIn = hb_subtitle_can_burn( subtitle->source );
+ int supportsForcedFlags = hb_subtitle_can_force( subtitle->source );
/* create a dictionary of source subtitle information to store in our array */
NSMutableDictionary *newSubtitleSourceTrack = [[NSMutableDictionary alloc] init];
[newSubtitleSourceTrack setObject:[NSNumber numberWithInt:i] forKey:@"sourceTrackNum"];
/* Human-readable representation of subtitle->source */
NSString *subSourceName = [NSString stringWithUTF8String:hb_subsource_name( subtitle->source )];
- NSString *bitmapOrText = subtitle->source == PICTURESUB ? @"Bitmap" : @"Text";
+ NSString *bitmapOrText = subtitle->format == PICTURESUB ? @"Bitmap" : @"Text";
/* Subtitle Source track name */
NSString *popupName = [NSString stringWithFormat:@"%d - %@ - (%@) (%@)",i,[NSString stringWithUTF8String:subtitle->lang],bitmapOrText,subSourceName];
[newSubtitleSourceTrack setObject:popupName forKey:@"sourceTrackName"];
*/
if (container == HB_MUX_MP4 && [anObject intValue] != 0)
{
- if ([[[subtitleArray objectAtIndex:rowIndex] objectForKey:@"subtitleSourceTrackType"] isEqualToString:[NSString stringWithUTF8String:hb_subsource_name( VOBSUB )]])
+ NSString *subtitleSourceTrackType = [[subtitleArray objectAtIndex:rowIndex] objectForKey:@"subtitleSourceTrackType"];
+ if ([subtitleSourceTrackType isEqualToString:[NSString stringWithUTF8String:hb_subsource_name( VOBSUB )]] ||
+ [subtitleSourceTrackType isEqualToString:[NSString stringWithUTF8String:hb_subsource_name( PGSSUB )]])
{
/* lets see if there are currently any burned in subs specified */
NSEnumerator *enumerator = [subtitleArray objectEnumerator];
}
}
/* if we have no current vobsub set to burn it in ... burn it in by default */
- if(!subtrackBurnedInFound)
+ if (!subtrackBurnedInFound)
{
[[subtitleArray objectAtIndex:rowIndex] setObject:[NSNumber numberWithInt:1] forKey:@"subtitleTrackBurned"];
/* Burned In and Default are mutually exclusive */
force = test_sub_list(subforce, i+1);
- int supports_burn =
- ( subtitle->source == VOBSUB ) ||
- ( subtitle->source == SSASUB );
+ int supports_burn = hb_subtitle_can_burn( subtitle->source );
- if ( burn && supports_burn )
+ if ( ( burn && supports_burn ) ||
+ !hb_subtitle_can_pass( subtitle->source, mux ) )
{
// Only allow one subtitle to be burned into video
if ( sub_burned )
projects / handbrake / commitdiff