static GstFlowReturn
gst_kate_enc_chain_text (GstKateEnc * ke, GstBuffer * buf)
{
kate_packet kp = { 0 };
int ret = 0;
GstFlowReturn rflow;
GstClockTime start = GST_BUFFER_TIMESTAMP (buf);
GstClockTime stop = GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf);
if (ke->format == GST_KATE_FORMAT_TEXT_PANGO_MARKUP) {
ret = kate_encode_set_markup_type (&ke->k, kate_markup_simple);
} else if (ke->format == GST_KATE_FORMAT_TEXT_UTF8) {
ret = kate_encode_set_markup_type (&ke->k, kate_markup_none);
} else {
return GST_FLOW_ERROR;
}
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to set markup type: %s",
gst_kate_util_get_error_message (ret)));
rflow = GST_FLOW_ERROR;
} else {
GstMapInfo info;
gboolean need_unmap = TRUE;
kate_float t0 = start / (double) GST_SECOND;
kate_float t1 = stop / (double) GST_SECOND;
if (!gst_buffer_map (buf, &info, GST_MAP_READ)) {
info.data = NULL;
info.size = 0;
need_unmap = FALSE;
GST_WARNING_OBJECT (buf, "Failed to map buffer");
}
GST_LOG_OBJECT (ke, "Encoding text: %*.*s (%u bytes) from %f to %f",
(int) info.size, (int) info.size, info.data, (int) info.size, t0, t1);
ret = kate_encode_text (&ke->k, t0, t1, (const char *) info.data, info.size,
&kp);
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to encode text: %s", gst_kate_util_get_error_message (ret)));
rflow = GST_FLOW_ERROR;
} else {
rflow = gst_kate_enc_chain_push_packet (ke, &kp, start, stop - start + 1);
}
if (need_unmap)
gst_buffer_unmap (buf, &info);
}
return rflow;
}
GstStateChangeReturn
gst_kate_decoder_base_change_state (GstKateDecoderBase * decoder,
GstElement * element, GstElementClass * parent_class,
GstStateChange transition)
{
GstStateChangeReturn res;
int ret;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
GST_DEBUG_OBJECT (element, "READY -> PAUSED, initializing kate state");
ret = kate_high_decode_init (&decoder->k);
if (ret < 0) {
GST_WARNING_OBJECT (element, "failed to initialize kate state: %s",
gst_kate_util_get_error_message (ret));
}
gst_segment_init (&decoder->kate_segment, GST_FORMAT_UNDEFINED);
decoder->kate_flushing = FALSE;
decoder->initialized = TRUE;
decoder->event_queue = g_queue_new ();
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
res = parent_class->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
GST_DEBUG_OBJECT (element, "PAUSED -> READY, clearing kate state");
if (decoder->initialized) {
kate_high_decode_clear (&decoder->k);
decoder->initialized = FALSE;
}
gst_segment_init (&decoder->kate_segment, GST_FORMAT_UNDEFINED);
decoder->kate_flushing = TRUE;
gst_kate_util_decode_base_reset (decoder);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_kate_util_decode_base_reset (decoder);
break;
default:
break;
}
return res;
}
static void
gst_kate_enc_generate_keepalive (GstKateEnc * ke, GstClockTime timestamp)
{
kate_packet kp;
int ret;
kate_float t = timestamp / (double) GST_SECOND;
GST_DEBUG_OBJECT (ke, "keepalive at %f", t);
ret = kate_encode_keepalive (&ke->k, t, &kp);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "Failed to encode keepalive packet: %s",
gst_kate_util_get_error_message (ret));
} else {
kate_int64_t granpos = kate_encode_get_granule (&ke->k);
GST_LOG_OBJECT (ke, "Keepalive packet encoded");
if (gst_kate_enc_push_and_free_kate_packet (ke, &kp, granpos, timestamp, 0,
FALSE)) {
GST_WARNING_OBJECT (ke, "Failed to push keepalive packet");
}
}
}
GstFlowReturn
gst_kate_util_decoder_base_chain_kate_packet (GstKateDecoderBase * decoder,
GstElement * element, GstPad * pad, GstBuffer * buf, GstPad * srcpad,
GstPad * tagpad, GstCaps ** src_caps, const kate_event ** ev)
{
kate_packet kp;
int ret;
GstFlowReturn rflow = GST_FLOW_OK;
gboolean is_header;
guint8 *data;
gsize size;
guint8 header[1];
size = gst_buffer_extract (buf, 0, header, 1);
GST_DEBUG_OBJECT (element, "got kate packet, %u bytes, type %02x",
gst_buffer_get_size (buf), size == 0 ? -1 : header[0]);
is_header = size > 0 && (header[0] & 0x80);
if (!is_header && decoder->tags) {
/* after we've processed headers, send any tags before processing the data packet */
GST_DEBUG_OBJECT (element, "Not a header, sending tags for pad %s:%s",
GST_DEBUG_PAD_NAME (tagpad));
gst_element_found_tags_for_pad (element, tagpad, decoder->tags);
decoder->tags = NULL;
}
data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
kate_packet_wrap (&kp, size, data);
ret = kate_high_decode_packetin (&decoder->k, &kp, ev);
gst_buffer_unmap (buf, data, size);
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (element, STREAM, DECODE, (NULL),
("Failed to decode Kate packet: %s",
gst_kate_util_get_error_message (ret)));
return GST_FLOW_ERROR;
}
if (G_UNLIKELY (ret > 0)) {
GST_DEBUG_OBJECT (element,
"kate_high_decode_packetin has received EOS packet");
}
/* headers may be interesting to retrieve information from */
if (G_UNLIKELY (is_header)) {
switch (header[0]) {
case 0x80: /* ID header */
GST_INFO_OBJECT (element, "Parsed ID header: language %s, category %s",
decoder->k.ki->language, decoder->k.ki->category);
if (src_caps) {
if (*src_caps) {
gst_caps_unref (*src_caps);
*src_caps = NULL;
}
if (strcmp (decoder->k.ki->category, "K-SPU") == 0 ||
strcmp (decoder->k.ki->category, "spu-subtitles") == 0) {
*src_caps = gst_caps_new_empty_simple ("video/x-dvd-subpicture");
} else if (decoder->k.ki->text_markup_type == kate_markup_none) {
*src_caps = gst_caps_new_empty_simple ("text/plain");
} else {
*src_caps = gst_caps_new_empty_simple ("text/x-pango-markup");
}
GST_INFO_OBJECT (srcpad, "Setting caps: %" GST_PTR_FORMAT, *src_caps);
if (!gst_pad_set_caps (srcpad, *src_caps)) {
GST_ERROR_OBJECT (srcpad, "Failed to set caps %" GST_PTR_FORMAT,
*src_caps);
}
}
if (decoder->k.ki->language && *decoder->k.ki->language) {
GstTagList *old = decoder->tags, *tags = gst_tag_list_new_empty ();
if (tags) {
gchar *lang_code;
/* en_GB -> en */
lang_code = g_ascii_strdown (decoder->k.ki->language, -1);
g_strdelimit (lang_code, NULL, '\0');
gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_LANGUAGE_CODE,
lang_code, NULL);
g_free (lang_code);
/* TODO: category - where should it go ? */
decoder->tags =
gst_tag_list_merge (decoder->tags, tags, GST_TAG_MERGE_REPLACE);
gst_tag_list_free (tags);
if (old)
gst_tag_list_free (old);
}
}
/* update properties */
if (decoder->language)
g_free (decoder->language);
decoder->language = g_strdup (decoder->k.ki->language);
if (decoder->category)
g_free (decoder->category);
decoder->category = g_strdup (decoder->k.ki->category);
decoder->original_canvas_width = decoder->k.ki->original_canvas_width;
decoder->original_canvas_height = decoder->k.ki->original_canvas_height;
/* we can now send away any event we've delayed, as the src pad now has caps */
gst_kate_util_decoder_base_drain_event_queue (decoder);
break;
case 0x81: /* Vorbis comments header */
GST_INFO_OBJECT (element, "Parsed comments header");
{
gchar *encoder = NULL;
GstTagList *old = decoder->tags, *list =
gst_tag_list_from_vorbiscomment_buffer (buf,
(const guint8 *) "\201kate\0\0\0\0", 9, &encoder);
if (list) {
decoder->tags =
gst_tag_list_merge (decoder->tags, list, GST_TAG_MERGE_REPLACE);
gst_tag_list_free (list);
}
if (!decoder->tags) {
GST_ERROR_OBJECT (element, "failed to decode comment header");
decoder->tags = gst_tag_list_new_empty ();
}
if (encoder) {
gst_tag_list_add (decoder->tags, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER, encoder, NULL);
g_free (encoder);
}
gst_tag_list_add (decoder->tags, GST_TAG_MERGE_REPLACE,
GST_TAG_SUBTITLE_CODEC, "Kate", NULL);
gst_tag_list_add (decoder->tags, GST_TAG_MERGE_REPLACE,
GST_TAG_ENCODER_VERSION, decoder->k.ki->bitstream_version_major,
NULL);
if (old)
gst_tag_list_free (old);
if (decoder->initialized) {
gst_element_found_tags_for_pad (element, tagpad, decoder->tags);
decoder->tags = NULL;
} else {
/* Only push them as messages for the time being. *
* They will be pushed on the pad once the decoder is initialized */
gst_element_post_message (element,
gst_message_new_tag (GST_OBJECT (element),
gst_tag_list_copy (decoder->tags)));
}
}
break;
default:
break;
}
}
#if ((KATE_VERSION_MAJOR<<16)|(KATE_VERSION_MINOR<<8)|KATE_VERSION_PATCH) >= 0x000400
else if (*ev && (*ev)->meta) {
int count = kate_meta_query_count ((*ev)->meta);
if (count > 0) {
GstTagList *evtags = gst_tag_list_new_empty ();
int idx;
GST_DEBUG_OBJECT (decoder, "Kate event has %d attached metadata", count);
for (idx = 0; idx < count; ++idx) {
const char *tag, *value;
size_t len;
if (kate_meta_query ((*ev)->meta, idx, &tag, &value, &len) < 0) {
GST_WARNING_OBJECT (decoder, "Failed to retrieve metadata %d", idx);
} else {
if (gst_kate_util_is_utf8_string (value, len)) {
gchar *compound = g_strdup_printf ("%s=%s", tag, value);
GST_DEBUG_OBJECT (decoder, "Metadata %d: %s=%s (%zu bytes)", idx,
tag, value, len);
gst_tag_list_add (evtags, GST_TAG_MERGE_APPEND,
GST_TAG_EXTENDED_COMMENT, compound, NULL);
g_free (compound);
} else {
GST_INFO_OBJECT (decoder,
"Metadata %d, (%s, %zu bytes) is binary, ignored", idx, tag,
len);
}
}
}
if (gst_tag_list_is_empty (evtags))
gst_tag_list_free (evtags);
else
gst_element_found_tags_for_pad (element, tagpad, evtags);
}
}
#endif
return rflow;
}
static GstFlowReturn
gst_kate_parse_push_headers (GstKateParse * parse)
{
/* mark and put on caps */
GstCaps *caps;
GstBuffer *outbuf;
kate_packet packet;
GList *headers, *outbuf_list = NULL;
int ret;
gboolean res;
/* get the headers into the caps, passing them to kate as we go */
caps =
gst_kate_util_set_header_on_caps (&parse->element,
gst_pad_get_current_caps (parse->sinkpad), parse->streamheader);
if (G_UNLIKELY (!caps)) {
GST_ELEMENT_ERROR (parse, STREAM, DECODE, (NULL),
("Failed to set headers on caps"));
return GST_FLOW_ERROR;
}
GST_DEBUG_OBJECT (parse, "here are the caps: %" GST_PTR_FORMAT, caps);
res = gst_pad_set_caps (parse->srcpad, caps);
gst_caps_unref (caps);
if (G_UNLIKELY (!res)) {
GST_WARNING_OBJECT (parse->srcpad, "Failed to set caps on source pad");
return GST_FLOW_NOT_NEGOTIATED;
}
headers = parse->streamheader;
while (headers) {
GstMapInfo info;
outbuf = GST_BUFFER_CAST (headers->data);
if (!gst_buffer_map (outbuf, &info, GST_MAP_READ)) {
GST_WARNING_OBJECT (outbuf, "Failed to map buffer");
continue;
}
kate_packet_wrap (&packet, info.size, info.data);
ret = kate_decode_headerin (&parse->ki, &parse->kc, &packet);
if (G_UNLIKELY (ret < 0)) {
GST_WARNING_OBJECT (parse, "Failed to decode header: %s",
gst_kate_util_get_error_message (ret));
}
gst_buffer_unmap (outbuf, &info);
/* takes ownership of outbuf, which was previously in parse->streamheader */
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_HEADER);
outbuf_list = g_list_append (outbuf_list, outbuf);
headers = headers->next;
}
/* first process queued events */
gst_kate_parse_drain_event_queue (parse);
/* push out buffers, ignoring return value... */
headers = outbuf_list;
while (headers) {
outbuf = GST_BUFFER_CAST (headers->data);
gst_pad_push (parse->srcpad, outbuf);
headers = headers->next;
}
g_list_free (outbuf_list);
g_list_free (parse->streamheader);
parse->streamheader = NULL;
parse->streamheader_sent = TRUE;
return GST_FLOW_OK;
}
static GstFlowReturn
gst_kate_enc_chain_spu (GstKateEnc * ke, GstBuffer * buf)
{
kate_packet kp;
kate_region *kregion;
kate_bitmap *kbitmap;
kate_palette *kpalette;
GstFlowReturn rflow;
int ret = 0;
GstClockTime start, stop;
kate_float t0, t1;
/* allocate region, bitmap, and palette, in case we have to delay encoding them */
kregion = (kate_region *) g_malloc (sizeof (kate_region));
kbitmap = (kate_bitmap *) g_malloc (sizeof (kate_bitmap));
kpalette = (kate_palette *) g_malloc (sizeof (kate_palette));
if (!kregion || !kpalette || !kbitmap) {
g_free (kregion);
g_free (kbitmap);
g_free (kpalette);
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL), ("Out of memory"));
return GST_FLOW_ERROR;
}
rflow = gst_kate_spu_decode_spu (ke, buf, kregion, kbitmap, kpalette);
if (G_UNLIKELY (rflow != GST_FLOW_OK)) {
GST_ERROR_OBJECT (ke, "Failed to decode incoming SPU");
#if 0
{
static int spu_count = 0;
FILE *f;
char name[32];
snprintf (name, sizeof (name), "/tmp/bad_spu_%04d", spu_count++);
name[sizeof (name) - 1] = 0;
f = fopen (name, "w");
if (f) {
fwrite (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), 1, f);
fclose (f);
}
}
#endif
goto beach;
}
if (G_UNLIKELY (kbitmap->width == 0 || kbitmap->height == 0)) {
/* there are some DVDs (well, at least one) where some dimwits put in a wholly transparent full screen 720x576 SPU !!!!?! */
GST_WARNING_OBJECT (ke, "SPU is totally invisible - dimwits");
rflow = GST_FLOW_OK;
goto beach;
}
/* timestamp offsets are hidden in the SPU packets */
start = GST_BUFFER_TIMESTAMP (buf) + GST_KATE_STM_TO_GST (ke->show_time);
stop = GST_BUFFER_TIMESTAMP (buf) + GST_KATE_STM_TO_GST (ke->hide_time);
t0 = start / (double) GST_SECOND;
t1 = stop / (double) GST_SECOND;
GST_DEBUG_OBJECT (ke, "buf ts %f, start/show %hu/%hu",
GST_BUFFER_TIMESTAMP (buf) / (double) GST_SECOND, ke->show_time,
ke->hide_time);
#if 0
{
static int spu_count = 0;
FILE *f;
char name[32];
snprintf (name, sizeof (name), "/tmp/spu_%04d", spu_count++);
name[sizeof (name) - 1] = 0;
f = fopen (name, "w");
if (f) {
fwrite (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), 1, f);
fclose (f);
}
}
#endif
GST_DEBUG_OBJECT (ke, "Encoding %" G_GSIZE_FORMAT "x%" G_GSIZE_FORMAT
" SPU: (%" G_GSIZE_FORMAT " bytes) from %f to %f",
kbitmap->width, kbitmap->height, gst_buffer_get_size (buf), t0, t1);
ret = kate_encode_set_region (&ke->k, kregion);
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to set region: %s", gst_kate_util_get_error_message (ret)));
goto error_return;
}
ret = kate_encode_set_palette (&ke->k, kpalette);
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to set palette: %s", gst_kate_util_get_error_message (ret)));
goto error_return;
}
ret = kate_encode_set_bitmap (&ke->k, kbitmap);
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to set bitmap: %s", gst_kate_util_get_error_message (ret)));
goto error_return;
}
/* Some SPUs have no hide time - so I'm going to delay the encoding of the packet
till either a suitable event happens, and the time of this event will be used
as the end time of this SPU, which will then be encoded and sent off. Suitable
events are the arrival of a subsequent SPU (eg, this SPU will replace the one
with no end), EOS, a new segment event, or a time threshold being reached */
if (ke->hide_time <= ke->show_time) {
GST_INFO_OBJECT (ke,
"Cannot encode SPU packet now, hide time is now known (starting at %f) - delaying",
t0);
ke->delayed_spu = TRUE;
ke->delayed_start = start;
ke->delayed_bitmap = kbitmap;
ke->delayed_palette = kpalette;
ke->delayed_region = kregion;
rflow = GST_FLOW_OK;
goto beach;
}
ret = kate_encode_text (&ke->k, t0, t1, "", 0, &kp);
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to encode empty text for SPU buffer: %s",
gst_kate_util_get_error_message (ret)));
goto error_return;
}
rflow = gst_kate_enc_chain_push_packet (ke, &kp, start, stop - start + 1);
beach:
/* Cleanup data if we're not keeping it around */
if (!ke->delayed_spu) {
g_free (kpalette->colors);
g_free (kpalette);
g_free (kbitmap->pixels);
g_free (kbitmap);
g_free (kregion);
}
return rflow;
error_return:
{
rflow = GST_FLOW_ERROR;
goto beach;
}
}
static GstFlowReturn
gst_kate_enc_flush_waiting (GstKateEnc * ke, GstClockTime now)
{
GstFlowReturn rflow = GST_FLOW_OK;
if (ke->delayed_spu) {
int ret;
kate_packet kp;
GstClockTime keepalive_time;
kate_float t0 = ke->delayed_start / (double) GST_SECOND;
kate_float t1 = now / (double) GST_SECOND;
GST_INFO_OBJECT (ke,
"We had a delayed SPU packet starting at %f, flushing at %f (assumed duration %f)",
t0, t1, t1 - t0);
ret = kate_encode_text (&ke->k, t0, t1, "", 0, &kp);
if (G_UNLIKELY (ret < 0)) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to encode text packet: %s",
gst_kate_util_get_error_message (ret)));
rflow = GST_FLOW_ERROR;
} else {
rflow =
gst_kate_enc_chain_push_packet (ke, &kp, ke->delayed_start,
now - ke->delayed_start + 1);
}
if (rflow == GST_FLOW_OK) {
GST_DEBUG_OBJECT (ke, "delayed SPU packet flushed");
} else {
GST_WARNING_OBJECT (ke, "Failed to flush delayed SPU packet: %s",
gst_flow_get_name (rflow));
}
/* forget it even if we couldn't flush it */
ke->delayed_spu = FALSE;
/* free the delayed data */
g_free (ke->delayed_bitmap->pixels);
g_free (ke->delayed_bitmap);
ke->delayed_bitmap = NULL;
g_free (ke->delayed_palette->colors);
g_free (ke->delayed_palette);
ke->delayed_palette = NULL;
g_free (ke->delayed_region);
ke->delayed_region = NULL;
/* now that we've flushed the packet, we want to insert keepalives as requested */
if (ke->keepalive_min_time > 0.0f && t1 > t0) {
GST_INFO_OBJECT (ke, "generating keepalives at %f from %f to %f",
ke->keepalive_min_time, t0, t1);
for (keepalive_time = ke->delayed_start;
(keepalive_time += ke->keepalive_min_time * GST_SECOND) < now;) {
GST_INFO_OBJECT (ke, "generating keepalive at %f",
keepalive_time / (double) GST_SECOND);
gst_kate_enc_generate_keepalive (ke, keepalive_time);
}
}
}
return rflow;
}
static GstFlowReturn
gst_kate_enc_send_headers (GstKateEnc * ke)
{
GstFlowReturn rflow = GST_FLOW_OK;
GstCaps *caps;
GList *headers = NULL, *item;
if (G_UNLIKELY (ke->category == NULL || *ke->category == '\0')) {
/* The error code is a bit of a lie, but seems most appropriate. */
GST_ELEMENT_ERROR (ke, LIBRARY, SETTINGS, (NULL),
("The 'category' property must be set. For subtitles, set it to "
"either 'SUB' (text subtitles) or 'K-SPU' (dvd-style subtitles)"));
return GST_FLOW_ERROR;
}
gst_kate_enc_set_metadata (ke);
/* encode headers and store them in a list */
while (1) {
kate_packet kp;
int ret = kate_encode_headers (&ke->k, &ke->kc, &kp);
if (ret == 0) {
GstBuffer *buffer;
buffer = gst_kate_enc_create_buffer (ke, &kp, 0, 0, 0, TRUE);
if (!buffer) {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed to create buffer, %u bytes", (guint) kp.nbytes));
rflow = GST_FLOW_ERROR;
break;
}
kate_packet_clear (&kp);
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_HEADER);
headers = g_list_append (headers, buffer);
} else if (ret > 0) {
GST_LOG_OBJECT (ke, "Last header encoded");
break;
} else {
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
("Failed encoding headers: %s",
gst_kate_util_get_error_message (ret)));
rflow = GST_FLOW_ERROR;
break;
}
}
if (rflow == GST_FLOW_OK) {
if (gst_kate_enc_is_simple_subtitle_category (ke, ke->category)) {
caps = gst_kate_util_set_header_on_caps (&ke->element,
gst_caps_from_string ("subtitle/x-kate"), headers);
} else {
caps = gst_kate_util_set_header_on_caps (&ke->element,
gst_caps_from_string ("application/x-kate"), headers);
}
if (caps) {
GST_DEBUG_OBJECT (ke, "here are the caps: %" GST_PTR_FORMAT, caps);
gst_pad_set_caps (ke->srcpad, caps);
gst_caps_unref (caps);
if (ke->pending_segment)
gst_pad_push_event (ke->srcpad, ke->pending_segment);
ke->pending_segment = NULL;
GST_LOG_OBJECT (ke, "pushing headers");
item = headers;
while (item) {
GstBuffer *buffer = item->data;
GST_LOG_OBJECT (ke, "pushing header %p", buffer);
gst_kate_enc_push_buffer (ke, buffer);
item = item->next;
}
} else {
GST_ERROR_OBJECT (ke, "Failed to set headers on caps");
}
}
g_list_free (headers);
return rflow;
}
static gboolean
gst_kate_enc_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstKateEnc *ke = GST_KATE_ENC (parent);
const GstStructure *structure;
gboolean ret;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:
{
GstCaps *caps;
gst_event_parse_caps (event, &caps);
ret = gst_kate_enc_setcaps (ke, caps);
gst_event_unref (event);
break;
}
case GST_EVENT_SEGMENT:{
GstSegment seg;
GST_LOG_OBJECT (ke, "Got newsegment event");
gst_event_copy_segment (event, &seg);
if (!ke->headers_sent) {
if (ke->pending_segment)
gst_event_unref (ke->pending_segment);
ke->pending_segment = event;
event = NULL;
}
if (ke->initialized) {
GST_LOG_OBJECT (ke, "ensuring all headers are in");
if (gst_kate_enc_flush_headers (ke) != GST_FLOW_OK) {
GST_WARNING_OBJECT (ke, "Failed to flush headers");
} else {
if (seg.format != GST_FORMAT_TIME
|| !GST_CLOCK_TIME_IS_VALID (seg.start)) {
GST_WARNING_OBJECT (ke,
"No time in newsegment event %p, format %d, timestamp %"
G_GINT64_FORMAT, event, (int) seg.format, seg.start);
/* to be safe, we'd need to generate a keepalive anyway, but we'd have to guess at the timestamp to use; a
good guess would be the last known timestamp plus the keepalive time, but if we then get a packet with a
timestamp less than this, it would fail to encode, which would be Bad. If we don't encode a keepalive, we
run the risk of stalling the pipeline and hanging, which is Very Bad. Oh dear. We can't exit(-1), can we ? */
} else {
float t = seg.start / (double) GST_SECOND;
if (ke->delayed_spu
&& t - ke->delayed_start / (double) GST_SECOND >=
ke->default_spu_duration) {
if (G_UNLIKELY (gst_kate_enc_flush_waiting (ke,
seg.start) != GST_FLOW_OK)) {
GST_WARNING_OBJECT (ke, "Failed to encode delayed packet");
/* continue with new segment handling anyway */
}
}
GST_LOG_OBJECT (ke, "ts %f, last %f (min %f)", t,
ke->last_timestamp / (double) GST_SECOND,
ke->keepalive_min_time);
if (ke->keepalive_min_time > 0.0f
&& t - ke->last_timestamp / (double) GST_SECOND >=
ke->keepalive_min_time) {
/* we only generate a keepalive if there is no SPU waiting, as it would
mean out of sequence start times - and granulepos */
if (!ke->delayed_spu) {
gst_kate_enc_generate_keepalive (ke, seg.start);
}
}
}
}
}
if (event)
ret = gst_pad_push_event (ke->srcpad, event);
else
ret = TRUE;
break;
}
case GST_EVENT_CUSTOM_DOWNSTREAM:
GST_LOG_OBJECT (ke, "Got custom downstream event");
/* adapted from the dvdsubdec element */
structure = gst_event_get_structure (event);
if (structure != NULL
&& gst_structure_has_name (structure, "application/x-gst-dvd")) {
if (ke->initialized) {
GST_LOG_OBJECT (ke, "ensuring all headers are in");
if (gst_kate_enc_flush_headers (ke) != GST_FLOW_OK) {
GST_WARNING_OBJECT (ke, "Failed to flush headers");
} else {
const gchar *event_name =
gst_structure_get_string (structure, "event");
if (event_name) {
if (!strcmp (event_name, "dvd-spu-clut-change")) {
gchar name[16];
int idx;
gboolean found;
gint value;
GST_INFO_OBJECT (ke, "New CLUT received");
for (idx = 0; idx < 16; ++idx) {
g_snprintf (name, sizeof (name), "clut%02d", idx);
found = gst_structure_get_int (structure, name, &value);
if (found) {
ke->spu_clut[idx] = value;
} else {
GST_WARNING_OBJECT (ke,
"DVD CLUT event did not contain %s field", name);
}
}
} else if (!strcmp (event_name, "dvd-lang-codes")) {
/* we can't know which stream corresponds to us */
}
} else {
GST_WARNING_OBJECT (ke, "custom downstream event with no name");
}
}
}
}
ret = gst_pad_push_event (ke->srcpad, event);
break;
case GST_EVENT_TAG:
GST_LOG_OBJECT (ke, "Got tag event");
if (ke->tags) {
GstTagList *list;
gst_event_parse_tag (event, &list);
gst_tag_list_insert (ke->tags, list,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (ke)));
} else {
g_assert_not_reached ();
}
ret = gst_pad_event_default (pad, parent, event);
break;
case GST_EVENT_EOS:
GST_INFO_OBJECT (ke, "Got EOS event");
if (ke->initialized) {
GST_LOG_OBJECT (ke, "ensuring all headers are in");
if (gst_kate_enc_flush_headers (ke) != GST_FLOW_OK) {
GST_WARNING_OBJECT (ke, "Failed to flush headers");
} else {
kate_packet kp;
int ret;
GstClockTime delayed_end =
ke->delayed_start + ke->default_spu_duration * GST_SECOND;
if (G_UNLIKELY (gst_kate_enc_flush_waiting (ke,
delayed_end) != GST_FLOW_OK)) {
GST_WARNING_OBJECT (ke, "Failed to encode delayed packet");
/* continue with EOS handling anyway */
}
ret = kate_encode_finish (&ke->k, -1, &kp);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "Failed to encode EOS packet: %s",
gst_kate_util_get_error_message (ret));
} else {
kate_int64_t granpos = kate_encode_get_granule (&ke->k);
GST_LOG_OBJECT (ke, "EOS packet encoded");
if (gst_kate_enc_push_and_free_kate_packet (ke, &kp, granpos,
ke->latest_end_time, 0, FALSE)) {
GST_WARNING_OBJECT (ke, "Failed to push EOS packet");
}
}
}
}
ret = gst_pad_event_default (pad, parent, event);
break;
default:
GST_LOG_OBJECT (ke, "Got unhandled event");
ret = gst_pad_event_default (pad, parent, event);
break;
}
return ret;
}
static GstStateChangeReturn
gst_kate_enc_change_state (GstElement * element, GstStateChange transition)
{
GstKateEnc *ke = GST_KATE_ENC (element);
GstStateChangeReturn res;
int ret;
GST_INFO_OBJECT (ke, "gst_kate_enc_change_state");
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
ke->tags = gst_tag_list_new_empty ();
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
GST_DEBUG_OBJECT (ke, "READY -> PAUSED, initializing kate state");
ret = kate_info_init (&ke->ki);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "failed to initialize kate info structure: %s",
gst_kate_util_get_error_message (ret));
break;
}
if (ke->language) {
ret = kate_info_set_language (&ke->ki, ke->language);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "failed to set stream language: %s",
gst_kate_util_get_error_message (ret));
break;
}
}
if (ke->category) {
ret = kate_info_set_category (&ke->ki, ke->category);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "failed to set stream category: %s",
gst_kate_util_get_error_message (ret));
break;
}
}
ret =
kate_info_set_original_canvas_size (&ke->ki,
ke->original_canvas_width, ke->original_canvas_height);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "failed to set original canvas size: %s",
gst_kate_util_get_error_message (ret));
break;
}
ret = kate_comment_init (&ke->kc);
if (ret < 0) {
GST_WARNING_OBJECT (ke,
"failed to initialize kate comment structure: %s",
gst_kate_util_get_error_message (ret));
break;
}
ret = kate_encode_init (&ke->k, &ke->ki);
if (ret < 0) {
GST_WARNING_OBJECT (ke, "failed to initialize kate state: %s",
gst_kate_util_get_error_message (ret));
break;
}
ke->headers_sent = FALSE;
ke->initialized = TRUE;
ke->last_timestamp = 0;
ke->latest_end_time = 0;
ke->format = GST_KATE_FORMAT_UNDEFINED;
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_tag_list_unref (ke->tags);
ke->tags = NULL;
break;
default:
break;
}
res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (res == GST_STATE_CHANGE_FAILURE) {
GST_WARNING_OBJECT (ke, "Parent failed to change state");
return res;
}
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
GST_DEBUG_OBJECT (ke, "PAUSED -> READY, clearing kate state");
if (ke->initialized) {
kate_clear (&ke->k);
kate_info_clear (&ke->ki);
kate_comment_clear (&ke->kc);
ke->initialized = FALSE;
ke->last_timestamp = 0;
ke->latest_end_time = 0;
}
gst_event_replace (&ke->pending_segment, NULL);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
default:
break;
}
GST_DEBUG_OBJECT (ke, "State change done");
return res;
}
