mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-02-17 11:45:25 +00:00
Code Issues 1 Projects Releases Wiki Activity

gaudieffects: Add Gaussian Blur effect, and brief example.

Browse source
This commit is contained in:
Jan Schmidt 2010-08-02 20:41:12 +10:00
parent fc9cfb0c00
commit 2f1899cd31
7 changed files with 507 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
docs/plugins/inspect/plugin-gaudieffects.xml
View file

@ -114,6 +114,27 @@
</caps>
</pads>
</element>
<element>
<name>gaussianblur</name>
<longname>GaussBlur</longname>
<class>Filter/Effect/Video</class>
<description>Perform Gaussian blur/sharpen on a video</description>
<author>Jan Schmidt &lt;thaytan@noraisin.net&gt;</author>
<pads>
<caps>
<name>sink</name>
<direction>sink</direction>
<presence>always</presence>
<details>video/x-raw-yuv, format=(fourcc)AYUV, width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], framerate=(fraction)[ 0/1, 2147483647/1 ]</details>
</caps>
<caps>
<name>src</name>
<direction>source</direction>
<presence>always</presence>
<details>video/x-raw-yuv, format=(fourcc)AYUV, width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], framerate=(fraction)[ 0/1, 2147483647/1 ]</details>
</caps>
</pads>
</element>
<element>
<name>solarize</name>
<longname>Solarize</longname>

8
gst/gaudieffects/Makefile.am
View file

@ -1,13 +1,13 @@
plugin_LTLIBRARIES = libgstgaudieffects.la
libgstgaudieffects_la_SOURCES = gstburn.c gstchromium.c gstdilate.c \
gstdodge.c gstexclusion.c gstsolarize.c gstplugin.c
libgstgaudieffects_la_CFLAGS = $(GST_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS)
libgstgaudieffects_la_LIBADD = $(GST_LIBS) -lgstvideo-@GST_MAJORMINOR@
gstdodge.c gstexclusion.c gstgaussblur.c gstsolarize.c gstplugin.c
libgstgaudieffects_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_CFLAGS)
libgstgaudieffects_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) -lgstvideo-@GST_MAJORMINOR@ $(GST_CONTROLLER_LIBS) $(GST_LIBS) $(LIBM)
libgstgaudieffects_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
libgstgaudieffects_la_LIBTOOLFLAGS = --tag=disable-static
# headers we need but don't want installed
noinst_HEADERS = \
gstburn.h gstchromium.h gstdilate.h gstdodge.h \
gstexclusion.h gstplugin.h gstsolarize.h
gstexclusion.h gstgaussblur.h gstplugin.h gstsolarize.h

23
gst/gaudieffects/blur-example.py Normal file
View file

@ -0,0 +1,23 @@
#!/usr/bin/python
import gobject; gobject.threads_init()
import pygst; pygst.require("0.10")
import gst
p = gst.parse_launch ("""
v4l2src !
ffmpegcolorspace ! queue ! video/x-raw-yuv,width=320,height=240,framerate=30/1 ! gaussianblur qos=true name=vf ! ffmpegcolorspace !
timeoverlay ! xvimagesink
""")
m = p.get_by_name ("vf")
m.set_property ("sigma", 0.5)
control = gst.Controller(m, "sigma")
control.set_interpolation_mode("sigma", gst.INTERPOLATE_LINEAR)
control.set("sigma", 0 * gst.SECOND, 0.5)
control.set("sigma", 5 * gst.SECOND, 10.0)
control.set("sigma", 25 * gst.SECOND, -5.0)
p.set_state (gst.STATE_PLAYING)
gobject.MainLoop().run()

411
gst/gaudieffects/gstgaussblur.c Normal file
View file

