mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 05:38:58 +00:00
1394 lines
44 KiB
C
1394 lines
44 KiB
C
/*
|
|
* GStreamer
|
|
* Copyright 2005 Thomas Vander Stichele <thomas@apestaart.org>
|
|
* Copyright 2005 Ronald S. Bultje <rbultje@ronald.bitfreak.net>
|
|
* Copyright (C) 2007 Fluendo S.A. <info@fluendo.com>
|
|
* Copyright 2008, 2009 Vincent Penquerc'h <ogg.k.ogg.k@googlemail.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Alternatively, the contents of this file may be used under the
|
|
* GNU Lesser General Public License Version 2.1 (the "LGPL"), in
|
|
* which case the following provisions apply instead of the ones
|
|
* mentioned above:
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
/**
|
|
* SECTION:element-kateenc
|
|
* @title: kateenc
|
|
* @see_also: oggmux
|
|
*
|
|
* This element encodes Kate streams.
|
|
*
|
|
* [Kate](http://libkate.googlecode.com/) is a free codec for text based data,
|
|
* such as subtitles. Any number of kate streams can be embedded in an Ogg
|
|
* stream.
|
|
*
|
|
* libkate (see above url) is needed to build this plugin.
|
|
*
|
|
* ## Example pipeline
|
|
*
|
|
* This encodes a DVD SPU track to a Kate stream:
|
|
* |[
|
|
* gst-launch-1.0 dvdreadsrc ! dvddemux ! dvdsubparse ! kateenc category=spu-subtitles ! oggmux ! filesink location=test.ogg
|
|
* ]|
|
|
*
|
|
*/
|
|
|
|
/* FIXME:
|
|
* - should we automatically pick up the language code from the
|
|
* upstream event tags if none was set via the property?
|
|
* - turn category property into an enum (freestyle text property in
|
|
* combination with supposedly strictly defined known values that
|
|
* aren't even particularly human-readable is just not very nice)? */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <string.h>
|
|
|
|
#include <gst/gst.h>
|
|
#include <gst/gsttagsetter.h>
|
|
#include <gst/tag/tag.h>
|
|
|
|
#include "gstkate.h"
|
|
#include "gstkateutil.h"
|
|
#include "gstkatespu.h"
|
|
#include "gstkateenc.h"
|
|
|
|
GST_DEBUG_CATEGORY_EXTERN (gst_kateenc_debug);
|
|
#define GST_CAT_DEFAULT gst_kateenc_debug
|
|
|
|
/* Filter signals and args */
|
|
enum
|
|
{
|
|
/* FILL ME */
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum
|
|
{
|
|
ARG_0,
|
|
ARG_LANGUAGE,
|
|
ARG_CATEGORY,
|
|
ARG_GRANULE_RATE_NUM,
|
|
ARG_GRANULE_RATE_DEN,
|
|
ARG_GRANULE_SHIFT,
|
|
ARG_KEEPALIVE_MIN_TIME,
|
|
ARG_ORIGINAL_CANVAS_WIDTH,
|
|
ARG_ORIGINAL_CANVAS_HEIGHT,
|
|
ARG_DEFAULT_SPU_DURATION,
|
|
};
|
|
|
|
#define DEFAULT_KEEPALIVE_MIN_TIME 2.5f
|
|
#define DEFAULT_DEFAULT_SPU_DURATION 1.5f
|
|
|
|
static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS ("text/x-raw, format={ pango-markup, utf8 }; "
|
|
GST_KATE_SPU_MIME_TYPE)
|
|
);
|
|
|
|
static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS ("subtitle/x-kate; application/x-kate")
|
|
);
|
|
|
|
static void gst_kate_enc_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec);
|
|
static void gst_kate_enc_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec);
|
|
static void gst_kate_enc_dispose (GObject * object);
|
|
|
|
static gboolean gst_kate_enc_setcaps (GstKateEnc * ke, GstCaps * caps);
|
|
static GstFlowReturn gst_kate_enc_chain (GstPad * pad, GstObject * parent,
|
|
GstBuffer * buf);
|
|
static GstStateChangeReturn gst_kate_enc_change_state (GstElement * element,
|
|
GstStateChange transition);
|
|
static gboolean gst_kate_enc_sink_event (GstPad * pad, GstObject * parent,
|
|
GstEvent * event);
|
|
static gboolean gst_kate_enc_source_query (GstPad * pad, GstObject * parent,
|
|
GstQuery * query);
|
|
|
|
#define gst_kate_enc_parent_class parent_class
|
|
G_DEFINE_TYPE_WITH_CODE (GstKateEnc, gst_kate_enc, GST_TYPE_ELEMENT,
|
|
G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL));
|
|
|
|
/* initialize the plugin's class */
|
|
static void
|
|
gst_kate_enc_class_init (GstKateEncClass * klass)
|
|
{
|
|
GObjectClass *gobject_class;
|
|
GstElementClass *gstelement_class;
|
|
|
|
gobject_class = (GObjectClass *) klass;
|
|
gstelement_class = (GstElementClass *) klass;
|
|
|
|
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_kate_enc_set_property);
|
|
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_kate_enc_get_property);
|
|
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_kate_enc_dispose);
|
|
|
|
g_object_class_install_property (gobject_class, ARG_LANGUAGE,
|
|
g_param_spec_string ("language", "Language",
|
|
"The language of the stream (e.g. \"fr\" or \"fr_FR\" for French)",
|
|
"", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_CATEGORY,
|
|
g_param_spec_string ("category", "Category",
|
|
"The category of the stream", "",
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_GRANULE_RATE_NUM,
|
|
g_param_spec_int ("granule-rate-numerator", "Granule rate numerator",
|
|
"The numerator of the granule rate",
|
|
1, G_MAXINT, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_GRANULE_RATE_DEN,
|
|
g_param_spec_int ("granule-rate-denominator", "Granule rate denominator",
|
|
"The denominator of the granule rate",
|
|
1, G_MAXINT, 1000, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_GRANULE_SHIFT,
|
|
g_param_spec_int ("granule-shift", "Granule shift",
|
|
"The granule shift", 0, 64, 32,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_ORIGINAL_CANVAS_WIDTH,
|
|
g_param_spec_int ("original-canvas-width", "Original canvas width",
|
|
"The width of the canvas this stream was authored for (0 is unspecified)",
|
|
0, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_ORIGINAL_CANVAS_HEIGHT,
|
|
g_param_spec_int ("original-canvas-height", "Original canvas height",
|
|
"The height of the canvas this stream was authored for (0 is unspecified)",
|
|
0, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_KEEPALIVE_MIN_TIME,
|
|
g_param_spec_float ("keepalive-min-time", "Keepalive minimum time",
|
|
"Minimum time to emit keepalive packets (0 disables keepalive packets)",
|
|
0.0f, FLT_MAX, DEFAULT_KEEPALIVE_MIN_TIME,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, ARG_DEFAULT_SPU_DURATION,
|
|
g_param_spec_float ("default-spu-duration", "Default SPU duration",
|
|
"The assumed max duration (in seconds) of SPUs with no duration specified",
|
|
0.0f, FLT_MAX, DEFAULT_DEFAULT_SPU_DURATION,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
gstelement_class->change_state =
|
|
GST_DEBUG_FUNCPTR (gst_kate_enc_change_state);
|
|
|
|
gst_element_class_add_static_pad_template (gstelement_class, &src_factory);
|
|
gst_element_class_add_static_pad_template (gstelement_class, &sink_factory);
|
|
|
|
gst_element_class_set_static_metadata (gstelement_class,
|
|
"Kate stream encoder", "Codec/Encoder/Subtitle",
|
|
"Encodes Kate streams from text or subpictures",
|
|
"Vincent Penquerc'h <ogg.k.ogg.k@googlemail.com>");
|
|
}
|
|
|
|
/* initialize the new element
|
|
* instantiate pads and add them to element
|
|
* set functions
|
|
* initialize structure
|
|
*/
|
|
static void
|
|
gst_kate_enc_init (GstKateEnc * ke)
|
|
{
|
|
GST_DEBUG_OBJECT (ke, "gst_kate_enc_init");
|
|
|
|
ke->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink");
|
|
gst_pad_set_chain_function (ke->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_kate_enc_chain));
|
|
gst_pad_set_event_function (ke->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_kate_enc_sink_event));
|
|
gst_element_add_pad (GST_ELEMENT (ke), ke->sinkpad);
|
|
|
|
ke->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
|
|
gst_pad_set_query_function (ke->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_kate_enc_source_query));
|
|
gst_element_add_pad (GST_ELEMENT (ke), ke->srcpad);
|
|
|
|
ke->initialized = FALSE;
|
|
ke->headers_sent = FALSE;
|
|
ke->last_timestamp = 0;
|
|
ke->latest_end_time = 0;
|
|
ke->language = NULL;
|
|
ke->category = NULL;
|
|
ke->format = GST_KATE_FORMAT_UNDEFINED;
|
|
ke->granule_rate_numerator = 1000;
|
|
ke->granule_rate_denominator = 1;
|
|
ke->granule_shift = 32;
|
|
ke->original_canvas_width = 0;
|
|
ke->original_canvas_height = 0;
|
|
ke->keepalive_min_time = DEFAULT_KEEPALIVE_MIN_TIME;
|
|
ke->default_spu_duration = DEFAULT_DEFAULT_SPU_DURATION;
|
|
memcpy (ke->spu_clut, gst_kate_spu_default_clut,
|
|
sizeof (gst_kate_spu_default_clut));
|
|
ke->delayed_spu = FALSE;
|
|
ke->delayed_bitmap = NULL;
|
|
ke->delayed_palette = NULL;
|
|
ke->delayed_region = NULL;
|
|
}
|
|
|
|
static void
|
|
gst_kate_enc_dispose (GObject * object)
|
|
{
|
|
GstKateEnc *ke = GST_KATE_ENC (object);
|
|
|
|
GST_LOG_OBJECT (ke, "disposing");
|
|
|
|
if (ke->language) {
|
|
g_free (ke->language);
|
|
ke->language = NULL;
|
|
}
|
|
if (ke->category) {
|
|
g_free (ke->category);
|
|
ke->category = NULL;
|
|
}
|
|
|
|
GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
|
|
}
|
|
|
|
static void
|
|
gst_kate_enc_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstKateEnc *ke = GST_KATE_ENC (object);
|
|
const char *str;
|
|
|
|
switch (prop_id) {
|
|
case ARG_LANGUAGE:
|
|
if (ke->language) {
|
|
g_free (ke->language);
|
|
ke->language = NULL;
|
|
}
|
|
str = g_value_get_string (value);
|
|
if (str)
|
|
ke->language = g_strdup (str);
|
|
break;
|
|
case ARG_CATEGORY:
|
|
if (ke->category) {
|
|
g_free (ke->category);
|
|
ke->category = NULL;
|
|
}
|
|
str = g_value_get_string (value);
|
|
if (str)
|
|
ke->category = g_strdup (str);
|
|
break;
|
|
case ARG_GRANULE_RATE_NUM:
|
|
ke->granule_rate_numerator = g_value_get_int (value);
|
|
break;
|
|
case ARG_GRANULE_RATE_DEN:
|
|
ke->granule_rate_denominator = g_value_get_int (value);
|
|
break;
|
|
case ARG_GRANULE_SHIFT:
|
|
ke->granule_rate_denominator = g_value_get_int (value);
|
|
break;
|
|
case ARG_KEEPALIVE_MIN_TIME:
|
|
ke->keepalive_min_time = g_value_get_float (value);
|
|
break;
|
|
case ARG_ORIGINAL_CANVAS_WIDTH:
|
|
ke->original_canvas_width = g_value_get_int (value);
|
|
break;
|
|
case ARG_ORIGINAL_CANVAS_HEIGHT:
|
|
ke->original_canvas_height = g_value_get_int (value);
|
|
break;
|
|
case ARG_DEFAULT_SPU_DURATION:
|
|
ke->default_spu_duration = g_value_get_float (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_kate_enc_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstKateEnc *ke = GST_KATE_ENC (object);
|
|
|
|
switch (prop_id) {
|
|
case ARG_LANGUAGE:
|
|
g_value_set_string (value, ke->language ? ke->language : "");
|
|
break;
|
|
case ARG_CATEGORY:
|
|
g_value_set_string (value, ke->category ? ke->category : "");
|
|
break;
|
|
case ARG_GRANULE_RATE_NUM:
|
|
g_value_set_int (value, ke->granule_rate_numerator);
|
|
break;
|
|
case ARG_GRANULE_RATE_DEN:
|
|
g_value_set_int (value, ke->granule_rate_denominator);
|
|
break;
|
|
case ARG_GRANULE_SHIFT:
|
|
g_value_set_int (value, ke->granule_shift);
|
|
break;
|
|
case ARG_KEEPALIVE_MIN_TIME:
|
|
g_value_set_float (value, ke->keepalive_min_time);
|
|
break;
|
|
case ARG_ORIGINAL_CANVAS_WIDTH:
|
|
g_value_set_int (value, ke->original_canvas_width);
|
|
break;
|
|
case ARG_ORIGINAL_CANVAS_HEIGHT:
|
|
g_value_set_int (value, ke->original_canvas_height);
|
|
break;
|
|
case ARG_DEFAULT_SPU_DURATION:
|
|
g_value_set_float (value, ke->default_spu_duration);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* GstElement vmethod implementations */
|
|
|
|
static GstBuffer *
|
|
gst_kate_enc_create_buffer (GstKateEnc * ke, kate_packet * kp,
|
|
kate_int64_t granpos, GstClockTime timestamp, GstClockTime duration,
|
|
gboolean header)
|
|
{
|
|
GstBuffer *buffer;
|
|
|
|
g_return_val_if_fail (kp != NULL, NULL);
|
|
g_return_val_if_fail (kp->data != NULL, NULL);
|
|
|
|
buffer = gst_buffer_new_allocate (NULL, kp->nbytes, NULL);
|
|
if (G_UNLIKELY (!buffer)) {
|
|
GST_WARNING_OBJECT (ke, "Failed to allocate buffer for %u bytes",
|
|
(guint) kp->nbytes);
|
|
return NULL;
|
|
}
|
|
|
|
gst_buffer_fill (buffer, 0, kp->data, kp->nbytes);
|
|
|
|
/* same system as other Ogg codecs, as per ext/ogg/README:
|
|
OFFSET_END is the granulepos
|
|
OFFSET is its time representation
|
|
*/
|
|
GST_BUFFER_OFFSET_END (buffer) = granpos;
|
|
GST_BUFFER_OFFSET (buffer) = timestamp;
|
|
GST_BUFFER_TIMESTAMP (buffer) = timestamp;
|
|
GST_BUFFER_DURATION (buffer) = duration;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_kate_enc_push_buffer (GstKateEnc * ke, GstBuffer * buffer)
|
|
{
|
|
GstFlowReturn flow;
|
|
|
|
ke->last_timestamp = GST_BUFFER_TIMESTAMP (buffer);
|
|
if (GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer) >
|
|
ke->latest_end_time) {
|
|
ke->latest_end_time =
|
|
GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer);
|
|
}
|
|
|
|
flow = gst_pad_push (ke->srcpad, buffer);
|
|
if (G_UNLIKELY (flow != GST_FLOW_OK)) {
|
|
GST_WARNING_OBJECT (ke->srcpad, "push flow: %s", gst_flow_get_name (flow));
|
|
}
|
|
|
|
return flow;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_kate_enc_push_and_free_kate_packet (GstKateEnc * ke, kate_packet * kp,
|
|
kate_int64_t granpos, GstClockTime timestamp, GstClockTime duration,
|
|
gboolean header)
|
|
{
|
|
GstBuffer *buffer;
|
|
|
|
GST_LOG_OBJECT (ke, "Creating buffer, %u bytes", (guint) kp->nbytes);
|
|
buffer =
|
|
gst_kate_enc_create_buffer (ke, kp, granpos, timestamp, duration, header);
|
|
if (G_UNLIKELY (!buffer)) {
|
|
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
|
|
("Failed to create buffer, %u bytes", (guint) kp->nbytes));
|
|
kate_packet_clear (kp);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
kate_packet_clear (kp);
|
|
|
|
return gst_kate_enc_push_buffer (ke, buffer);
|
|
}
|
|
|
|
static void
|
|
gst_kate_enc_metadata_set1 (const GstTagList * list, const gchar * tag,
|
|
gpointer kateenc)
|
|
{
|
|
GstKateEnc *ke = GST_KATE_ENC (kateenc);
|
|
GList *vc_list, *l;
|
|
|
|
vc_list = gst_tag_to_vorbis_comments (list, tag);
|
|
|
|
for (l = vc_list; l != NULL; l = l->next) {
|
|
const gchar *vc_string = (const gchar *) l->data;
|
|
gchar *key = NULL, *val = NULL;
|
|
|
|
GST_LOG_OBJECT (ke, "Kate comment: %s", vc_string);
|
|
if (gst_tag_parse_extended_comment (vc_string, &key, NULL, &val, TRUE)) {
|
|
kate_comment_add_tag (&ke->kc, key, val);
|
|
g_free (key);
|
|
g_free (val);
|
|
}
|
|
}
|
|
|
|
g_list_foreach (vc_list, (GFunc) g_free, NULL);
|
|
g_list_free (vc_list);
|
|
}
|
|
|
|
static void
|
|
gst_kate_enc_set_metadata (GstKateEnc * ke)
|
|
{
|
|
GstTagList *merged_tags;
|
|
const GstTagList *user_tags;
|
|
|
|
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (ke));
|
|
|
|
GST_DEBUG_OBJECT (ke, "upstream tags = %" GST_PTR_FORMAT, ke->tags);
|
|
GST_DEBUG_OBJECT (ke, "user-set tags = %" GST_PTR_FORMAT, user_tags);
|
|
|
|
/* gst_tag_list_merge() will handle NULL for either or both lists fine */
|
|
merged_tags = gst_tag_list_merge (user_tags, ke->tags,
|
|
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (ke)));
|
|
|
|
if (merged_tags) {
|
|
GST_DEBUG_OBJECT (ke, "merged tags = %" GST_PTR_FORMAT, merged_tags);
|
|
gst_tag_list_foreach (merged_tags, gst_kate_enc_metadata_set1, ke);
|
|
gst_tag_list_unref (merged_tags);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_kate_enc_setcaps (GstKateEnc * ke, GstCaps * caps)
|
|
{
|
|
GST_LOG_OBJECT (ke, "input caps: %" GST_PTR_FORMAT, caps);
|
|
|
|
/* One day we could try to automatically set the category based on the
|
|
* input format, assuming that the input is subtitles. Currently that
|
|
* doesn't work yet though, because we send the header packets already from
|
|
* the sink event handler when receiving the newsegment event, so before
|
|
* the first buffer (might be tricky to change too, given that there could
|
|
* be no data at the beginning for a long time). So for now we just try to
|
|
* make sure people didn't set the category to something obviously wrong. */
|
|
if (ke->category != NULL) {
|
|
GstStructure *s = gst_caps_get_structure (caps, 0);
|
|
|
|
if (gst_structure_has_name (s, "text/x-raw")) {
|
|
const gchar *format;
|
|
|
|
format = gst_structure_get_string (s, "format");
|
|
if (strcmp (format, "utf8") == 0) {
|
|
ke->format = GST_KATE_FORMAT_TEXT_UTF8;
|
|
} else if (strcmp (format, "pango-markup") == 0) {
|
|
ke->format = GST_KATE_FORMAT_TEXT_PANGO_MARKUP;
|
|
}
|
|
|
|
if (strcmp (ke->category, "K-SPU") == 0 ||
|
|
strcmp (ke->category, "spu-subtitles") == 0) {
|
|
GST_ELEMENT_WARNING (ke, LIBRARY, SETTINGS, (NULL),
|
|
("Category set to '%s', but input is text-based.", ke->category));
|
|
}
|
|
} else if (gst_structure_has_name (s, "subpicture/x-dvd")) {
|
|
ke->format = GST_KATE_FORMAT_SPU;
|
|
if (strcmp (ke->category, "SUB") == 0 ||
|
|
strcmp (ke->category, "subtitles") == 0) {
|
|
GST_ELEMENT_WARNING (ke, LIBRARY, SETTINGS, (NULL),
|
|
("Category set to '%s', but input is subpictures.", ke->category));
|
|
}
|
|
} else {
|
|
GST_ERROR_OBJECT (ke, "unexpected input caps %" GST_PTR_FORMAT, caps);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_kate_enc_is_simple_subtitle_category (GstKateEnc * ke, const char *category)
|
|
{
|
|
static const char *const simple[] = {
|
|
"subtitles",
|
|
"SUB",
|
|
"spu-subtitles",
|
|
"K-SPU",
|
|
};
|
|
int n;
|
|
|
|
if (!category)
|
|
return FALSE;
|
|
for (n = 0; n < G_N_ELEMENTS (simple); ++n) {
|
|
if (!strcmp (category, simple[n]))
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
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 GstFlowReturn
|
|
gst_kate_enc_flush_headers (GstKateEnc * ke)
|
|
{
|
|
GstFlowReturn rflow = GST_FLOW_OK;
|
|
if (!ke->headers_sent) {
|
|
GST_INFO_OBJECT (ke, "headers not yet sent, flushing");
|
|
rflow = gst_kate_enc_send_headers (ke);
|
|
if (rflow == GST_FLOW_OK) {
|
|
ke->headers_sent = TRUE;
|
|
GST_INFO_OBJECT (ke, "headers flushed");
|
|
} else {
|
|
GST_WARNING_OBJECT (ke, "Failed to flush headers: %s",
|
|
gst_flow_get_name (rflow));
|
|
}
|
|
}
|
|
return rflow;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_kate_enc_chain_push_packet (GstKateEnc * ke, kate_packet * kp,
|
|
GstClockTime start, GstClockTime duration)
|
|
{
|
|
kate_int64_t granpos;
|
|
GstFlowReturn rflow;
|
|
|
|
granpos = kate_encode_get_granule (&ke->k);
|
|
if (G_UNLIKELY (granpos < 0)) {
|
|
GST_ELEMENT_ERROR (ke, STREAM, ENCODE, (NULL),
|
|
("Negative granpos for packet"));
|
|
kate_packet_clear (kp);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
rflow =
|
|
gst_kate_enc_push_and_free_kate_packet (ke, kp, granpos, start, duration,
|
|
FALSE);
|
|
if (G_UNLIKELY (rflow != GST_FLOW_OK)) {
|
|
GST_WARNING_OBJECT (ke, "Failed to push Kate packet");
|
|
}
|
|
return rflow;
|
|
}
|
|
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
|
|
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_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_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;
|
|
}
|
|
|
|
/* chain function
|
|
* this function does the actual processing
|
|
*/
|
|
static GstFlowReturn
|
|
gst_kate_enc_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
|
|
{
|
|
GstKateEnc *ke = GST_KATE_ENC (parent);
|
|
GstFlowReturn rflow;
|
|
|
|
GST_DEBUG_OBJECT (ke, "got packet, %" G_GSIZE_FORMAT " bytes",
|
|
gst_buffer_get_size (buf));
|
|
|
|
/* first push headers if we haven't done that yet */
|
|
rflow = gst_kate_enc_flush_headers (ke);
|
|
|
|
if (G_LIKELY (rflow == GST_FLOW_OK)) {
|
|
/* flush any packet we had waiting */
|
|
rflow = gst_kate_enc_flush_waiting (ke, GST_BUFFER_TIMESTAMP (buf));
|
|
|
|
if (G_LIKELY (rflow == GST_FLOW_OK)) {
|
|
if (ke->format == GST_KATE_FORMAT_SPU) {
|
|
/* encode a kate_bitmap */
|
|
rflow = gst_kate_enc_chain_spu (ke, buf);
|
|
} else {
|
|
/* encode text */
|
|
rflow = gst_kate_enc_chain_text (ke, buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
gst_buffer_unref (buf);
|
|
|
|
return rflow;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static GstClockTime
|
|
gst_kate_enc_granule_time (kate_state * k, gint64 granulepos)
|
|
{
|
|
float t;
|
|
|
|
if (granulepos == -1)
|
|
return -1;
|
|
|
|
t = kate_granule_time (k->ki, granulepos);
|
|
return t * GST_SECOND;
|
|
}
|
|
|
|
/*
|
|
conversions on the sink:
|
|
- nothing
|
|
conversions on the source:
|
|
- default is granules at num/den rate
|
|
- default -> time is possible
|
|
- bytes do not mean anything, packets can be any number of bytes, and we
|
|
have no way to know the number of bytes emitted without decoding
|
|
*/
|
|
|
|
static gboolean
|
|
gst_kate_enc_convert (GstPad * pad, GstFormat src_fmt, gint64 src_val,
|
|
GstFormat * dest_fmt, gint64 * dest_val)
|
|
{
|
|
GstKateEnc *ke;
|
|
gboolean res = FALSE;
|
|
|
|
if (src_fmt == *dest_fmt) {
|
|
*dest_val = src_val;
|
|
return TRUE;
|
|
}
|
|
|
|
ke = GST_KATE_ENC (gst_pad_get_parent (pad));
|
|
|
|
if (!ke->initialized) {
|
|
GST_WARNING_OBJECT (ke, "not initialized yet");
|
|
gst_object_unref (ke);
|
|
return FALSE;
|
|
}
|
|
|
|
if (src_fmt == GST_FORMAT_BYTES || *dest_fmt == GST_FORMAT_BYTES) {
|
|
GST_WARNING_OBJECT (ke, "unsupported format");
|
|
gst_object_unref (ke);
|
|
return FALSE;
|
|
}
|
|
|
|
switch (src_fmt) {
|
|
case GST_FORMAT_DEFAULT:
|
|
switch (*dest_fmt) {
|
|
case GST_FORMAT_TIME:
|
|
*dest_val = gst_kate_enc_granule_time (&ke->k, src_val);
|
|
res = TRUE;
|
|
break;
|
|
default:
|
|
res = FALSE;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
res = FALSE;
|
|
break;
|
|
}
|
|
|
|
if (!res) {
|
|
GST_WARNING_OBJECT (ke, "unsupported format");
|
|
}
|
|
|
|
gst_object_unref (ke);
|
|
return res;
|
|
}
|
|
|
|
static gboolean
|
|
gst_kate_enc_source_query (GstPad * pad, GstObject * parent, GstQuery * query)
|
|
{
|
|
gboolean res = FALSE;
|
|
|
|
GST_DEBUG ("source query %d", GST_QUERY_TYPE (query));
|
|
|
|
switch (GST_QUERY_TYPE (query)) {
|
|
case GST_QUERY_CONVERT:
|
|
{
|
|
GstFormat src_fmt, dest_fmt;
|
|
gint64 src_val, dest_val;
|
|
|
|
gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
|
|
if (!gst_kate_enc_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)) {
|
|
return gst_pad_query_default (pad, parent, query);
|
|
}
|
|
gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
|
|
res = TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
res = gst_pad_query_default (pad, parent, query);
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
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;
|
|
}
|