mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 05:38:58 +00:00
c1d34b8acf
Original commit message from CVS: 2005-07-01 Andy Wingo <wingo@pobox.com> * tests/network-clock.scm: Commentary update. * gst/elements/gstidentity.c (PROP_DUPLICATE): Gone daddy gone. Didn't really make sense, not implementable with basetransform, etc. (gst_identity_transform): Unref inbuf via make_writable. Feeble attempt at implementing the sync property, needs an unlock method. * gst/base/gstbasetransform.c (gst_base_transform_transform_caps): New func, by default returns the same caps (the identity transformation). (gst_base_transform_getcaps): Uses transform_caps to return something sensible. (gst_base_transform_setcaps): Complicated logic to get caps on both pads, even if they are different, and to call set_caps once for every time both pads get their caps set. (gst_base_transform_handle_buffer): Give the ref to the transform function. Allows in-place modification of the buffer. * gst/base/gstbasetransform.h (transform_caps): New class method. Given caps on one side, what can I do on the other. (set_caps): Take two caps, one for each side of the element. * gst/gstpad.h: * gst/gstpad.c (gst_pad_fixate_caps): Change prototype to modify caps in place. This is safe because we can check the mutability of the caps, and a good idea because fixate functions are just called as a matter of last resort. (Not actually implemented.) (gst_pad_set_caps): If the caps we're setting is actually the same as the existing pad caps, just update the pointer without calling setcaps. Assert that caps is either NULL or fixed, as per the docs. * gst/gstghostpad.c: Update for fixate changes.
513 lines
13 KiB
C
513 lines
13 KiB
C
/* GStreamer
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
* 2005 Wim Taymans <wim@fluendo.com>
|
|
*
|
|
* gstbasetransform.c:
|
|
*
|
|
* 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., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include "../gst-i18n-lib.h"
|
|
#include "gstbasetransform.h"
|
|
#include <gst/gstmarshal.h>
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (gst_base_transform_debug);
|
|
#define GST_CAT_DEFAULT gst_base_transform_debug
|
|
|
|
/* BaseTransform signals and args */
|
|
enum
|
|
{
|
|
SIGNAL_HANDOFF,
|
|
/* FILL ME */
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
};
|
|
|
|
static GstElementClass *parent_class = NULL;
|
|
|
|
static void gst_base_transform_base_init (gpointer g_class);
|
|
static void gst_base_transform_class_init (GstBaseTransformClass * klass);
|
|
static void gst_base_transform_init (GstBaseTransform * trans,
|
|
gpointer g_class);
|
|
|
|
GType
|
|
gst_base_transform_get_type (void)
|
|
{
|
|
static GType base_transform_type = 0;
|
|
|
|
if (!base_transform_type) {
|
|
static const GTypeInfo base_transform_info = {
|
|
sizeof (GstBaseTransformClass),
|
|
(GBaseInitFunc) gst_base_transform_base_init,
|
|
NULL,
|
|
(GClassInitFunc) gst_base_transform_class_init,
|
|
NULL,
|
|
NULL,
|
|
sizeof (GstBaseTransform),
|
|
0,
|
|
(GInstanceInitFunc) gst_base_transform_init,
|
|
};
|
|
|
|
base_transform_type = g_type_register_static (GST_TYPE_ELEMENT,
|
|
"GstBaseTransform", &base_transform_info, G_TYPE_FLAG_ABSTRACT);
|
|
}
|
|
return base_transform_type;
|
|
}
|
|
|
|
static void gst_base_transform_finalize (GObject * object);
|
|
static void gst_base_transform_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec);
|
|
static void gst_base_transform_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec);
|
|
static gboolean gst_base_transform_src_activate_pull (GstPad * pad,
|
|
gboolean active);
|
|
static gboolean gst_base_transform_sink_activate_push (GstPad * pad,
|
|
gboolean active);
|
|
static GstElementStateReturn gst_base_transform_change_state (GstElement *
|
|
element);
|
|
|
|
static gboolean gst_base_transform_event (GstPad * pad, GstEvent * event);
|
|
static GstFlowReturn gst_base_transform_getrange (GstPad * pad, guint64 offset,
|
|
guint length, GstBuffer ** buffer);
|
|
static GstFlowReturn gst_base_transform_chain (GstPad * pad,
|
|
GstBuffer * buffer);
|
|
static GstFlowReturn gst_base_transform_handle_buffer (GstBaseTransform * trans,
|
|
GstBuffer * inbuf, GstBuffer ** outbuf);
|
|
static GstCaps *gst_base_transform_getcaps (GstPad * pad);
|
|
static gboolean gst_base_transform_setcaps (GstPad * pad, GstCaps * caps);
|
|
|
|
/* static guint gst_base_transform_signals[LAST_SIGNAL] = { 0 }; */
|
|
|
|
static void
|
|
gst_base_transform_base_init (gpointer g_class)
|
|
{
|
|
GST_DEBUG_CATEGORY_INIT (gst_base_transform_debug, "basetransform", 0,
|
|
"basetransform element");
|
|
}
|
|
|
|
static void
|
|
gst_base_transform_finalize (GObject * object)
|
|
{
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_base_transform_class_init (GstBaseTransformClass * klass)
|
|
{
|
|
GObjectClass *gobject_class;
|
|
GstElementClass *gstelement_class;
|
|
|
|
gobject_class = G_OBJECT_CLASS (klass);
|
|
gstelement_class = GST_ELEMENT_CLASS (klass);
|
|
|
|
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
|
|
|
|
gobject_class->set_property =
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_set_property);
|
|
gobject_class->get_property =
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_get_property);
|
|
|
|
gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_base_transform_finalize);
|
|
|
|
gstelement_class->change_state =
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_change_state);
|
|
}
|
|
|
|
static void
|
|
gst_base_transform_init (GstBaseTransform * trans, gpointer g_class)
|
|
{
|
|
GstPadTemplate *pad_template;
|
|
|
|
GST_DEBUG ("gst_base_transform_init");
|
|
|
|
pad_template =
|
|
gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "sink");
|
|
g_return_if_fail (pad_template != NULL);
|
|
trans->sinkpad = gst_pad_new_from_template (pad_template, "sink");
|
|
gst_pad_set_getcaps_function (trans->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_getcaps));
|
|
gst_pad_set_setcaps_function (trans->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_setcaps));
|
|
gst_pad_set_event_function (trans->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_event));
|
|
gst_pad_set_chain_function (trans->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_chain));
|
|
gst_pad_set_activatepush_function (trans->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_sink_activate_push));
|
|
gst_element_add_pad (GST_ELEMENT (trans), trans->sinkpad);
|
|
|
|
pad_template =
|
|
gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");
|
|
g_return_if_fail (pad_template != NULL);
|
|
trans->srcpad = gst_pad_new_from_template (pad_template, "src");
|
|
gst_pad_set_getcaps_function (trans->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_getcaps));
|
|
gst_pad_set_setcaps_function (trans->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_setcaps));
|
|
gst_pad_set_getrange_function (trans->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_getrange));
|
|
gst_pad_set_activatepull_function (trans->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_base_transform_src_activate_pull));
|
|
gst_element_add_pad (GST_ELEMENT (trans), trans->srcpad);
|
|
}
|
|
|
|
static GstCaps *
|
|
gst_base_transform_transform_caps (GstBaseTransform * trans, GstPad * pad,
|
|
GstCaps * caps)
|
|
{
|
|
GstBaseTransformClass *klass;
|
|
|
|
klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
|
|
|
|
if (klass->transform_caps)
|
|
return klass->transform_caps (trans, pad, caps);
|
|
else
|
|
return gst_caps_ref (caps);
|
|
}
|
|
|
|
static GstCaps *
|
|
gst_base_transform_getcaps (GstPad * pad)
|
|
{
|
|
GstBaseTransform *trans;
|
|
GstPad *otherpad;
|
|
GstCaps *caps;
|
|
|
|
trans = GST_BASE_TRANSFORM (GST_PAD_PARENT (pad));
|
|
|
|
otherpad = (pad == trans->srcpad) ? trans->sinkpad : trans->srcpad;
|
|
|
|
/* we can do what the peer can */
|
|
caps = gst_pad_peer_get_caps (otherpad);
|
|
|
|
if (caps) {
|
|
GstCaps *temp;
|
|
|
|
temp = gst_base_transform_transform_caps (trans, otherpad, caps);
|
|
gst_caps_unref (caps);
|
|
caps = gst_caps_intersect (temp, gst_pad_get_pad_template_caps (pad));
|
|
gst_caps_unref (temp);
|
|
} else {
|
|
/* no peer, our padtemplate is enough then */
|
|
caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
|
|
}
|
|
|
|
return caps;
|
|
}
|
|
|
|
static gboolean
|
|
gst_base_transform_setcaps (GstPad * pad, GstCaps * caps)
|
|
{
|
|
GstBaseTransform *trans;
|
|
GstBaseTransformClass *klass;
|
|
GstStructure *structure;
|
|
GstPad *otherpad, *otherpeer;
|
|
gboolean ret = TRUE;
|
|
|
|
trans = GST_BASE_TRANSFORM (GST_PAD_PARENT (pad));
|
|
klass = GST_BASE_TRANSFORM_GET_CLASS (trans);
|
|
|
|
otherpad = (pad == trans->srcpad) ? trans->sinkpad : trans->srcpad;
|
|
otherpeer = gst_pad_get_peer (otherpad);
|
|
|
|
if (GST_PAD_IS_IN_SETCAPS (otherpad))
|
|
goto done;
|
|
|
|
if (otherpeer == NULL || gst_pad_accept_caps (otherpeer, caps)) {
|
|
|
|
/* the peer accepts the caps as they are */
|
|
gst_pad_set_caps (otherpad, caps);
|
|
|
|
/* let the element know */
|
|
if (klass->set_caps)
|
|
klass->set_caps (trans, caps, caps);
|
|
|
|
ret = TRUE;
|
|
} else {
|
|
GstCaps *peercaps;
|
|
GstCaps *intersect;
|
|
GstCaps *transform = NULL;
|
|
GstCaps *othercaps;
|
|
|
|
ret = FALSE;
|
|
|
|
/* other pad has a peer, so we have to figure out how to do the conversion
|
|
*/
|
|
/* see how we can transform the input caps */
|
|
transform = gst_base_transform_transform_caps (trans, pad, caps);
|
|
|
|
if (!transform)
|
|
goto done;
|
|
|
|
/* see what the peer can do */
|
|
peercaps = gst_pad_get_caps (otherpeer);
|
|
|
|
GST_DEBUG ("icaps %" GST_PTR_FORMAT, peercaps);
|
|
GST_DEBUG ("transform %" GST_PTR_FORMAT, transform);
|
|
|
|
/* filter against our possibilities */
|
|
intersect = gst_caps_intersect (peercaps, transform);
|
|
gst_caps_unref (peercaps);
|
|
gst_caps_unref (transform);
|
|
|
|
GST_DEBUG ("intersect %" GST_PTR_FORMAT, intersect);
|
|
|
|
/* take first possibility */
|
|
othercaps = gst_caps_copy_nth (intersect, 0);
|
|
gst_caps_unref (intersect);
|
|
structure = gst_caps_get_structure (othercaps, 0);
|
|
|
|
/* and fixate if necessary */
|
|
gst_pad_fixate_caps (otherpad, othercaps);
|
|
|
|
g_return_val_if_fail (gst_caps_is_fixed (othercaps), FALSE);
|
|
|
|
gst_pad_set_caps (otherpad, othercaps);
|
|
|
|
/* let the element know */
|
|
if (klass->set_caps) {
|
|
if (pad == trans->sinkpad) {
|
|
klass->set_caps (trans, caps, othercaps);
|
|
} else {
|
|
klass->set_caps (trans, othercaps, caps);
|
|
}
|
|
}
|
|
|
|
ret = TRUE;
|
|
}
|
|
|
|
done:
|
|
|
|
if (otherpeer)
|
|
gst_object_unref (otherpeer);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_base_transform_event (GstPad * pad, GstEvent * event)
|
|
{
|
|
GstBaseTransform *trans;
|
|
GstBaseTransformClass *bclass;
|
|
gboolean ret = FALSE;
|
|
gboolean unlock;
|
|
|
|
trans = GST_BASE_TRANSFORM (GST_PAD_PARENT (pad));
|
|
bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
|
|
|
|
if (bclass->event)
|
|
bclass->event (trans, event);
|
|
|
|
unlock = FALSE;
|
|
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_FLUSH:
|
|
if (GST_EVENT_FLUSH_DONE (event)) {
|
|
GST_STREAM_LOCK (pad);
|
|
unlock = TRUE;
|
|
}
|
|
break;
|
|
case GST_EVENT_EOS:
|
|
GST_STREAM_LOCK (pad);
|
|
unlock = TRUE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
ret = gst_pad_event_default (pad, event);
|
|
if (unlock)
|
|
GST_STREAM_UNLOCK (pad);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_base_transform_getrange (GstPad * pad, guint64 offset,
|
|
guint length, GstBuffer ** buffer)
|
|
{
|
|
GstBaseTransform *trans;
|
|
GstFlowReturn ret;
|
|
GstBuffer *inbuf;
|
|
|
|
trans = GST_BASE_TRANSFORM (GST_PAD_PARENT (pad));
|
|
|
|
GST_STREAM_LOCK (pad);
|
|
|
|
ret = gst_pad_pull_range (trans->sinkpad, offset, length, &inbuf);
|
|
if (ret == GST_FLOW_OK) {
|
|
ret = gst_base_transform_handle_buffer (trans, inbuf, buffer);
|
|
}
|
|
|
|
GST_STREAM_UNLOCK (pad);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_base_transform_chain (GstPad * pad, GstBuffer * buffer)
|
|
{
|
|
GstBaseTransform *trans;
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GstBuffer *outbuf;
|
|
|
|
trans = GST_BASE_TRANSFORM (GST_PAD_PARENT (pad));
|
|
|
|
GST_STREAM_LOCK (pad);
|
|
|
|
ret = gst_base_transform_handle_buffer (trans, buffer, &outbuf);
|
|
if (ret == GST_FLOW_OK) {
|
|
ret = gst_pad_push (trans->srcpad, outbuf);
|
|
}
|
|
|
|
GST_STREAM_UNLOCK (pad);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_base_transform_handle_buffer (GstBaseTransform * trans, GstBuffer * inbuf,
|
|
GstBuffer ** outbuf)
|
|
{
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GstBaseTransformClass *bclass;
|
|
|
|
bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
|
|
if (bclass->transform)
|
|
ret = bclass->transform (trans, inbuf, outbuf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
gst_base_transform_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstBaseTransform *trans;
|
|
|
|
trans = GST_BASE_TRANSFORM (object);
|
|
|
|
switch (prop_id) {
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_base_transform_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstBaseTransform *trans;
|
|
|
|
trans = GST_BASE_TRANSFORM (object);
|
|
|
|
switch (prop_id) {
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_base_transform_sink_activate_push (GstPad * pad, gboolean active)
|
|
{
|
|
gboolean result = TRUE;
|
|
GstBaseTransform *trans;
|
|
GstBaseTransformClass *bclass;
|
|
|
|
trans = GST_BASE_TRANSFORM (GST_OBJECT_PARENT (pad));
|
|
bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
|
|
|
|
if (active) {
|
|
if (bclass->start)
|
|
result = bclass->start (trans);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static gboolean
|
|
gst_base_transform_src_activate_pull (GstPad * pad, gboolean active)
|
|
{
|
|
gboolean result = FALSE;
|
|
GstBaseTransform *trans;
|
|
GstBaseTransformClass *bclass;
|
|
|
|
trans = GST_BASE_TRANSFORM (GST_OBJECT_PARENT (pad));
|
|
bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
|
|
|
|
result = gst_pad_activate_pull (trans->sinkpad, active);
|
|
|
|
if (active) {
|
|
if (result && bclass->start)
|
|
result &= bclass->start (trans);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static GstElementStateReturn
|
|
gst_base_transform_change_state (GstElement * element)
|
|
{
|
|
GstBaseTransform *trans;
|
|
GstBaseTransformClass *bclass;
|
|
GstElementState transition;
|
|
GstElementStateReturn result;
|
|
|
|
trans = GST_BASE_TRANSFORM (element);
|
|
bclass = GST_BASE_TRANSFORM_GET_CLASS (trans);
|
|
|
|
transition = GST_STATE_TRANSITION (element);
|
|
|
|
switch (transition) {
|
|
case GST_STATE_NULL_TO_READY:
|
|
break;
|
|
case GST_STATE_READY_TO_PAUSED:
|
|
break;
|
|
case GST_STATE_PAUSED_TO_PLAYING:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
result = GST_ELEMENT_CLASS (parent_class)->change_state (element);
|
|
|
|
switch (transition) {
|
|
case GST_STATE_PLAYING_TO_PAUSED:
|
|
break;
|
|
case GST_STATE_PAUSED_TO_READY:
|
|
if (bclass->stop)
|
|
result = bclass->stop (trans);
|
|
break;
|
|
case GST_STATE_READY_TO_NULL:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|