mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-09-20 19:10:18 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/validate/plugins/ssim/gstvalidatessim.c

816 lines
26 KiB
C
Raw Blame History

/* GStreamer
*
* Copyright (C) 2015 Raspberry Pi Foundation
* Author: Thibault Saunier <thibault.saunier@collabora.com>
*
* gstvalidatessim.c: GstValidateActionTypes to use with ssim applications
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser 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.
*/
/**
* SECTION:validate-ssim
* @short_description: GstValidate plugin to detect frame corruptions
*
* GstValidate plugin to run the ssim algorithm on the buffers flowing in the
* pipeline to find regressions and detect frame corruptions.
* It allows you to generate image files from the buffers flowing in the pipeline
* (either as raw in the many formats supported by GStreamer or as png) and then
* check them against pre generated, reference images.
*
* The ssim algorithm will set a value of 1.0 when images are perfectly identical,
* and -1.0 if they have nothing in common. By default we consider images as similar
* if they have at least a ssim value of 0.95 but you can override it defining the value
* under which the test will be considered as failed.
*
* Errors are reported on the GstValidate reporting system. You can also ask
* the plugin to generate grey scale output images. Those will be named in a way
* that should lets you precisely see where and how the test failed.
*
* # Configuration
*
* The configuration of the plugin is done through a validate configuration file,
* specified with the %GST_VALIDATE_CONFIG environment variable. Each line starting
* with 'ssim,' will configure the ssim plugin. In practice each configuration statement
* will lead to the creation of a #GstValidateOverride object which will then dump
* image files and if wanted compare those with a set of reference images.
*
* The following parameters can be passed in the configuration file:
* - element-classification: The target element classification as define in
* gst_element_class_set_metadata
* - output-dir: The directory in which the image files will be saved
* - min-avg-priority: (default 0.95): The minimum average similarity
* under which we consider the test as failing
* - min-lowest-priority: (default 1): The minimum 'lowest' similarity
* under which we consider the test as failing
* - reference-images-dir: Define the directory in which the files to be
* compared can be found
* - result-output-dir: The folder in which to store resulting grey scale
* images when the test failed. In that folder you will find images
* with the structural difference between the expected result and the actual
* result.
* - output-video-format: The format in which you want the images to be saved
* - reference-video-format: The format in which the reference images are stored
* - check-recurrence: The recurrence in seconds (as float) the frames should
* be dumped and checked.By default it is GST_CLOCK_TIME_NONE, meaning each
* and every frame is checked. Not that in any case, after a discontinuity
* in the stream (after a seek or a change in the video format for example)
* a check is done. And if recurrence == 0, images will be checked only after
* such discontinuity
* - is-config: Property letting the plugin know that the config line is exclusively
* used to configure the following configuration expressions. In practice this
* means that it will change the default values for the other configuration
* expressions.
*
* # Example #
*
* Let's take a special configuration where we want to compare frames that are
* outputted by a video decoder with the ones after a agingtv element we would
* call my_agingtv. We force to check one frame every 5.0 seconds only (with
* check-recurrence=5.0) so the test is fast.
*
* The configuration file:
* |[
* core, action=set-property, target-element-klass=Sink, property-name=sync, property-value=false
*
* ssim, is-config=true, output-video-format="I420", reference-video-format="I420"
* ssim, element-classification="Video/Decoder", output-dir=/tmp/test/before-agingtv/
* ssim, element-name=my_agingtv, output-dir=/tmp/test/after-agingtv/, \
* reference-images-dir=/tmp/test/before-agingtv/, \
* result-output-dir=/tmp/test/failures, check-recurrence=5.0
* ]|
*
* Save that content in a file called check_agingtv_ssim.config
*
* ## Launch the pipeline
* |[
* GST_VALIDATE_CONFIG=check_agingtv_ssim.config gst-validate-1.0-debug uridecodebin uri=file://a/file ! videoconvert ! agingtv name=my_agingtv ! videoconvert ! autovideosink
* ]|
*/
#define _GNU_SOURCE
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <cairo.h>
#include <glib/gstdio.h>
#include <gst/gst.h>
#include <gst/video/video.h>
#include "../../gst-libs/gst/video/gstvalidatessim.h"
#include "../../gst/validate/gst-validate-report.h"
#include "../../gst/validate/gst-validate-pad-monitor.h"
#include "../../gst/validate/gst-validate-reporter.h"
#include "../../gst/validate/validate.h"
#include "../../gst/validate/gst-validate-scenario.h"
#include "../../gst/validate/gst-validate-utils.h"
#define SSIM_WRONG_FORMAT g_quark_from_static_string ("validatessim::wrong-format")
#define SSIM_CONVERSION_ERROR g_quark_from_static_string ("validatessim::conversion-error")
#define SSIM_SAVING_ERROR g_quark_from_static_string ("validatessim::saving-error")
#define MONITOR_DATA g_quark_from_static_string ("validate-ssim-monitor-data")
typedef struct _ValidateSsimOverridePriv ValidateSsimOverridePriv;
typedef struct
{
GstValidateOverride parent;
ValidateSsimOverridePriv *priv;
} ValidateSsimOverride;
typedef struct
{
GstValidateOverrideClass parent;
} ValidateSsimOverrideClass;
typedef struct
{
gchar *path;
GstClockTime position;
guint width, height;
} Frame;
static void
free_frame (Frame * frame)
{
g_free (frame->path);
}
static GType validate_ssim_override_get_type (void);
#define VALIDATE_SSIM_OVERRIDE_TYPE (validate_ssim_override_get_type ())
#define VALIDATE_SSIM_OVERRIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALIDATE_SSIM_OVERRIDE_TYPE, ValidateSsimOverride))
#define VALIDATE_SSIM_OVERRIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALIDATE_SSIM_OVERRIDE_TYPE, ValidateSsimOverrideClass))
#define IS_VALIDATE_SSIM_OVERRIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALIDATE_SSIM_OVERRIDE_TYPE))
#define IS_VALIDATE_SSIM_OVERRIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALIDATE_SSIM_OVERRIDE_TYPE))
#define VALIDATE_SSIM_OVERRIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALIDATE_SSIM_OVERRIDE_TYPE, ValidateSsimOverrideClass))
/* *INDENT-OFF* */
G_DEFINE_TYPE (ValidateSsimOverride, validate_ssim_override, GST_TYPE_VALIDATE_OVERRIDE)
/* *INDENT-ON* */
struct _ValidateSsimOverridePriv
{
gchar *outdir;
gchar *result_outdir;
GstStructure *config;
gboolean is_attached;
GstVideoConverter *converter;
GstCaps *last_caps;
GstVideoInfo in_info;
GstVideoInfo out_info;
GArray *frames;
GstClockTime recurrence;
GstClockTime last_dump_position;
/* Always used in the streaming thread */
gboolean needs_reconfigure;
GstVideoFormat save_format;
const gchar *ext;
GstVideoFormat ref_format;
const gchar *ref_ext;
};
static void
runner_stopping (GstValidateRunner * runner, ValidateSsimOverride * self)
{
GstValidateSsim *ssim;
guint i, nfiles;
gfloat mssim = 0, lowest = 1, highest = -1, total_avg = 0;
gint npassed = 0, nfailures = 0;
gdouble min_avg_similarity = 0.95, min_lowest_similarity = -1.0,
min_avg = 1.0, min_min = 1.0;
const gchar *compared_files_dir =
gst_structure_get_string (self->priv->config,
"reference-images-dir");
if (!compared_files_dir) {
return;
}
gst_validate_printf (self,
"Running frame comparison between images from %s and %s" "%s%s.\n",
compared_files_dir, self->priv->outdir,
self->priv->result_outdir ? ". Issues can be visialized in " :
" (set 'result-output-dir' in the config file to visualize the result)",
self->priv->result_outdir ? self->priv->result_outdir : "");
gst_structure_get_double (self->priv->config, "min-avg-priority",
&min_avg_similarity);
gst_structure_get_double (self->priv->config, "min-lowest-priority",
&min_lowest_similarity);
ssim =
gst_validate_ssim_new (runner, min_avg_similarity, min_lowest_similarity);
nfiles = self->priv->frames->len;
for (i = 0; i < nfiles; i++) {
Frame *frame = &g_array_index (self->priv->frames, Frame, i);
gchar *refname, *ref_path, *bname = g_path_get_basename (frame->path);
if (self->priv->ref_format == GST_VIDEO_FORMAT_ENCODED)
refname = g_strdup_printf ("*.%s", self->priv->ref_ext);
else
refname = g_strdup_printf ("*.%dx%d.%s", frame->width, frame->height,
self->priv->ref_ext);
ref_path = g_build_path (G_DIR_SEPARATOR_S, compared_files_dir,
refname, NULL);
if (!gst_validate_ssim_compare_image_files (ssim, ref_path, frame->path,
&mssim, &lowest, &highest, self->priv->result_outdir))
nfailures++;
else
npassed++;
min_avg = MIN (min_avg, mssim);
min_min = MIN (lowest, min_min);
total_avg += mssim;
gst_validate_printf (NULL,
"<position: %" GST_TIME_FORMAT " duration: %" GST_TIME_FORMAT
" %d / %d avg: %f min: %f (Passed: %d failed: %d)/>\n",
GST_TIME_ARGS (frame->position), GST_TIME_ARGS (GST_CLOCK_TIME_NONE),
i + 1, nfiles, mssim, lowest, npassed, nfailures);
g_free (bname);
}
gst_validate_printf (NULL,
"\nAverage similarity: %f, min_avg: %f, min_min: %f\n",
total_avg / nfiles, min_avg, min_min);
}
static void
_runner_set (GObject * object, GParamSpec * pspec, gpointer user_data)
{
ValidateSsimOverride *self = VALIDATE_SSIM_OVERRIDE (object);
self->priv->is_attached = TRUE;
g_signal_connect (gst_validate_reporter_get_runner (GST_VALIDATE_REPORTER
(self)), "stopping", G_CALLBACK (runner_stopping), self);
}
static ValidateSsimOverride *
validate_ssim_override_new (GstStructure * config)
{
const gchar *format;
ValidateSsimOverride *self = g_object_new (VALIDATE_SSIM_OVERRIDE_TYPE, NULL);
self->priv->outdir =
g_strdup (gst_structure_get_string (config, "output-dir"));
if (self->priv->outdir == NULL) {
gchar *template = g_build_filename (g_get_tmp_dir (),
"validatessim-XXXXXX", NULL);
self->priv->outdir = g_mkdtemp (template);
}
if (!g_file_test (self->priv->outdir, G_FILE_TEST_IS_DIR)) {
if (g_mkdir_with_parents (self->priv->outdir, 0755) != 0) {
GST_ERROR ("Could not create directory %s", self->priv->outdir);
g_object_unref (self);
return NULL;
}
}
gst_validate_printf (self, "Using %s as output directory\n",
self->priv->outdir);
self->priv->config = gst_structure_copy (config);
self->priv->result_outdir =
g_strdup (gst_structure_get_string (config, "result-output-dir"));
format = gst_structure_get_string (config, "output-video-format");
if (!format) {
self->priv->save_format = GST_VIDEO_FORMAT_ENCODED;
self->priv->ext = "png";
} else {
self->priv->save_format = gst_video_format_from_string (format);
self->priv->ext = format;
}
if (self->priv->save_format == GST_VIDEO_FORMAT_UNKNOWN) {
GST_ERROR ("Uknown video format: %s", format);
gst_object_unref (self);
return NULL;
}
format = gst_structure_get_string (config, "reference-video-format");
if (!format) {
self->priv->ref_ext = "png";
self->priv->ref_format = GST_VIDEO_FORMAT_ENCODED;
} else {
self->priv->ref_format = gst_video_format_from_string (format);
if (self->priv->ref_format == GST_VIDEO_FORMAT_UNKNOWN) {
GST_ERROR ("Uknown video format: %s", format);
gst_object_unref (self);
return NULL;
}
self->priv->ref_ext = format;
}
gst_validate_utils_get_clocktime (config, "check-recurrence",
&self->priv->recurrence);
g_signal_connect (self, "notify::validate-runner", G_CALLBACK (_runner_set),
NULL);
return self;
}
static gboolean
_can_attach (GstValidateOverride * override, GstValidateMonitor * monitor)
{
guint i;
GstPad *pad;
GstCaps *template_caps;
GstElement *element;
GstStructure *structure;
if (VALIDATE_SSIM_OVERRIDE (override)->priv->is_attached) {
GST_ERROR_OBJECT (override, "Already attached");
return FALSE;
}
if (!GST_IS_VALIDATE_PAD_MONITOR (monitor)) {
return FALSE;
}
pad = GST_VALIDATE_PAD_MONITOR_GET_PAD (monitor);
element = gst_validate_monitor_get_element (monitor);
if ((gst_validate_element_has_klass (element, "Converter") ||
gst_validate_element_has_klass (element, "Filter")) &&
GST_PAD_IS_SINK (pad)) {
GST_INFO_OBJECT (override, "Not attaching on filter sinkpads");
return FALSE;
}
template_caps = GST_PAD_TEMPLATE_CAPS (GST_PAD_PAD_TEMPLATE (pad));
for (i = 0; i < gst_caps_get_size (template_caps); i++) {
structure = gst_caps_get_structure (template_caps, i);
if (gst_structure_has_name (structure, "video/x-raw")) {
GST_INFO_OBJECT (override, "Wrapping %" GST_PTR_FORMAT, pad);
gst_validate_reporter_set_name (GST_VALIDATE_REPORTER (override),
g_strdup_printf ("ssim-override-%s",
gst_validate_reporter_get_name (GST_VALIDATE_REPORTER
(monitor))));
return TRUE;
}
}
return FALSE;
}
static void
_finalize (GObject * object)
{
ValidateSsimOverridePriv *priv = VALIDATE_SSIM_OVERRIDE (object)->priv;
if (priv->converter)
gst_video_converter_free (priv->converter);
if (priv->last_caps)
gst_caps_unref (priv->last_caps);
g_free (priv->outdir);
g_free (priv->result_outdir);
g_array_unref (priv->frames);
if (priv->config)
gst_structure_free (priv->config);
}
static void
validate_ssim_override_class_init (ValidateSsimOverrideClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = _finalize;
if (!gst_validate_is_initialized ())
return;
GST_VALIDATE_OVERRIDE_CLASS (klass)->can_attach = _can_attach;
gst_validate_issue_register (gst_validate_issue_new (SSIM_WRONG_FORMAT,
"The ValidateSSim plugin can not work with a video format",
"The GstValidate ssim plugin was not able to work"
" with a video format that flowed in the pipeline."
" Make sure you properly configured the plugin",
GST_VALIDATE_REPORT_LEVEL_CRITICAL));
gst_validate_issue_register (gst_validate_issue_new (SSIM_CONVERSION_ERROR,
"The ValidateSSim plugin could not convert a frame in the needed format",
"The GstValidate ssim plugin needs to convert the frame in a colorspace"
" it can handle, but it was not possible.",
GST_VALIDATE_REPORT_LEVEL_CRITICAL));
gst_validate_issue_register (gst_validate_issue_new (SSIM_SAVING_ERROR,
"The ValidateSSim plugin could not save PNG file",
"The ValidateSSim plugin could not save PNG file",
GST_VALIDATE_REPORT_LEVEL_CRITICAL));
g_type_class_add_private (klass, sizeof (ValidateSsimOverridePriv));
}
static void
validate_ssim_override_init (ValidateSsimOverride * self)
{
self->priv =
G_TYPE_INSTANCE_GET_PRIVATE (self, VALIDATE_SSIM_OVERRIDE_TYPE,
ValidateSsimOverridePriv);
self->priv->needs_reconfigure = TRUE;
self->priv->frames = g_array_new (TRUE, TRUE, sizeof (Frame));
g_array_set_clear_func (self->priv->frames, (GDestroyNotify) free_frame);
}
static gboolean
_set_videoconvert (ValidateSsimOverride * o,
GstValidatePadMonitor * pad_monitor)
{
GstCaps *caps;
GstVideoFormat format;
ValidateSsimOverridePriv *priv = o->priv;
GstPad *pad = GST_VALIDATE_PAD_MONITOR_GET_PAD (pad_monitor);
caps = gst_pad_get_current_caps (pad);
gst_caps_replace (&priv->last_caps, caps);
gst_video_info_init (&priv->in_info);
gst_video_info_init (&priv->out_info);
if (priv->converter) {
gst_video_converter_free (priv->converter);
priv->converter = NULL;
}
if (!gst_video_info_from_caps (&priv->in_info, priv->last_caps)) {
GST_VALIDATE_REPORT (o, SSIM_WRONG_FORMAT,
"The format %" GST_PTR_FORMAT " is not supported"
" by the plugin", pad_monitor->last_caps);
return FALSE;
}
if (GST_VIDEO_INFO_HAS_ALPHA (&priv->in_info))
format = GST_VIDEO_FORMAT_BGRA;
else
format = GST_VIDEO_FORMAT_BGRx;
if (priv->in_info.finfo->format == format) {
GST_INFO_OBJECT (o, "No conversion needed");
return TRUE;
}
if (priv->save_format != GST_VIDEO_FORMAT_ENCODED)
format = priv->save_format;
gst_video_info_set_format (&priv->out_info, format,
priv->in_info.width, priv->in_info.height);
priv->out_info.fps_d = priv->in_info.fps_d;
priv->out_info.fps_n = priv->in_info.fps_n;
priv->converter = gst_video_converter_new (&priv->in_info,
&priv->out_info, NULL);
return TRUE;
}
static gboolean
has_frame (ValidateSsimOverride * self, gchar * name)
{
guint i;
GArray *frames = self->priv->frames;
for (i = 0; i < frames->len; ++i) {
if (g_strcmp0 (g_array_index (frames, Frame, i).path, name) == 0)
return TRUE;
}
return FALSE;
}
static gchar *
_get_filename (ValidateSsimOverride * self, GstValidatePadMonitor * monitor,
GstClockTime position)
{
gint i = 0;
gchar *outname = NULL, *s;
if (self->priv->save_format == GST_VIDEO_FORMAT_ENCODED)
s = g_strdup_printf ("%" GST_TIME_FORMAT ".%s", GST_TIME_ARGS (position),
self->priv->ext);
else
s = g_strdup_printf ("%" GST_TIME_FORMAT ".%dx%d.%s",
GST_TIME_ARGS (position),
self->priv->out_info.width,
self->priv->out_info.height, self->priv->ext);
outname = g_build_path (G_DIR_SEPARATOR_S, self->priv->outdir, s, NULL);
g_free (s);
while (has_frame (self, outname)) {
g_free (outname);
if (self->priv->save_format == GST_VIDEO_FORMAT_ENCODED)
s = g_strdup_printf ("%" GST_TIME_FORMAT "-%d.%s",
GST_TIME_ARGS (position), i++, self->priv->ext);
else
s = g_strdup_printf ("%" GST_TIME_FORMAT "-%d.%dx%d.%s",
GST_TIME_ARGS (position), i++, self->priv->out_info.width,
self->priv->out_info.height, self->priv->ext);
outname = g_build_path (G_DIR_SEPARATOR_S, self->priv->outdir, s, NULL);
g_free (s);
}
return outname;
}
static gboolean
_should_dump_buffer (ValidateSsimOverride * self,
GstValidatePadMonitor * pad_monitor, GstClockTime position)
{
ValidateSsimOverridePriv *priv = self->priv;
if (!GST_CLOCK_TIME_IS_VALID (priv->recurrence))
return TRUE;
if (priv->needs_reconfigure)
return TRUE;
/* recurence 0 means, dump exclusively on reconfiguration */
if (priv->recurrence == 0)
return FALSE;
if (ABS (position - priv->last_dump_position) >= priv->recurrence)
return TRUE;
return FALSE;
}
static gboolean
_save_frame (ValidateSsimOverride * self, GstVideoFrame * frame,
const gchar * outname)
{
gboolean res = TRUE;
cairo_status_t status;
cairo_surface_t *surface;
GError *error = NULL;
if (self->priv->save_format == GST_VIDEO_FORMAT_ENCODED) {
surface =
cairo_image_surface_create_for_data (GST_VIDEO_FRAME_PLANE_DATA (frame,
0), CAIRO_FORMAT_RGB24, GST_VIDEO_FRAME_WIDTH (frame),
GST_VIDEO_FRAME_HEIGHT (frame), GST_VIDEO_FRAME_PLANE_STRIDE (frame,
0));
if ((status = cairo_surface_write_to_png (surface, outname)) !=
CAIRO_STATUS_SUCCESS) {
GST_VALIDATE_REPORT (self, SSIM_SAVING_ERROR,
"Could not save %s" " cairo status is %s", outname,
cairo_status_to_string (status));
res = FALSE;
}
cairo_surface_destroy (surface);
return res;
}
if (!g_file_set_contents (outname,
GST_VIDEO_FRAME_PLANE_DATA (frame, 0),
GST_VIDEO_FRAME_SIZE (frame), &error)) {
GST_VALIDATE_REPORT (self, SSIM_SAVING_ERROR,
"Could not save %s error: %s", outname, error->message);
res = FALSE;
}
return res;
}
static void
_handle_buffer (GstValidateOverride * override,
GstValidatePadMonitor * pad_monitor, GstBuffer * buffer)
{
gchar *outname = NULL;
GstVideoFrame frame;
Frame iframe;
ValidateSsimOverride *o = VALIDATE_SSIM_OVERRIDE (override);
ValidateSsimOverridePriv *priv = o->priv;
GstClockTime running_time, position;
running_time = gst_segment_to_running_time (&pad_monitor->segment,
GST_FORMAT_TIME, GST_BUFFER_PTS (buffer));
position = gst_segment_to_position (&pad_monitor->segment,
GST_FORMAT_TIME, running_time);
if (!_should_dump_buffer (o, pad_monitor, position)) {
GST_LOG_OBJECT (override, "Not dumping buffer: %" GST_TIME_FORMAT,
GST_TIME_ARGS (position));
return;
}
if (priv->needs_reconfigure) {
priv->needs_reconfigure = !_set_videoconvert (o, pad_monitor);
}
if (priv->converter) {
GstVideoFrame inframe;
GstBuffer *outbuf;
if (!gst_video_frame_map (&inframe, &priv->in_info, buffer, GST_MAP_READ)) {
GST_VALIDATE_REPORT (o, SSIM_CONVERSION_ERROR,
"Could not map the videoframe %p", buffer);
return;
}
outbuf = gst_buffer_new_allocate (NULL, priv->out_info.size, NULL);
if (!gst_video_frame_map (&frame, &priv->out_info, outbuf, GST_MAP_WRITE)) {
GST_VALIDATE_REPORT (o, SSIM_CONVERSION_ERROR,
"Could not map the outbuffer %p", outbuf);
gst_buffer_unref (outbuf);
return;
}
gst_buffer_unref (outbuf);
gst_video_converter_frame (priv->converter, &inframe, &frame);
gst_video_frame_unmap (&inframe);
} else {
if (!gst_video_frame_map (&frame, &priv->in_info, buffer, GST_MAP_WRITE)) {
GST_VALIDATE_REPORT (o, SSIM_CONVERSION_ERROR,
"Could not map the buffer %p", buffer);
return;
}
}
outname = _get_filename (o, pad_monitor, position);
if (_save_frame (o, &frame, outname)) {
priv->last_dump_position = position;
iframe.position = position;
iframe.path = outname;
iframe.width = priv->in_info.width;
iframe.height = priv->in_info.height;
g_array_append_val (priv->frames, iframe);
}
gst_video_frame_unmap (&frame);
}
static void
_handle_event (GstValidateOverride * override,
GstValidateMonitor * pad_monitor, GstEvent * event)
{
ValidateSsimOverride *self = VALIDATE_SSIM_OVERRIDE (override);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_FLUSH_STOP:
self->priv->needs_reconfigure = TRUE;
break;
case GST_EVENT_CAPS:
self->priv->needs_reconfigure = TRUE;
break;
default:
break;
}
}
static gboolean
_map_confg (GQuark field_id, GValue * value, GstStructure * structure)
{
if (!gst_structure_id_has_field (structure, field_id))
gst_structure_id_set_value (structure, field_id, value);
return TRUE;
}
static gboolean
gst_validate_ssim_init (GstPlugin * plugin)
{
GList *tmp, *config;
GstStructure *config_structure = NULL;
if (!gst_validate_is_initialized ())
return FALSE;
config = gst_validate_plugin_get_config (plugin);
for (tmp = config; tmp; tmp = tmp->next) {
gboolean is_config;
if (gst_structure_get_boolean (tmp->data, "is-config", &is_config)) {
if (is_config) {
config_structure = tmp->data;
break;
}
}
}
for (tmp = config; tmp; tmp = tmp->next) {
const gchar *name = gst_structure_get_string (tmp->data, "element-name");
const gchar *target_element_classification =
gst_structure_get_string (tmp->data, "element-classification");
if (tmp->data == config_structure)
continue;
if (config_structure) {
gst_structure_map_in_place (config_structure,
(GstStructureMapFunc) _map_confg, tmp->data);
}
if ((name || target_element_classification)) {
GstValidateOverride *override =
GST_VALIDATE_OVERRIDE (validate_ssim_override_new (tmp->data));
if (override == NULL) {
GST_ERROR ("Could not create override with config %"
GST_PTR_FORMAT, tmp->data);
continue;
}
override->buffer_probe_handler =
(GstValidateOverrideBufferHandler) _handle_buffer;
override->buffer_handler =
(GstValidateOverrideBufferHandler) _handle_buffer;
override->event_handler = (GstValidateOverrideEventHandler) _handle_event;
if (target_element_classification)
gst_validate_override_register_by_klass (target_element_classification,
override);
else if (name)
gst_validate_override_register_by_name (name, override);
else
g_assert_not_reached ();
} else {
GST_ERROR ("Wrong configuration '%" GST_PTR_FORMAT
"'element-classification' and output-dir are mandatory fields",
tmp->data);
g_assert_not_reached ();
}
}
return TRUE;
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
ssim,
"GstValidate plugin to run the ssim algorithm on raw"
" video buffers. It allows you to generate png files"
"\n "
" and then check them against pre generated, reference images."
"\n "
" The following parametters can be passed in the configuration file:"
"\n "
" 'element-classification': The target element classification as define in gst_element_class_set_metadata"
"\n "
" 'output-dir': The directory in which the image files will be saved'"
"\n",
gst_validate_ssim_init, VERSION, "LGPL", GST_PACKAGE_NAME,
GST_PACKAGE_ORIGIN)
Reference in a new issue View git blame Copy permalink