@ -0,0 +1,411 @@
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <math.h>
#include <gst/gst.h>
#include <gst/controller/gstcontroller.h>
#include "gstplugin.h"
#include "gstgaussblur.h"
static gboolean gauss_blur_stop (GstBaseTransform * btrans);
static gboolean gauss_blur_set_caps (GstBaseTransform * btrans,
GstCaps * incaps, GstCaps * outcaps);
static GstFlowReturn gauss_blur_process_frame (GstBaseTransform * btrans,
GstBuffer * in_buf, GstBuffer * out_buf);
static void gauss_blur_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec);
static void gauss_blur_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec);
GST_DEBUG_CATEGORY_STATIC (gst_gauss_blur_debug);
#define GST_CAT_DEFAULT gst_gauss_blur_debug
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
#define CAPS_STR_RGB GST_VIDEO_CAPS_BGRx ";" GST_VIDEO_CAPS_RGBx
#else
#define CAPS_STR_RGB GST_VIDEO_CAPS_xRGB ";" GST_VIDEO_CAPS_xBGR
#endif
#define CAPS_STR GST_VIDEO_CAPS_YUV("AYUV")
/* The capabilities of the inputs and outputs. */
static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (CAPS_STR)
);
static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (CAPS_STR)
);
enum
{
PROP_0,
PROP_SIGMA,
PROP_LAST
};
static void cleanup (GaussBlur * gb);
static gboolean make_gaussian_kernel (GaussBlur * gb, float sigma);
static void gaussian_smooth (GaussBlur * gb, guint8 * image,
guint8 * out_image);
GST_BOILERPLATE (GaussBlur, gauss_blur, GstVideoFilter, GST_TYPE_VIDEO_FILTER);
#define DEFAULT_SIGMA 1.2
static void
gauss_blur_base_init (gpointer gclass)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
gst_element_class_set_details_simple (element_class,
"GaussBlur",
"Filter/Effect/Video",
"Perform Gaussian blur/sharpen on a video",
"Jan Schmidt <thaytan@noraisin.net>");
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&src_factory));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&sink_factory));
}
static void
gauss_blur_class_init (GaussBlurClass * klass)
{
GObjectClass *object_class = (GObjectClass *) klass;
GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;
object_class->set_property = gauss_blur_set_property;
object_class->get_property = gauss_blur_get_property;
trans_class->stop = gauss_blur_stop;
trans_class->set_caps = gauss_blur_set_caps;
trans_class->transform = gauss_blur_process_frame;
g_object_class_install_property (object_class, PROP_SIGMA,
g_param_spec_double ("sigma", "Sigma",
"Sigma value for gaussian blur (negative for sharpen)",
-20.0, 20.0, DEFAULT_SIGMA,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
}
static void
gauss_blur_init (GaussBlur * gb, GaussBlurClass * gclass)
{
gb->sigma = DEFAULT_SIGMA;
gb->cur_sigma = -1.0;
}
static void
cleanup (GaussBlur * gb)
{
g_free (gb->tempim);
gb->tempim = NULL;
g_free (gb->smoothedim);
gb->smoothedim = NULL;
g_free (gb->kernel);
gb->kernel = NULL;
g_free (gb->kernel_sum);
gb->kernel_sum = NULL;
}
static gboolean
gauss_blur_stop (GstBaseTransform * btrans)
{
GaussBlur *gb = GAUSS_BLUR (btrans);
cleanup (gb);
return TRUE;
}
static gboolean
gauss_blur_set_caps (GstBaseTransform * btrans,
GstCaps * incaps, GstCaps * outcaps)
{
GaussBlur *gb = GAUSS_BLUR (btrans);
GstStructure *structure;
GstVideoFormat format;
guint32 n_elems;
structure = gst_caps_get_structure (incaps, 0);
g_return_val_if_fail (structure != NULL, FALSE);
if (!gst_video_format_parse_caps (incaps, &format, &gb->width, &gb->height))
return FALSE;
/* get stride */
gb->stride = gst_video_format_get_row_stride (format, 0, gb->width);
n_elems = gb->stride * gb->height;
gb->tempim = g_malloc (sizeof (gfloat) * n_elems);
//gb->smoothedim = g_malloc (sizeof (guint16) * n_elems);
return TRUE;
}
static GstFlowReturn
gauss_blur_process_frame (GstBaseTransform * btrans,
GstBuffer * in_buf, GstBuffer * out_buf)
{
GaussBlur *gb = GAUSS_BLUR (btrans);
GstClockTime timestamp;
gint64 stream_time;
gfloat sigma;
/* GstController: update the properties */
timestamp = GST_BUFFER_TIMESTAMP (in_buf);
stream_time =
gst_segment_to_stream_time (&btrans->segment, GST_FORMAT_TIME, timestamp);
if (GST_CLOCK_TIME_IS_VALID (stream_time))
gst_object_sync_values (G_OBJECT (gb), stream_time);
GST_OBJECT_LOCK (gb);
sigma = gb->sigma;
GST_OBJECT_UNLOCK (gb);
if (gb->cur_sigma != sigma) {
g_free (gb->kernel);
gb->kernel = NULL;
g_free (gb->kernel_sum);
gb->kernel_sum = NULL;
gb->cur_sigma = sigma;
}
if (gb->kernel == NULL && !make_gaussian_kernel (gb, gb->cur_sigma)) {
GST_ELEMENT_ERROR (btrans, RESOURCE, NO_SPACE_LEFT, ("Out of memory"),
("Failed to allocation gaussian kernel"));
return GST_FLOW_ERROR;
}
/*
* Perform gaussian smoothing on the image using the input standard
* deviation.
*/
memcpy (GST_BUFFER_DATA (out_buf), GST_BUFFER_DATA (in_buf),
gb->height * gb->stride);
gaussian_smooth (gb, GST_BUFFER_DATA (in_buf), GST_BUFFER_DATA (out_buf));
return GST_FLOW_OK;
}
static void
blur_row_x (GaussBlur * gb, guint8 * in_row, gfloat * out_row)
{
int c, cc, center;
float dot[4], sum;
int k, kmin, kmax;
center = gb->windowsize / 2;
for (c = 0; c < gb->width; c++) {
/* Calculate min */
cc = center - c;
kmin = MAX (0, cc);
cc = kmin - cc;
/* Calc max */
kmax = MIN (gb->windowsize, gb->width - cc);
cc *= 4;
dot[0] = dot[1] = dot[2] = dot[3] = 0.0;
/* Calculate sum for range */
sum = gb->kernel_sum[kmax - 1];
sum -= kmin ? gb->kernel_sum[kmin - 1] : 0.0;
for (k = kmin; k < kmax; k++) {
float coeff = gb->kernel[k];
dot[0] += (float) in_row[cc++] * coeff;
dot[1] += (float) in_row[cc++] * coeff;
dot[2] += (float) in_row[cc++] * coeff;
dot[3] += (float) in_row[cc++] * coeff;
}
out_row[c * 4] = dot[0] / sum;
out_row[c * 4 + 1] = dot[1] / sum;
out_row[c * 4 + 2] = dot[2] / sum;
out_row[c * 4 + 3] = dot[3] / sum;
}
}
static void
gaussian_smooth (GaussBlur * gb, guint8 * image, guint8 * out_image)
{
int r, c, rr, center;
float dot[4], sum;
int k, kmin, kmax;
guint8 *in_row = image;
float *tmp_out_row = gb->tempim;
float *tmp_in_pos;
gint y_avail = 0;
guint8 *out_row;
/* Apply the gaussian kernel */
center = gb->windowsize / 2;
/* Blur in the y - direction. */
for (r = 0; r < gb->height; r++) {
/* Calculate input row range */
rr = center - r;
kmin = MAX (0, rr);
rr = kmin - rr;
/* Calc max */
kmax = MIN (gb->windowsize, gb->height - rr);
/* Precalculate sum for range */
sum = gb->kernel_sum[kmax - 1];
sum -= kmin ? gb->kernel_sum[kmin - 1] : 0.0;
/* Blur more input rows (x direction blur) */
while (y_avail <= (r + center) && y_avail < gb->height) {
blur_row_x (gb, in_row, tmp_out_row);
in_row += gb->stride;
tmp_out_row += gb->stride;
y_avail++;
}
tmp_in_pos = gb->tempim + (rr * gb->stride);
out_row = out_image + r * gb->stride;
for (c = 0; c < gb->width; c++) {
float *tmp = tmp_in_pos;
dot[0] = dot[1] = dot[2] = dot[3] = 0.0;
for (k = kmin; k < kmax; k++, tmp += gb->stride) {
float kern = gb->kernel[k];
dot[0] += tmp[0] * kern;
dot[1] += tmp[1] * kern;
dot[2] += tmp[2] * kern;
dot[3] += tmp[3] * kern;
}
*out_row++ = (guint8) CLAMP ((dot[0] / sum + 0.5), 0, 255);
*out_row++ = (guint8) CLAMP ((dot[1] / sum + 0.5), 0, 255);
*out_row++ = (guint8) CLAMP ((dot[2] / sum + 0.5), 0, 255);
*out_row++ = (guint8) CLAMP ((dot[3] / sum + 0.5), 0, 255);
tmp_in_pos += 4;
}
}
}
/*
* Create a one dimensional gaussian kernel.
*/
static gboolean
make_gaussian_kernel (GaussBlur * gb, float sigma)
{
int i, center, left, right;
float sum, sum2;
const float fe = -0.5 / (sigma * sigma);
const float dx = 1.0 / (sigma * sqrt (2 * M_PI));
center = ceil (2.5 * fabs (sigma));
gb->windowsize = (int) (1 + 2 * center);
gb->kernel = g_new (float, gb->windowsize);
gb->kernel_sum = g_new (float, gb->windowsize);
if (gb->kernel == NULL || gb->kernel_sum == NULL)
return FALSE;
if (gb->windowsize == 1) {
gb->kernel[0] = 1.0;
gb->kernel_sum[0] = 1.0;
return TRUE;
}
/* Center co-efficient */
sum = gb->kernel[center] = dx;
/* Other coefficients */
left = center - 1;
right = center + 1;
for (i = 1; i <= center; i++, left--, right++) {
float fx = dx * pow (M_E, fe * i * i);
gb->kernel[right] = gb->kernel[left] = fx;
sum += 2 * fx;
}
if (sigma < 0) {
sum = -sum;
gb->kernel[center] += 2.0 * sum;
}
for (i = 0; i < gb->windowsize; i++)
gb->kernel[i] /= sum;
sum2 = 0.0;
for (i = 0; i < gb->windowsize; i++) {
sum2 += gb->kernel[i];
gb->kernel_sum[i] = sum2;
}
#if 0
g_print ("Sigma %f: ", sigma);
for (i = 0; i < gb->windowsize; i++)
g_print ("%f ", gb->kernel[i]);
g_print ("\n");
g_print ("sums: ");
for (i = 0; i < gb->windowsize; i++)
g_print ("%f ", gb->kernel_sum[i]);
g_print ("\n");
g_print ("sum %f sum2 %f\n", sum, sum2);
#endif
return TRUE;
}
static void
gauss_blur_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec)
{
GaussBlur *gb = GAUSS_BLUR (object);
switch (prop_id) {
case PROP_SIGMA:
GST_OBJECT_LOCK (object);
gb->sigma = g_value_get_double (value);
GST_OBJECT_UNLOCK (object);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gauss_blur_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec)
{
GaussBlur *gb = GAUSS_BLUR (object);
switch (prop_id) {
case PROP_SIGMA:
GST_OBJECT_LOCK (gb);
g_value_set_double (value, gb->sigma);
GST_OBJECT_UNLOCK (gb);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/* Register the element factories and other features. */
gboolean
gst_gauss_blur_plugin_init (GstPlugin * plugin)
{
/* debug category for fltering log messages */
GST_DEBUG_CATEGORY_INIT (gst_gauss_blur_debug, "gaussianblur",
0, "Gaussian Blur video effect");
return gst_element_register (plugin, "gaussianblur", GST_RANK_NONE,
GST_TYPE_GAUSS_BLUR);
}

40
gst/gaudieffects/gstgaussblur.h Normal file
View file

@ -0,0 +1,40 @@
#ifndef __GST_GAUSS_BLUR_H__
#define __GST_GAUSS_BLUR_H__
#include <gst/gst.h>
#include <gst/video/video.h>
#include <gst/video/gstvideofilter.h>
G_BEGIN_DECLS
#define GST_TYPE_GAUSS_BLUR (gauss_blur_get_type())
#define GAUSS_BLUR(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GAUSS_BLUR, GaussBlur))
typedef struct GaussBlur GaussBlur;
typedef struct GaussBlurClass GaussBlurClass;
struct GaussBlur
{
GstVideoFilter videofilter;
gint width, height, stride;
float cur_sigma, sigma;
int windowsize;
float *kernel;
float *kernel_sum;
float *tempim;
gint16 *smoothedim;
};
struct GaussBlurClass
{
GstVideoFilterClass parent_class;
};
GType gauss_blur_get_type(void);
G_END_DECLS
#endif

1
gst/gaudieffects/gstplugin.c
View file

@ -71,6 +71,7 @@ plugin_init (GstPlugin * plugin)
ret &= gst_dodge_plugin_init (plugin);
ret &= gst_exclusion_plugin_init (plugin);
ret &= gst_solarize_plugin_init (plugin);
ret &= gst_gauss_blur_plugin_init (plugin);
return ret;
}

13
gst/gaudieffects/gstplugin.h
View file

@ -50,12 +50,13 @@
G_BEGIN_DECLS
gboolean gst_burn_plugin_init (GstPlugin * chromium);
gboolean gst_chromium_plugin_init (GstPlugin * chromium);
gboolean gst_dilate_plugin_init (GstPlugin * chromium);
gboolean gst_dodge_plugin_init (GstPlugin * chromium);
gboolean gst_exclusion_plugin_init (GstPlugin * chromium);
gboolean gst_solarize_plugin_init (GstPlugin * chromium);
gboolean gst_burn_plugin_init (GstPlugin *plugin);
gboolean gst_chromium_plugin_init (GstPlugin *plugin);
gboolean gst_dilate_plugin_init (GstPlugin *plugin);
gboolean gst_dodge_plugin_init (GstPlugin *plugin);
gboolean gst_exclusion_plugin_init (GstPlugin *plugin);
gboolean gst_gauss_blur_plugin_init (GstPlugin *plugin);
gboolean gst_solarize_plugin_init (GstPlugin *plugin);
G_END_DECLS