mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-04-26 04:36:20 +00:00
Code Issues 1 Projects Releases Wiki Activity

assrender: Refactoring and make core more similar to textoverlay

Browse source 
Especially the combining of the text and video buffers is now
almost the same as in textoverlay.

We should really get a base class for this.

Conflicts:

	ext/assrender/gstassrender.c
	ext/assrender/gstassrender.h
This commit is contained in:
Andre Moreira Magalhaes (andrunko) 2012-05-24 11:11:00 -03:00 committed by Sebastian Dröge
parent 70719535dc
commit 2213a44214
2 changed files with 403 additions and 204 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

599
ext/assrender/gstassrender.c
View file

@ -82,6 +82,14 @@ static GstStaticPadTemplate text_sink_factory =
GST_STATIC_CAPS ("application/x-ass; application/x-ssa") GST_STATIC_CAPS ("application/x-ass; application/x-ssa")
); );
#define GST_ASS_RENDER_GET_LOCK(ass) (&GST_ASS_RENDER (ass)->lock)
#define GST_ASS_RENDER_GET_COND(ass) (&GST_ASS_RENDER (ass)->cond)
#define GST_ASS_RENDER_LOCK(ass) (g_mutex_lock (GST_ASS_RENDER_GET_LOCK (ass)))
#define GST_ASS_RENDER_UNLOCK(ass) (g_mutex_unlock (GST_ASS_RENDER_GET_LOCK (ass)))
#define GST_ASS_RENDER_WAIT(ass) (g_cond_wait (GST_ASS_RENDER_GET_COND (ass), GST_ASS_RENDER_GET_LOCK (ass)))
#define GST_ASS_RENDER_SIGNAL(ass) (g_cond_signal (GST_ASS_RENDER_GET_COND (ass)))
#define GST_ASS_RENDER_BROADCAST(ass)(g_cond_broadcast (GST_ASS_RENDER_GET_COND (ass)))
static void gst_ass_render_set_property (GObject * object, guint prop_id, static void gst_ass_render_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec); const GValue * value, GParamSpec * pspec);
static void gst_ass_render_get_property (GObject * object, guint prop_id, static void gst_ass_render_get_property (GObject * object, guint prop_id,
@ -210,8 +218,8 @@ gst_ass_render_init (GstAssRender * render)
gst_video_info_init (&render->info); gst_video_info_init (&render->info);
g_mutex_init (&render->subtitle_mutex); g_mutex_init (&render->lock);
g_cond_init (&render->subtitle_cond); g_cond_init (&render->cond);
render->renderer_init_ok = FALSE; render->renderer_init_ok = FALSE;
render->track_init_ok = FALSE; render->track_init_ok = FALSE;
@ -244,8 +252,8 @@ gst_ass_render_finalize (GObject * object)
{ {
GstAssRender *render = GST_ASS_RENDER (object); GstAssRender *render = GST_ASS_RENDER (object);
g_mutex_clear (&render->subtitle_mutex); g_mutex_clear (&render->lock);
g_cond_clear (&render->subtitle_cond); g_cond_clear (&render->cond);
if (render->ass_track) { if (render->ass_track) {
ass_free_track (render->ass_track); ass_free_track (render->ass_track);
@ -270,6 +278,7 @@ gst_ass_render_set_property (GObject * object, guint prop_id,
{ {
GstAssRender *render = GST_ASS_RENDER (object); GstAssRender *render = GST_ASS_RENDER (object);
GST_ASS_RENDER_LOCK (render);
switch (prop_id) { switch (prop_id) {
case PROP_ENABLE: case PROP_ENABLE:
render->enable = g_value_get_boolean (value); render->enable = g_value_get_boolean (value);
@ -284,6 +293,7 @@ gst_ass_render_set_property (GObject * object, guint prop_id,
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
} }
GST_ASS_RENDER_UNLOCK (render);
} }
static void static void
@ -292,6 +302,7 @@ gst_ass_render_get_property (GObject * object, guint prop_id,
{ {
GstAssRender *render = GST_ASS_RENDER (object); GstAssRender *render = GST_ASS_RENDER (object);
GST_ASS_RENDER_LOCK (render);
switch (prop_id) { switch (prop_id) {
case PROP_ENABLE: case PROP_ENABLE:
g_value_set_boolean (value, render->enable); g_value_set_boolean (value, render->enable);
@ -303,6 +314,7 @@ gst_ass_render_get_property (GObject * object, guint prop_id,
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
} }
GST_ASS_RENDER_UNLOCK (render);
} }
static GstStateChangeReturn static GstStateChangeReturn
@ -312,28 +324,23 @@ gst_ass_render_change_state (GstElement * element, GstStateChange transition)
GstStateChangeReturn ret; GstStateChangeReturn ret;
switch (transition) { switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
render->subtitle_flushing = FALSE;
gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
break;
case GST_STATE_CHANGE_NULL_TO_READY:
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
default:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY: case GST_STATE_CHANGE_PAUSED_TO_READY:
g_mutex_lock (&render->subtitle_mutex); GST_ASS_RENDER_LOCK (render);
render->subtitle_flushing = TRUE; render->subtitle_flushing = TRUE;
render->video_flushing = TRUE;
if (render->subtitle_pending) if (render->subtitle_pending)
gst_buffer_unref (render->subtitle_pending); gst_buffer_unref (render->subtitle_pending);
render->subtitle_pending = NULL; render->subtitle_pending = NULL;
g_cond_signal (&render->subtitle_cond); GST_ASS_RENDER_BROADCAST (render);
g_mutex_unlock (&render->subtitle_mutex); GST_ASS_RENDER_UNLOCK (render);
break;
default:
break; break;
} }
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) { switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY: case GST_STATE_CHANGE_PAUSED_TO_READY:
@ -341,12 +348,20 @@ gst_ass_render_change_state (GstElement * element, GstStateChange transition)
if (render->ass_track) if (render->ass_track)
ass_free_track (render->ass_track); ass_free_track (render->ass_track);
render->ass_track = NULL; render->ass_track = NULL;
g_mutex_unlock (&render->ass_mutex);
render->track_init_ok = FALSE; render->track_init_ok = FALSE;
render->renderer_init_ok = FALSE; render->renderer_init_ok = FALSE;
g_mutex_unlock (&render->ass_mutex);
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
GST_ASS_RENDER_LOCK (render);
render->subtitle_flushing = FALSE;
render->video_flushing = FALSE;
render->video_eos = FALSE;
render->subtitle_eos = FALSE;
gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
GST_ASS_RENDER_UNLOCK (render);
break; break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
case GST_STATE_CHANGE_READY_TO_NULL:
default: default:
break; break;
} }
@ -386,10 +401,18 @@ gst_ass_render_event_src (GstPad * pad, GstObject * parent, GstEvent * event)
GstAssRender *render = GST_ASS_RENDER (parent); GstAssRender *render = GST_ASS_RENDER (parent);
gboolean ret = FALSE; gboolean ret = FALSE;
GST_DEBUG_OBJECT (render, "received src event %" GST_PTR_FORMAT, event);
switch (GST_EVENT_TYPE (event)) { switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEEK:{ case GST_EVENT_SEEK:{
GstSeekFlags flags; GstSeekFlags flags;
if (!render->track_init_ok) {
GST_DEBUG_OBJECT (render, "seek received, pushing upstream");
ret = gst_pad_push_event (render->video_sinkpad, event);
return ret;
}
GST_DEBUG_OBJECT (render, "seek received, driving from here"); GST_DEBUG_OBJECT (render, "seek received, driving from here");
gst_event_parse_seek (event, NULL, NULL, &flags, NULL, NULL, NULL, NULL); gst_event_parse_seek (event, NULL, NULL, &flags, NULL, NULL, NULL, NULL);
@ -399,13 +422,14 @@ gst_ass_render_event_src (GstPad * pad, GstObject * parent, GstEvent * event)
gst_pad_push_event (render->srcpad, gst_event_new_flush_start ()); gst_pad_push_event (render->srcpad, gst_event_new_flush_start ());
/* Mark subtitle as flushing, unblocks chains */ /* Mark subtitle as flushing, unblocks chains */
g_mutex_lock (&render->subtitle_mutex); GST_ASS_RENDER_LOCK (render);
render->subtitle_flushing = TRUE;
render->video_flushing = TRUE;
if (render->subtitle_pending) if (render->subtitle_pending)
gst_buffer_unref (render->subtitle_pending); gst_buffer_unref (render->subtitle_pending);
render->subtitle_pending = NULL; render->subtitle_pending = NULL;
render->subtitle_flushing = TRUE; GST_ASS_RENDER_BROADCAST (render);
g_cond_signal (&render->subtitle_cond); GST_ASS_RENDER_UNLOCK (render);
g_mutex_unlock (&render->subtitle_mutex);
/* Seek on each sink pad */ /* Seek on each sink pad */
gst_event_ref (event); gst_event_ref (event);
@ -418,9 +442,13 @@ gst_ass_render_event_src (GstPad * pad, GstObject * parent, GstEvent * event)
break; break;
} }
default: default:
gst_event_ref (event); if (render->track_init_ok) {
ret = gst_pad_push_event (render->video_sinkpad, event); gst_event_ref (event);
gst_pad_push_event (render->text_sinkpad, event); ret = gst_pad_push_event (render->video_sinkpad, event);
gst_pad_push_event (render->text_sinkpad, event);
} else {
ret = gst_pad_push_event (render->video_sinkpad, event);
}
break; break;
} }
@ -913,11 +941,8 @@ gst_ass_render_chain_video (GstPad * pad, GstObject * parent,
guint64 start, stop, clip_start = 0, clip_stop = 0; guint64 start, stop, clip_start = 0, clip_stop = 0;
ASS_Image *ass_image; ASS_Image *ass_image;
if (!GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) { if (!GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
GST_WARNING_OBJECT (render, "buffer without timestamp, discarding"); goto missing_timestamp;
gst_buffer_unref (buffer);
return GST_FLOW_OK;
}
/* ignore buffers that are outside of the current segment */ /* ignore buffers that are outside of the current segment */
start = GST_BUFFER_TIMESTAMP (buffer); start = GST_BUFFER_TIMESTAMP (buffer);
@ -949,94 +974,235 @@ gst_ass_render_chain_video (GstPad * pad, GstObject * parent,
GST_BUFFER_DURATION (buffer) = clip_stop - clip_start; GST_BUFFER_DURATION (buffer) = clip_stop - clip_start;
} }
render->video_segment.position = clip_start; /* now, after we've done the clipping, fix up end time if there's no
* duration (we only use those estimated values internally though, we
g_mutex_lock (&render->subtitle_mutex); * don't want to set bogus values on the buffer itself) */
if (render->subtitle_pending) { if (stop == -1) {
GstClockTime sub_running_time, vid_running_time; if (render->info.fps_n && render->info.fps_d) {
GstClockTime sub_running_time_end, vid_running_time_end; GST_DEBUG_OBJECT (render, "estimating duration based on framerate");
stop =
sub_running_time = start + gst_util_uint64_scale_int (GST_SECOND, render->info.fps_d,
gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME, render->info.fps_n);
GST_BUFFER_TIMESTAMP (render->subtitle_pending)); } else {
sub_running_time_end = GST_WARNING_OBJECT (render, "no duration, assuming minimal duration");
gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME, stop = start + 1; /* we need to assume some interval */
GST_BUFFER_TIMESTAMP (render->subtitle_pending) +
GST_BUFFER_DURATION (render->subtitle_pending));
vid_running_time =
gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
GST_BUFFER_TIMESTAMP (buffer));
vid_running_time_end =
gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer));
if (sub_running_time_end < vid_running_time) {
gst_buffer_unref (render->subtitle_pending);
GST_DEBUG_OBJECT (render,
"Too late text buffer, dropping (%" GST_TIME_FORMAT " < %"
GST_TIME_FORMAT, GST_TIME_ARGS (sub_running_time_end),
GST_TIME_ARGS (vid_running_time));
render->subtitle_pending = NULL;
g_cond_signal (&render->subtitle_cond);
} else if (sub_running_time <= vid_running_time_end + GST_SECOND / 2) {
gst_ass_render_process_text (render, render->subtitle_pending,
sub_running_time, sub_running_time_end - sub_running_time);
render->subtitle_pending = NULL;
g_cond_signal (&render->subtitle_cond);
} }
} }
g_mutex_unlock (&render->subtitle_mutex);
/* now start rendering subtitles, if all conditions are met */ wait_for_text_buf:
GST_ASS_RENDER_LOCK (render);
if (render->video_flushing)
goto flushing;
if (render->video_eos)
goto have_eos;
if (render->renderer_init_ok && render->track_init_ok && render->enable) { if (render->renderer_init_ok && render->track_init_ok && render->enable) {
GstClockTime running_time; /* Text pad linked, check if we have a text buffer queued */
gdouble timestamp; if (render->subtitle_pending) {
#ifndef GST_DISABLE_GST_DEBUG gboolean pop_text = FALSE, valid_text_time = TRUE;
gdouble step; GstClockTime text_start = GST_CLOCK_TIME_NONE;
#endif GstClockTime text_end = GST_CLOCK_TIME_NONE;
GstClockTime text_running_time = GST_CLOCK_TIME_NONE;
GstClockTime text_running_time_end = GST_CLOCK_TIME_NONE;
GstClockTime vid_running_time, vid_running_time_end;
running_time = /* if the text buffer isn't stamped right, pop it off the
gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME, * queue and display it for the current video frame only */
GST_BUFFER_TIMESTAMP (buffer)); if (!GST_BUFFER_TIMESTAMP_IS_VALID (render->subtitle_pending) ||
GST_DEBUG_OBJECT (render, !GST_BUFFER_DURATION_IS_VALID (render->subtitle_pending)) {
"rendering frame for running time %" GST_TIME_FORMAT, GST_WARNING_OBJECT (render,
GST_TIME_ARGS (running_time)); "Got text buffer with invalid timestamp or duration");
/* libass needs timestamps in ms */ valid_text_time = FALSE;
timestamp = running_time / GST_MSECOND; } else {
text_start = GST_BUFFER_TIMESTAMP (render->subtitle_pending);
text_end = text_start + GST_BUFFER_DURATION (render->subtitle_pending);
}
g_mutex_lock (&render->ass_mutex); vid_running_time =
#ifndef GST_DISABLE_GST_DEBUG gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
/* only for testing right now. could possibly be used for optimizations? */ start);
step = ass_step_sub (render->ass_track, timestamp, 1); vid_running_time_end =
GST_DEBUG_OBJECT (render, "Current running time: %" GST_TIME_FORMAT gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
" // Next event: %" GST_TIME_FORMAT, stop);
GST_TIME_ARGS (running_time), GST_TIME_ARGS (step * GST_MSECOND));
#endif
/* not sure what the last parameter to this call is for (detect_change) */ /* If timestamp and duration are valid */
ass_image = ass_render_frame (render->ass_renderer, render->ass_track, if (valid_text_time) {
timestamp, NULL); text_running_time =
g_mutex_unlock (&render->ass_mutex); gst_segment_to_running_time (&render->video_segment,
GST_FORMAT_TIME, text_start);
text_running_time_end =
gst_segment_to_running_time (&render->video_segment,
GST_FORMAT_TIME, text_end);
}
if (ass_image != NULL) { GST_LOG_OBJECT (render, "T: %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
GstVideoFrame frame; GST_TIME_ARGS (text_running_time),
GST_TIME_ARGS (text_running_time_end));
GST_LOG_OBJECT (render, "V: %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
GST_TIME_ARGS (vid_running_time),
GST_TIME_ARGS (vid_running_time_end));
buffer = gst_buffer_make_writable (buffer); /* Text too old or in the future */
if (valid_text_time && text_running_time_end <= vid_running_time) {
/* text buffer too old, get rid of it and do nothing */
GST_DEBUG_OBJECT (render, "text buffer too old, popping");
pop_text = FALSE;
gst_buffer_unref (render->subtitle_pending);
render->subtitle_pending = NULL;
GST_ASS_RENDER_BROADCAST (render);
GST_ASS_RENDER_UNLOCK (render);
goto wait_for_text_buf;
} else if (valid_text_time && vid_running_time_end <= text_running_time) {
gdouble timestamp;
gst_video_frame_map (&frame, &render->info, buffer, GST_MAP_WRITE); GST_ASS_RENDER_UNLOCK (render);
render->blit (render, ass_image, &frame);
gst_video_frame_unmap (&frame); timestamp = vid_running_time / GST_MSECOND;
g_mutex_lock (&render->ass_mutex);
/* not sure what the last parameter to this call is for (detect_change) */
ass_image = ass_render_frame (render->ass_renderer, render->ass_track,
timestamp, NULL);
g_mutex_unlock (&render->ass_mutex);
if (ass_image != NULL) {
GstVideoFrame frame;
buffer = gst_buffer_make_writable (buffer);
gst_video_frame_map (&frame, &render->info, buffer, GST_MAP_WRITE);
render->blit (render, ass_image, &frame);
gst_video_frame_unmap (&frame);
} else {
GST_LOG_OBJECT (render, "nothing to render right now");
}
/* Push the video frame */
ret = gst_pad_push (render->srcpad, buffer);
} else {
gdouble timestamp;
gst_ass_render_process_text (render, render->subtitle_pending,
text_running_time, text_running_time_end - text_running_time);
render->subtitle_pending = NULL;
GST_ASS_RENDER_BROADCAST (render);
GST_ASS_RENDER_UNLOCK (render);
/* libass needs timestamps in ms */
timestamp = vid_running_time / GST_MSECOND;
g_mutex_lock (&render->ass_mutex);
/* not sure what the last parameter to this call is for (detect_change) */
ass_image = ass_render_frame (render->ass_renderer, render->ass_track,
timestamp, NULL);
g_mutex_unlock (&render->ass_mutex);
if (ass_image != NULL) {
GstVideoFrame frame;
buffer = gst_buffer_make_writable (buffer);
gst_video_frame_map (&frame, &render->info, buffer, GST_MAP_WRITE);
render->blit (render, ass_image, &frame);
gst_video_frame_unmap (&frame);
} else {
GST_DEBUG_OBJECT (render, "nothing to render right now");
}
ret = gst_pad_push (render->srcpad, buffer);
if (valid_text_time && text_running_time_end <= vid_running_time_end) {
GST_LOG_OBJECT (render, "text buffer not needed any longer");
pop_text = TRUE;
}
}
if (pop_text) {
GST_ASS_RENDER_LOCK (render);
if (render->subtitle_pending)
gst_buffer_unref (render->subtitle_pending);
render->subtitle_pending = NULL;
GST_ASS_RENDER_BROADCAST (render);
GST_ASS_RENDER_UNLOCK (render);
}
} else { } else {
GST_LOG_OBJECT (render, "nothing to render right now"); gboolean wait_for_text_buf = TRUE;
if (render->subtitle_eos)
wait_for_text_buf = FALSE;
/* Text pad linked, but no text buffer available - what now? */
if (render->subtitle_segment.format == GST_FORMAT_TIME) {
GstClockTime text_start_running_time, text_last_stop_running_time;
GstClockTime vid_running_time;
vid_running_time =
gst_segment_to_running_time (&render->video_segment,
GST_FORMAT_TIME, GST_BUFFER_TIMESTAMP (buffer));
text_start_running_time =
gst_segment_to_running_time (&render->subtitle_segment,
GST_FORMAT_TIME, render->subtitle_segment.start);
text_last_stop_running_time =
gst_segment_to_running_time (&render->subtitle_segment,
GST_FORMAT_TIME, render->subtitle_segment.position);
if ((GST_CLOCK_TIME_IS_VALID (text_start_running_time) &&
vid_running_time < text_start_running_time) ||
(GST_CLOCK_TIME_IS_VALID (text_last_stop_running_time) &&
vid_running_time < text_last_stop_running_time)) {
wait_for_text_buf = FALSE;
}
}
if (wait_for_text_buf) {
GST_DEBUG_OBJECT (render, "no text buffer, need to wait for one");
GST_ASS_RENDER_WAIT (render);
GST_DEBUG_OBJECT (render, "resuming");
GST_ASS_RENDER_UNLOCK (render);
goto wait_for_text_buf;
} else {
GST_ASS_RENDER_UNLOCK (render);
GST_LOG_OBJECT (render, "no need to wait for a text buffer");
ret = gst_pad_push (render->srcpad, buffer);
}
} }
} else { } else {
GST_LOG_OBJECT (render, "rendering disabled, doing buffer passthrough"); GST_LOG_OBJECT (render, "rendering disabled, doing buffer passthrough");
GST_ASS_RENDER_UNLOCK (render);
ret = gst_pad_push (render->srcpad, buffer);
return ret;
} }
ret = gst_pad_push (render->srcpad, buffer); GST_DEBUG_OBJECT (render, "leaving chain for buffer %p ret=%d", buffer, ret);
/* Update last_stop */
render->video_segment.position = clip_start;
return ret; return ret;
missing_timestamp:
{
GST_WARNING_OBJECT (render, "buffer without timestamp, discarding");
gst_buffer_unref (buffer);
return GST_FLOW_OK;
}
flushing:
{
GST_ASS_RENDER_UNLOCK (render);
GST_DEBUG_OBJECT (render, "flushing, discarding buffer");
gst_buffer_unref (buffer);
return GST_FLOW_FLUSHING;
}
have_eos:
{
GST_ASS_RENDER_UNLOCK (render);
GST_DEBUG_OBJECT (render, "eos, discarding buffer");
gst_buffer_unref (buffer);
return GST_FLOW_EOS;
}
out_of_segment: out_of_segment:
{ {
GST_DEBUG_OBJECT (render, "buffer out of segment, discarding"); GST_DEBUG_OBJECT (render, "buffer out of segment, discarding");
@ -1050,94 +1216,86 @@ gst_ass_render_chain_text (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{ {
GstFlowReturn ret = GST_FLOW_OK; GstFlowReturn ret = GST_FLOW_OK;
GstAssRender *render = GST_ASS_RENDER (parent); GstAssRender *render = GST_ASS_RENDER (parent);
GstClockTime timestamp, duration; gboolean in_seg = FALSE;
GstClockTime sub_running_time, vid_running_time; guint64 clip_start = 0, clip_stop = 0;
GstClockTime sub_running_time_end;
guint64 cstart, cstop; GST_DEBUG_OBJECT (render, "entering chain for buffer %p", buffer);
gboolean in_seg;
GST_ASS_RENDER_LOCK (render);
if (render->subtitle_flushing) { if (render->subtitle_flushing) {
gst_buffer_unref (buffer); GST_ASS_RENDER_UNLOCK (render);
return GST_FLOW_FLUSHING; ret = GST_FLOW_FLUSHING;
GST_LOG_OBJECT (render, "text flushing");
goto beach;
} }
timestamp = GST_BUFFER_TIMESTAMP (buffer); if (render->subtitle_eos) {
duration = GST_BUFFER_DURATION (buffer); GST_ASS_RENDER_UNLOCK (render);
ret = GST_FLOW_EOS;
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (timestamp) GST_LOG_OBJECT (render, "text EOS");
|| !GST_CLOCK_TIME_IS_VALID (duration))) { goto beach;
GST_WARNING_OBJECT (render,
"Text buffer without valid timestamp" " or duration, dropping");
gst_buffer_unref (buffer);
return GST_FLOW_OK;
} }
in_seg = if (G_LIKELY (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))) {
gst_segment_clip (&render->subtitle_segment, GST_FORMAT_TIME, timestamp, GstClockTime stop;
timestamp + duration, &cstart, &cstop);
if (!in_seg) {
GST_DEBUG_OBJECT (render,
"Text buffer before segment start (%" GST_TIME_FORMAT " < %"
GST_TIME_FORMAT ")", GST_TIME_ARGS (timestamp),
GST_TIME_ARGS (render->subtitle_segment.start));
gst_buffer_unref (buffer);
return GST_FLOW_OK;
}
GST_BUFFER_TIMESTAMP (buffer) = timestamp = cstart; if (G_LIKELY (GST_BUFFER_DURATION_IS_VALID (buffer)))
GST_BUFFER_DURATION (buffer) = duration = cstop - cstart; stop = GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer);
else
stop = GST_CLOCK_TIME_NONE;
render->subtitle_segment.position = GST_BUFFER_TIMESTAMP (buffer); in_seg = gst_segment_clip (&render->subtitle_segment, GST_FORMAT_TIME,
GST_BUFFER_TIMESTAMP (buffer), stop, &clip_start, &clip_stop);
sub_running_time =
gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME,
timestamp);
sub_running_time_end =
gst_segment_to_running_time (&render->subtitle_segment, GST_FORMAT_TIME,
timestamp + duration);
vid_running_time =
gst_segment_to_running_time (&render->video_segment, GST_FORMAT_TIME,
render->video_segment.position);
if (render->info.fps_n && render->info.fps_d)
vid_running_time +=
gst_util_uint64_scale (GST_SECOND, render->info.fps_d,
render->info.fps_n);
if (sub_running_time > vid_running_time + GST_SECOND / 2) {
g_assert (render->subtitle_pending == NULL);
g_mutex_lock (&render->subtitle_mutex);
if (G_UNLIKELY (render->subtitle_flushing)) {
GST_DEBUG_OBJECT (render, "Text pad flushing");
gst_buffer_unref (buffer);
g_mutex_unlock (&render->subtitle_mutex);
return GST_FLOW_FLUSHING;
}
GST_DEBUG_OBJECT (render,
"Too early text buffer, waiting (%" GST_TIME_FORMAT " > %"
GST_TIME_FORMAT, GST_TIME_ARGS (sub_running_time),
GST_TIME_ARGS (vid_running_time));
render->subtitle_pending = buffer;
g_cond_wait (&render->subtitle_cond, &render->subtitle_mutex);
g_mutex_unlock (&render->subtitle_mutex);
} else if (sub_running_time_end < vid_running_time) {
GST_DEBUG_OBJECT (render,
"Too late text buffer, dropping (%" GST_TIME_FORMAT " < %"
GST_TIME_FORMAT, GST_TIME_ARGS (sub_running_time_end),
GST_TIME_ARGS (vid_running_time));
gst_buffer_unref (buffer);
ret = GST_FLOW_OK;
} else { } else {
gst_ass_render_process_text (render, buffer, sub_running_time, in_seg = TRUE;
sub_running_time_end - sub_running_time);
ret = GST_FLOW_OK;
} }
GST_DEBUG_OBJECT (render, if (in_seg) {
"processed text packet with timestamp %" GST_TIME_FORMAT if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
" and duration %" GST_TIME_FORMAT, GST_BUFFER_TIMESTAMP (buffer) = clip_start;
GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration)); else if (GST_BUFFER_DURATION_IS_VALID (buffer))
GST_BUFFER_DURATION (buffer) = clip_stop - clip_start;
if (render->subtitle_pending
&& (!GST_BUFFER_TIMESTAMP_IS_VALID (render->subtitle_pending)
|| !GST_BUFFER_DURATION_IS_VALID (render->subtitle_pending))) {
gst_buffer_unref (render->subtitle_pending);
render->subtitle_pending = NULL;
GST_ASS_RENDER_BROADCAST (render);
} else {
/* Wait for the previous buffer to go away */
while (render->subtitle_pending != NULL) {
GST_DEBUG ("Pad %s:%s has a buffer queued, waiting",
GST_DEBUG_PAD_NAME (pad));
GST_ASS_RENDER_WAIT (render);
GST_DEBUG ("Pad %s:%s resuming", GST_DEBUG_PAD_NAME (pad));
if (render->subtitle_flushing) {
GST_ASS_RENDER_UNLOCK (render);
ret = GST_FLOW_FLUSHING;
goto beach;
}
}
}
if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
render->subtitle_segment.position = clip_start;
GST_DEBUG_OBJECT (render,
"New buffer arrived for timestamp %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)));
render->subtitle_pending = gst_buffer_ref (buffer);
/* in case the video chain is waiting for a text buffer, wake it up */
GST_ASS_RENDER_BROADCAST (render);
}
GST_ASS_RENDER_UNLOCK (render);
beach:
GST_DEBUG_OBJECT (render, "leaving chain for buffer %p", buffer);
gst_buffer_unref (buffer);
return ret; return ret;
} }
@ -1227,8 +1385,7 @@ gst_ass_render_event_video (GstPad * pad, GstObject * parent, GstEvent * event)
gboolean ret = FALSE; gboolean ret = FALSE;
GstAssRender *render = GST_ASS_RENDER (parent); GstAssRender *render = GST_ASS_RENDER (parent);
GST_DEBUG_OBJECT (pad, "received video event %s", GST_DEBUG_OBJECT (pad, "received video event %" GST_PTR_FORMAT, event);
GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event)) { switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS: case GST_EVENT_CAPS:
@ -1256,7 +1413,7 @@ gst_ass_render_event_video (GstPad * pad, GstObject * parent, GstEvent * event)
GST_DEBUG_OBJECT (render, "VIDEO SEGMENT after: %" GST_SEGMENT_FORMAT, GST_DEBUG_OBJECT (render, "VIDEO SEGMENT after: %" GST_SEGMENT_FORMAT,
&render->video_segment); &render->video_segment);
ret = gst_pad_push_event (render->srcpad, event); ret = gst_pad_event_default (pad, parent, event);
} else { } else {
GST_ELEMENT_WARNING (render, STREAM, MUX, (NULL), GST_ELEMENT_WARNING (render, STREAM, MUX, (NULL),
("received non-TIME newsegment event on video input")); ("received non-TIME newsegment event on video input"));
@ -1274,13 +1431,35 @@ gst_ass_render_event_video (GstPad * pad, GstObject * parent, GstEvent * event)
gst_event_parse_tag (event, &taglist); gst_event_parse_tag (event, &taglist);
gst_ass_render_handle_tags (render, taglist); gst_ass_render_handle_tags (render, taglist);
ret = gst_pad_push_event (render->srcpad, event); ret = gst_pad_event_default (pad, parent, event);
break; break;
} }
case GST_EVENT_EOS:
GST_ASS_RENDER_LOCK (render);
GST_INFO_OBJECT (render, "video EOS");
render->video_eos = TRUE;
GST_ASS_RENDER_UNLOCK (render);
ret = gst_pad_event_default (pad, parent, event);
break;
case GST_EVENT_FLUSH_START:
GST_ASS_RENDER_LOCK (render);
GST_INFO_OBJECT (render, "video flush start");
render->video_flushing = TRUE;
GST_ASS_RENDER_BROADCAST (render);
GST_ASS_RENDER_UNLOCK (render);
ret = gst_pad_event_default (pad, parent, event);
break;
case GST_EVENT_FLUSH_STOP: case GST_EVENT_FLUSH_STOP:
GST_ASS_RENDER_LOCK (render);
GST_INFO_OBJECT (render, "video flush stop");
render->video_flushing = FALSE;
render->video_eos = FALSE;
gst_segment_init (&render->video_segment, GST_FORMAT_TIME); gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
GST_ASS_RENDER_UNLOCK (render);
ret = gst_pad_event_default (pad, parent, event);
break;
default: default:
ret = gst_pad_push_event (render->srcpad, event); ret = gst_pad_event_default (pad, parent, event);
break; break;
} }
@ -1319,7 +1498,7 @@ gst_ass_render_event_text (GstPad * pad, GstObject * parent, GstEvent * event)
gboolean ret = FALSE; gboolean ret = FALSE;
GstAssRender *render = GST_ASS_RENDER (parent); GstAssRender *render = GST_ASS_RENDER (parent);
GST_DEBUG_OBJECT (pad, "received text event %s", GST_EVENT_TYPE_NAME (event)); GST_DEBUG_OBJECT (pad, "received text event %" GST_PTR_FORMAT, event);
switch (GST_EVENT_TYPE (event)) { switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS: case GST_EVENT_CAPS:
@ -1335,37 +1514,52 @@ gst_ass_render_event_text (GstPad * pad, GstObject * parent, GstEvent * event)
{ {
GstSegment segment; GstSegment segment;
GST_DEBUG_OBJECT (render, "received new segment"); GST_ASS_RENDER_LOCK (render);
render->subtitle_eos = FALSE;
GST_ASS_RENDER_UNLOCK (render);
gst_event_copy_segment (event, &segment); gst_event_copy_segment (event, &segment);
GST_ASS_RENDER_LOCK (render);
if (segment.format == GST_FORMAT_TIME) { if (segment.format == GST_FORMAT_TIME) {
GST_DEBUG_OBJECT (render, "SUBTITLE SEGMENT now: %" GST_SEGMENT_FORMAT, GST_DEBUG_OBJECT (render, "TEXT SEGMENT now: %" GST_SEGMENT_FORMAT,
&render->subtitle_segment); &render->subtitle_segment);
render->subtitle_segment = segment; render->subtitle_segment = segment;
GST_DEBUG_OBJECT (render, GST_DEBUG_OBJECT (render,
"SUBTITLE SEGMENT after: %" GST_SEGMENT_FORMAT, "TEXT SEGMENT after: %" GST_SEGMENT_FORMAT,
&render->subtitle_segment); &render->subtitle_segment);
ret = TRUE;
gst_event_unref (event);
} else { } else {
GST_ELEMENT_WARNING (render, STREAM, MUX, (NULL), GST_ELEMENT_WARNING (render, STREAM, MUX, (NULL),
("received non-TIME newsegment event on subtitle input")); ("received non-TIME newsegment event on subtitle input"));
ret = FALSE;
gst_event_unref (event);
} }
gst_event_unref (event);
ret = TRUE;
/* wake up the video chain, it might be waiting for a text buffer or
* a text segment update */
GST_ASS_RENDER_BROADCAST (render);
GST_ASS_RENDER_UNLOCK (render);
break; break;
} }
case GST_EVENT_FLUSH_STOP: case GST_EVENT_FLUSH_STOP:
gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME); GST_ASS_RENDER_LOCK (render);
GST_INFO_OBJECT (render, "text flush stop");
render->subtitle_flushing = FALSE; render->subtitle_flushing = FALSE;
render->subtitle_eos = FALSE;
if (render->subtitle_pending)
gst_buffer_unref (render->subtitle_pending);
render->subtitle_pending = NULL;
GST_ASS_RENDER_BROADCAST (render);
gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
GST_ASS_RENDER_UNLOCK (render);
gst_event_unref (event); gst_event_unref (event);
ret = TRUE; ret = TRUE;
break; break;
case GST_EVENT_FLUSH_START: case GST_EVENT_FLUSH_START:
GST_DEBUG_OBJECT (render, "begin flushing"); GST_DEBUG_OBJECT (render, "text flush start");
g_mutex_lock (&render->ass_mutex); g_mutex_lock (&render->ass_mutex);
if (render->ass_track) { if (render->ass_track) {
/* delete any events on the ass_track */ /* delete any events on the ass_track */
@ -1377,20 +1571,21 @@ gst_ass_render_event_text (GstPad * pad, GstObject * parent, GstEvent * event)
GST_DEBUG_OBJECT (render, "done flushing"); GST_DEBUG_OBJECT (render, "done flushing");
} }
g_mutex_unlock (&render->ass_mutex); g_mutex_unlock (&render->ass_mutex);
g_mutex_lock (&render->subtitle_mutex); GST_ASS_RENDER_LOCK (render);
if (render->subtitle_pending)
gst_buffer_unref (render->subtitle_pending);
render->subtitle_pending = NULL;
render->subtitle_flushing = TRUE; render->subtitle_flushing = TRUE;
g_cond_signal (&render->subtitle_cond); GST_ASS_RENDER_BROADCAST (render);
g_mutex_unlock (&render->subtitle_mutex); GST_ASS_RENDER_UNLOCK (render);
gst_event_unref (event); gst_event_unref (event);
ret = TRUE; ret = TRUE;
break; break;
case GST_EVENT_EOS: case GST_EVENT_EOS:
GST_OBJECT_LOCK (render); GST_ASS_RENDER_LOCK (render);
render->subtitle_eos = TRUE;
GST_INFO_OBJECT (render, "text EOS"); GST_INFO_OBJECT (render, "text EOS");
GST_OBJECT_UNLOCK (render); /* wake up the video chain, it might be waiting for a text buffer or
* a text segment update */
GST_ASS_RENDER_BROADCAST (render);
GST_ASS_RENDER_UNLOCK (render);
gst_event_unref (event); gst_event_unref (event);
ret = TRUE; ret = TRUE;
break; break;
@ -1403,11 +1598,11 @@ gst_ass_render_event_text (GstPad * pad, GstObject * parent, GstEvent * event)
gst_event_parse_tag (event, &taglist); gst_event_parse_tag (event, &taglist);
gst_ass_render_handle_tags (render, taglist); gst_ass_render_handle_tags (render, taglist);
ret = gst_pad_push_event (render->srcpad, event); ret = gst_pad_event_default (pad, parent, event);
break; break;
} }
default: default:
ret = gst_pad_push_event (render->srcpad, event); ret = gst_pad_event_default (pad, parent, event);
break; break;
} }

8
ext/assrender/gstassrender.h
View file

@ -55,15 +55,19 @@ struct _GstAssRender
gboolean enable, embeddedfonts; gboolean enable, embeddedfonts;
/* <private> */ /* <private> */
GMutex lock;
GCond cond;
GstSegment video_segment; GstSegment video_segment;
gboolean video_flushing;
gboolean video_eos;
GstVideoInfo info; GstVideoInfo info;
GstAssRenderBlitFunction blit; GstAssRenderBlitFunction blit;
GMutex subtitle_mutex;
GCond subtitle_cond;
GstBuffer *subtitle_pending; GstBuffer *subtitle_pending;
gboolean subtitle_flushing; gboolean subtitle_flushing;
gboolean subtitle_eos;
GstSegment subtitle_segment; GstSegment subtitle_segment;
GMutex ass_mutex; GMutex ass_mutex;