From 0f4d96ce68be9c504d975aa07c143053b5886be6 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Wed, 24 Apr 2002 23:09:13 +0000 Subject: Vertigo is another cool one Original commit message from CVS: Vertigo is another cool one --- gst/effectv/gstvertigo.c | 358 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 358 insertions(+) create mode 100644 gst/effectv/gstvertigo.c (limited to 'gst/effectv/gstvertigo.c') diff --git a/gst/effectv/gstvertigo.c b/gst/effectv/gstvertigo.c new file mode 100644 index 00000000..4e9ec4ed --- /dev/null +++ b/gst/effectv/gstvertigo.c @@ -0,0 +1,358 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * + * EffecTV: + * Copyright (C) 2001 FUKUCHI Kentarou + * + * EffecTV is free software. We release this product under the terms of the + * GNU General Public License version 2. The license is included in the file + * COPYING. + * + * This program 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 General Public License for more details. + */ + +#include +#include +#include +#include "gsteffectv.h" + +#define GST_TYPE_VERTIGOTV \ + (gst_vertigotv_get_type()) +#define GST_VERTIGOTV(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VERTIGOTV,GstVertigoTV)) +#define GST_VERTIGOTV_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstVertigoTV)) +#define GST_IS_VERTIGOTV(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VERTIGOTV)) +#define GST_IS_VERTIGOTV_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VERTIGOTV)) + +typedef struct _GstVertigoTV GstVertigoTV; +typedef struct _GstVertigoTVClass GstVertigoTVClass; + +struct _GstVertigoTV +{ + GstElement element; + + GstPad *sinkpad, *srcpad; + + gint width, height; + guint32 *buffer; + guint32 *current_buffer, *alt_buffer; + gint dx, dy; + gint sx, sy; + gdouble phase; + gdouble phase_increment; + gdouble zoomrate; + +}; + +struct _GstVertigoTVClass +{ + GstElementClass parent_class; + + void (*reset) (GstElement *element); +}; + +GstElementDetails gst_vertigotv_details = { + "VertigoTV", + "Filter/Effect", + "A loopback alpha blending effector with rotating and scaling", + VERSION, + "Wim Taymans ", + "(C) 2001 FUKUCHI Kentarou", +}; + + +/* Filter signals and args */ +enum +{ + /* FILL ME */ + RESET_SIGNAL, + LAST_SIGNAL +}; + +enum +{ + ARG_0, + ARG_SPEED, + ARG_ZOOM_SPEED, +}; + +static void gst_vertigotv_class_init (GstVertigoTVClass * klass); +static void gst_vertigotv_init (GstVertigoTV * filter); + +static void gst_vertigotv_reset_handler (GstElement *element); + +static void gst_vertigotv_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_vertigotv_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static void gst_vertigotv_chain (GstPad * pad, GstBuffer * buf); + +static GstElementClass *parent_class = NULL; +static guint gst_vertigotv_signals[LAST_SIGNAL] = { 0 }; + +GType gst_vertigotv_get_type (void) +{ + static GType vertigotv_type = 0; + + if (!vertigotv_type) { + static const GTypeInfo vertigotv_info = { + sizeof (GstVertigoTVClass), NULL, + NULL, + (GClassInitFunc) gst_vertigotv_class_init, + NULL, + NULL, + sizeof (GstVertigoTV), + 0, + (GInstanceInitFunc) gst_vertigotv_init, + }; + + vertigotv_type = g_type_register_static (GST_TYPE_ELEMENT, "GstVertigoTV", &vertigotv_info, 0); + } + return vertigotv_type; +} + +static void +gst_vertigotv_class_init (GstVertigoTVClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + gobject_class = (GObjectClass *) klass; + gstelement_class = (GstElementClass *) klass; + + parent_class = g_type_class_ref (GST_TYPE_ELEMENT); + + gst_vertigotv_signals[RESET_SIGNAL] = + g_signal_new ("reset_parms", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GstVertigoTVClass, reset), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + klass->reset = gst_vertigotv_reset_handler; + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SPEED, + g_param_spec_float ("speed","Speed","Control the speed of movement", + 0.01, 100.0, 0.02, G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ZOOM_SPEED, + g_param_spec_float ("zoom_speed","Zoom Speed","Control the rate of zooming", + 1.01, 1.1, 1.01, G_PARAM_READWRITE)); + + gobject_class->set_property = gst_vertigotv_set_property; + gobject_class->get_property = gst_vertigotv_get_property; +} + +static void +gst_vertigotv_reset_handler (GstElement *element) +{ + GstVertigoTV *filter = GST_VERTIGOTV (element); + + filter->phase = 0.0; + filter->phase_increment = 0.02; + filter->zoomrate = 1.01; +} + + +static GstPadConnectReturn +gst_vertigotv_sinkconnect (GstPad * pad, GstCaps * caps) +{ + GstVertigoTV *filter; + gint area; + + filter = GST_VERTIGOTV (gst_pad_get_parent (pad)); + + if (!GST_CAPS_IS_FIXED (caps)) + return GST_PAD_CONNECT_DELAYED; + + gst_caps_get_int (caps, "width", &filter->width); + gst_caps_get_int (caps, "height", &filter->height); + + area = filter->width * filter->height; + + g_free (filter->buffer); + filter->buffer = (guint32 *) g_malloc (area * 2 * sizeof(guint32)); + + bzero (filter->buffer, area * 2 * sizeof(guint32)); + filter->current_buffer = filter->buffer; + filter->alt_buffer = filter->buffer + area; + filter->phase = 0; + + if (gst_pad_try_set_caps (filter->srcpad, caps)) { + return GST_PAD_CONNECT_OK; + } + + return GST_PAD_CONNECT_REFUSED; +} + +static void +gst_vertigotv_init (GstVertigoTV * filter) +{ + filter->sinkpad = gst_pad_new_from_template (gst_effectv_sink_factory (), "sink"); + gst_pad_set_chain_function (filter->sinkpad, gst_vertigotv_chain); + gst_pad_set_connect_function (filter->sinkpad, gst_vertigotv_sinkconnect); + gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); + + filter->srcpad = gst_pad_new_from_template (gst_effectv_src_factory (), "src"); + gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); + + filter->buffer = NULL; + filter->phase = 0.0; + filter->phase_increment = 0.02; + filter->zoomrate = 1.01; +} + +static void +gst_vertigotv_set_parms (GstVertigoTV *filter) +{ + double vx, vy; + double t; + double x, y; + double dizz; + + dizz = sin (filter->phase) * 10 + sin (filter->phase*1.9+5) * 5; + + x = filter->width / 2; + y = filter->height / 2; + + t = (x*x + y*y) * filter->zoomrate; + + if (filter->width > filter->height) { + if (dizz >= 0) { + if (dizz > x) dizz = x; + vx = (x * (x - dizz) + y * y) / t; + } else { + if (dizz < -x) dizz = -x; + vx = (x * (x + dizz) + y * y) / t; + } + vy = (dizz * y) / t; + } else { + if (dizz >= 0) { + if (dizz > y) dizz = y; + vx = (x * x + y * (y - dizz)) / t; + } else { + if (dizz < -y) dizz = -y; + vx = (x * x + y * (y + dizz)) / t; + } + vy = (dizz * x) / t; + } + filter->dx = vx * 65536; + filter->dy = vy * 65536; + filter->sx = (-vx * x + vy * y + x + cos (filter->phase * 5) * 2) * 65536; + filter->sy = (-vx * y - vy * x + y + sin (filter->phase * 6) * 2) * 65536; + + filter->phase += filter->phase_increment; + if (filter->phase > 5700000) filter->phase = 0; +} + +static void +gst_vertigotv_chain (GstPad * pad, GstBuffer * buf) +{ + GstVertigoTV *filter; + guint32 *src, *dest; + GstBuffer *outbuf; + guint32 *p; + guint32 v; + gint x, y; + gint ox, oy; + gint i; + gint width, height, area; + + filter = GST_VERTIGOTV (gst_pad_get_parent (pad)); + + src = (guint32 *) GST_BUFFER_DATA (buf); + + width = filter->width; + height = filter->height; + area = width * height; + + outbuf = gst_buffer_new (); + GST_BUFFER_SIZE (outbuf) = area * sizeof(guint32); + dest = (guint32 *) GST_BUFFER_DATA (outbuf) = g_malloc (GST_BUFFER_SIZE (outbuf)); + GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf); + + gst_vertigotv_set_parms (filter); + p = filter->alt_buffer; + + for (y = height; y > 0; y--) { + ox = filter->sx; + oy = filter->sy; + + for (x = width; x > 0; x--) { + i = (oy >> 16) * width + (ox >> 16); + if (i < 0) i = 0; + if (i >= area) i = area; + + v = filter->current_buffer[i] & 0xfcfcff; + v = (v * 3) + ((*src++) & 0xfcfcff); + + *p++ = (v >> 2); + ox += filter->dx; + oy += filter->dy; + } + filter->sx -= filter->dy; + filter->sy += filter->dx; + } + + memcpy(dest, filter->alt_buffer, area * sizeof(guint32)); + + gst_buffer_unref (buf); + + gst_pad_push (filter->srcpad, outbuf); + + p = filter->current_buffer; + filter->current_buffer = filter->alt_buffer; + filter->alt_buffer = p; +} + +static void +gst_vertigotv_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) +{ + GstVertigoTV *filter; + + /* it's not null if we got it, but it might not be ours */ + g_return_if_fail (GST_IS_VERTIGOTV (object)); + + filter = GST_VERTIGOTV (object); + + switch (prop_id) { + case ARG_SPEED: + filter->phase_increment = g_value_get_float (value); + break; + case ARG_ZOOM_SPEED: + filter->zoomrate = g_value_get_float (value); + break; + default: + break; + } +} + +static void +gst_vertigotv_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) +{ + GstVertigoTV *filter; + + /* it's not null if we got it, but it might not be ours */ + g_return_if_fail (GST_IS_VERTIGOTV (object)); + + filter = GST_VERTIGOTV (object); + + switch (prop_id) { + case ARG_SPEED: + g_value_set_float (value, filter->phase_increment); + break; + case ARG_ZOOM_SPEED: + g_value_set_float (value, filter->zoomrate); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} -- cgit