mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-27 02:30:35 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-devtools/validate/gst-libs/gst/video/gstvalidatessim.c

1068 lines
30 KiB
C
Raw Blame History

/* GStreamer
*
* Copyright (C) 2015 Raspberry Pi Foundation
* Author: Thibault Saunier <thibault.saunier@collabora.com>
*
* 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.
*/
#include <glib-object.h>
#include <glib.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include "gstvalidatessim.h"
#include "gssim.h"
#include <cairo.h>
#include <gio/gio.h>
#include <gst/gst.h>
#include <gst/video/video.h>
#define GST_CAT_DEFAULT gstvalidatessim_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
#define SIMILARITY_ISSUE_WITH_PREVIOUS g_quark_from_static_string ("ssim::image-not-similar-enough-with-theoretical-reference")
#define SIMILARITY_ISSUE g_quark_from_static_string ("ssim::image-not-similar-enough")
#define GENERAL_INPUT_ERROR g_quark_from_static_string ("ssim::general-file-error")
#define WRONG_FORMAT g_quark_from_static_string ("ssim::wrong-format")
enum
{
PROP_FIRST_PROP = 1,
PROP_RUNNER,
PROP_LAST
};
typedef struct
{
GstVideoConverter *converter;
GstVideoInfo in_info;
GstVideoInfo out_info;
} SSimConverterInfo;
struct _GstValidateSsimPrivate
{
gint width;
gint height;
Gssim *ssim;
GList *converters;
GstVideoInfo out_info;
SSimConverterInfo outconverter_info;
gfloat min_avg_similarity;
gfloat min_lowest_similarity;
GHashTable *ref_frames_cache;
gint fps_n, fps_d;
};
G_DEFINE_TYPE_WITH_CODE (GstValidateSsim, gst_validate_ssim,
GST_TYPE_OBJECT, G_ADD_PRIVATE (GstValidateSsim)
G_IMPLEMENT_INTERFACE (GST_TYPE_VALIDATE_REPORTER, NULL));
static void
ssim_convert_info_free (SSimConverterInfo * info)
{
if (info->converter)
gst_video_converter_free (info->converter);
g_free (info);
}
static gboolean
gst_validate_ssim_convert (GstValidateSsim * self, SSimConverterInfo * info,
GstVideoFrame * frame, GstVideoFrame * converted_frame)
{
gboolean res = TRUE;
GstBuffer *outbuf = NULL;
g_return_val_if_fail (info != NULL, FALSE);
outbuf = gst_buffer_new_allocate (NULL, info->out_info.size, NULL);
if (!gst_video_frame_map (converted_frame, &info->out_info, outbuf,
GST_MAP_WRITE)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map output converted_frame");
goto fail;
}
gst_video_converter_frame (info->converter, frame, converted_frame);
done:
if (outbuf)
gst_buffer_unref (outbuf);
return res;
fail:
res = FALSE;
goto done;
}
static gchar *
gst_validate_ssim_save_out (GstValidateSsim * self, GstBuffer * buffer,
const gchar * ref_file, const gchar * file, const gchar * outfolder)
{
GstVideoFrame frame, converted;
if (!g_file_test (outfolder, G_FILE_TEST_IS_DIR)) {
if (g_mkdir_with_parents (outfolder, 0755) != 0) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not create output directory %s", outfolder);
return NULL;
}
}
if (self->priv->outconverter_info.converter == NULL ||
self->priv->width != self->priv->outconverter_info.out_info.width ||
self->priv->height != self->priv->outconverter_info.out_info.height) {
if (self->priv->outconverter_info.converter)
gst_video_converter_free (self->priv->outconverter_info.converter);
gst_video_info_init (&self->priv->outconverter_info.in_info);
gst_video_info_set_format (&self->priv->outconverter_info.in_info,
GST_VIDEO_FORMAT_GRAY8, self->priv->width, self->priv->height);
gst_video_info_init (&self->priv->outconverter_info.out_info);
gst_video_info_set_format (&self->priv->outconverter_info.out_info,
GST_VIDEO_FORMAT_RGBx, self->priv->width, self->priv->height);
self->priv->outconverter_info.converter =
gst_video_converter_new (&self->priv->outconverter_info.in_info,
&self->priv->outconverter_info.out_info, NULL);
}
if (!gst_video_frame_map (&frame, &self->priv->outconverter_info.in_info,
buffer, GST_MAP_READ)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map output frame");
return NULL;
}
if (gst_validate_ssim_convert (self, &self->priv->outconverter_info,
&frame, &converted)) {
cairo_status_t status;
gchar *bn1 = g_path_get_basename (ref_file);
gchar *bn2 = g_path_get_basename (file);
gchar *fname =
g_strdup_printf ("original_%s.VS.nok_%s.result.png", bn1, bn2);
gchar *outfile = g_build_path (G_DIR_SEPARATOR_S, outfolder, fname, NULL);
cairo_surface_t *out_surface = NULL;
if (g_str_has_suffix (file, ".png")) {
cairo_t *context;
cairo_surface_t *ref_surface =
cairo_image_surface_create_from_png (ref_file);
cairo_surface_t *nok_surface = cairo_image_surface_create_from_png (file);
cairo_surface_t *diff_surface =
cairo_image_surface_create_for_data (GST_VIDEO_FRAME_PLANE_DATA
(&converted, 0), CAIRO_FORMAT_RGB24,
GST_VIDEO_FRAME_WIDTH (&converted),
GST_VIDEO_FRAME_HEIGHT (&converted),
GST_VIDEO_FRAME_PLANE_STRIDE (&converted, 0));
out_surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24,
GST_VIDEO_FRAME_WIDTH (&frame) * 2,
GST_VIDEO_FRAME_HEIGHT (&frame) * 2);
context = cairo_create (out_surface);
cairo_set_operator (context, CAIRO_OPERATOR_OVER);
cairo_set_source_surface (context, ref_surface, 0, 0);
cairo_paint (context);
cairo_translate (context, GST_VIDEO_FRAME_WIDTH (&converted), 0);
cairo_set_source_surface (context, nok_surface, 0, 0);
cairo_paint (context);
cairo_translate (context, -GST_VIDEO_FRAME_WIDTH (&converted) / 2,
GST_VIDEO_FRAME_HEIGHT (&converted));
cairo_set_source_surface (context, diff_surface, 0, 0);
cairo_paint (context);
cairo_surface_destroy (ref_surface);
cairo_surface_destroy (nok_surface);
cairo_surface_destroy (diff_surface);
} else {
out_surface =
cairo_image_surface_create_for_data (GST_VIDEO_FRAME_PLANE_DATA
(&converted, 0), CAIRO_FORMAT_RGB24,
GST_VIDEO_FRAME_WIDTH (&converted),
GST_VIDEO_FRAME_HEIGHT (&converted),
GST_VIDEO_FRAME_PLANE_STRIDE (&converted, 0));
}
if ((status = cairo_surface_write_to_png (out_surface, outfile)) !=
CAIRO_STATUS_SUCCESS) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not save '%s', cairo status is '%s'", outfile,
cairo_status_to_string (status));
}
cairo_surface_destroy (out_surface);
gst_video_frame_unmap (&frame);
gst_video_frame_unmap (&converted);
g_free (bn1);
g_free (bn2);
g_free (fname);
return outfile;
}
return NULL;
}
static gboolean
gst_validate_ssim_configure (GstValidateSsim * self, gint width, gint height)
{
if (width == self->priv->width && height == self->priv->height)
return FALSE;
gssim_configure (self->priv->ssim, width, height);
self->priv->width = width;
self->priv->height = height;
gst_video_info_init (&self->priv->out_info);
gst_video_info_set_format (&self->priv->out_info, GST_VIDEO_FORMAT_I420,
self->priv->width, self->priv->height);
return TRUE;
}
static void
gst_validate_ssim_configure_converter (GstValidateSsim * self, gint index,
gboolean force, GstVideoFormat in_format, gint width, gint height)
{
SSimConverterInfo *info = g_list_nth_data (self->priv->converters, index);
if (!info) {
info = g_new0 (SSimConverterInfo, 1);
self->priv->converters =
g_list_insert (self->priv->converters, info, index);
}
if (force || info->in_info.height != height || info->in_info.width != width ||
info->in_info.finfo->format != in_format) {
gst_video_info_init (&info->in_info);
gst_video_info_set_format (&info->in_info, in_format, width, height);
if (info->converter)
gst_video_converter_free (info->converter);
info->out_info = self->priv->out_info;
if (gst_video_info_is_equal (&info->in_info, &info->out_info))
info->converter = NULL;
else
info->converter =
gst_video_converter_new (&info->in_info, &info->out_info, NULL);
}
}
static GstVideoFormat
_get_format_from_surface (cairo_surface_t * surface)
{
#if G_BYTE_ORDER == G_BIG_ENDIAN
if (cairo_surface_get_content (surface) == CAIRO_CONTENT_COLOR_ALPHA)
return GST_VIDEO_FORMAT_BGRA;
else
return GST_VIDEO_FORMAT_BGRx;
#else
if (cairo_surface_get_content (surface) == CAIRO_CONTENT_COLOR_ALPHA)
return GST_VIDEO_FORMAT_ARGB;
else
return GST_VIDEO_FORMAT_RGBx;
#endif
}
void
gst_validate_ssim_compare_frames (GstValidateSsim * self,
GstVideoFrame * ref_frame, GstVideoFrame * frame, GstBuffer ** outbuf,
gfloat * mean, gfloat * lowest, gfloat * highest)
{
gboolean reconf;
guint8 *outdata = NULL;
GstMapInfo map1, map2, outmap;
GstVideoFrame converted_frame1, converted_frame2;
SSimConverterInfo *convinfo1, *convinfo2;
reconf =
gst_validate_ssim_configure (self, ref_frame->info.width,
ref_frame->info.height);
gst_validate_ssim_configure_converter (self, 0, reconf,
ref_frame->info.finfo->format, ref_frame->info.width,
ref_frame->info.height);
gst_validate_ssim_configure_converter (self, 1, reconf,
frame->info.finfo->format, frame->info.width, frame->info.height);
convinfo1 = (SSimConverterInfo *) g_list_nth_data (self->priv->converters, 0);
if (convinfo1->converter)
gst_validate_ssim_convert (self, convinfo1, ref_frame, &converted_frame1);
else
converted_frame1 = *ref_frame;
convinfo2 = (SSimConverterInfo *) g_list_nth_data (self->priv->converters, 1);
if (convinfo2->converter)
gst_validate_ssim_convert (self, convinfo2, frame, &converted_frame2);
else
converted_frame2 = *frame;
if (!gst_buffer_map (converted_frame1.buffer, &map1, GST_MAP_READ)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map reference frame");
return;
}
if (!gst_buffer_map (converted_frame2.buffer, &map2, GST_MAP_READ)) {
gst_buffer_unmap (converted_frame1.buffer, &map1);
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map compared frame");
return;
}
if (outbuf) {
*outbuf = gst_buffer_new_and_alloc (GST_ROUND_UP_4 (self->priv->width) *
self->priv->height);
if (!gst_buffer_map (*outbuf, &outmap, GST_MAP_WRITE)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map output frame");
gst_buffer_unref (*outbuf);
gst_buffer_unmap (converted_frame1.buffer, &map1);
gst_buffer_unmap (converted_frame2.buffer, &map2);
*outbuf = NULL;
return;
}
outdata = outmap.data;
}
gssim_compare (self->priv->ssim, map1.data, map2.data, outdata, mean,
lowest, highest);
gst_buffer_unmap (ref_frame->buffer, &map1);
gst_buffer_unmap (frame->buffer, &map2);
if (convinfo1->converter)
gst_video_frame_unmap (&converted_frame1);
if (convinfo2->converter)
gst_video_frame_unmap (&converted_frame2);
if (outbuf)
gst_buffer_unmap (*outbuf, &outmap);
}
static gboolean
gst_validate_ssim_get_frame_from_png (GstValidateSsim * self, const char *file,
GstVideoFrame * frame)
{
guint8 *data;
GstBuffer *buf;
GstVideoInfo info;
cairo_surface_t *surface = NULL;
surface = cairo_image_surface_create_from_png (file);
if (surface == NULL
|| (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR, "Could not open %s: %s",
file, cairo_status_to_string (cairo_surface_status (surface)));
return FALSE;
}
gst_video_info_init (&info);
gst_video_info_set_format (&info,
_get_format_from_surface (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface));
cairo_surface_flush (surface);
data = cairo_image_surface_get_data (surface);
buf = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
data, info.size, 0, info.size, surface,
(GDestroyNotify) cairo_surface_destroy);
if (!gst_video_frame_map (frame, &info, buf, GST_MAP_READ)) {
gst_buffer_unref (buf);
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map input frame");
return FALSE;
}
gst_buffer_unref (buf);
return TRUE;
}
static gboolean
gst_validate_ssim_get_frame_from_file (GstValidateSsim * self, const char *file,
GstVideoFrame * frame)
{
gchar *data;
gsize length;
GstBuffer *buf;
GstVideoInfo info;
GstVideoFormat format;
gint strv_length, width, height;
gboolean res = TRUE;
gchar **splited_name = NULL, **splited_size = NULL, *strformat;
GError *error = NULL;
if (g_str_has_suffix (file, ".png")) {
return gst_validate_ssim_get_frame_from_png (self, file, frame);
}
splited_name = g_strsplit (file, ".", -1);
strv_length = g_strv_length (splited_name);
strformat = splited_name[strv_length - 1];
format = gst_video_format_from_string (strformat);
if (format == GST_VIDEO_FORMAT_UNKNOWN) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT, "Unknown format: %s", strformat);
goto fail;
}
splited_size = g_strsplit (splited_name[strv_length - 2], "x", -1);
if (g_strv_length (splited_size) != 2) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT,
"Can not determine video size from filename: %s ", file);
goto fail;
}
errno = 0;
width = g_ascii_strtoull (splited_size[0], NULL, 10);
if (errno) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT,
"Can not determine video size from filename: %s ", file);
goto fail;
}
errno = 0;
height = g_ascii_strtoull (splited_size[1], NULL, 10);
if (errno) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT,
"Can not determine video size from filename: %s ", file);
goto fail;
}
gst_video_info_init (&info);
gst_video_info_set_format (&info, format, width, height);
if (!g_file_get_contents (file, &data, &length, &error)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR, "Could not open %s: %s",
file, error->message);
g_error_free (error);
goto fail;
}
buf = gst_buffer_new_wrapped (data, length);
if (!gst_video_frame_map (frame, &info, buf, GST_MAP_READ)) {
gst_buffer_unref (buf);
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map input frame");
goto fail;
}
gst_buffer_unref (buf);
done:
g_strfreev (splited_name);
g_strfreev (splited_size);
return res;
fail:
res = FALSE;
goto done;
}
static gboolean
_filename_get_timestamp (GstValidateSsim * self, const gchar * filename,
GstClockTime * ts)
{
guint h, m, s, ns;
gchar *bname = g_path_get_basename (filename);
gchar *other = g_strdup (bname);
gboolean res = TRUE;
if (sscanf (bname, "%" GST_VALIDATE_SSIM_TIME_FORMAT "%s", &h, &m, &s, &ns,
other) < 4) {
GST_INFO_OBJECT (self, "Can not sscanf %s", bname);
goto fail;
}
*ts = (h * 3600 + m * 60 + s) * GST_SECOND + ns;
done:
g_free (other);
g_free (bname);
return res;
fail:
res = FALSE;
goto done;
}
typedef struct
{
gchar *path;
GstClockTime ts;
} Frame;
static void
_free_frame (Frame * frame)
{
g_free (frame->path);
}
static gint
_sort_frames (Frame * a, Frame * b)
{
if (a->ts < b->ts)
return -1;
if (a->ts == b->ts)
return 0;
return 1;
}
static Frame *
_find_frame (GstValidateSsim * self, GArray * frames, GstClockTime ts,
gboolean get_next)
{
guint i;
Frame *lframe = &g_array_index (frames, Frame, 0);
if (self->priv->fps_n) {
gint64 frame_number = gst_util_uint64_scale (ts, self->priv->fps_n,
self->priv->fps_d * GST_SECOND);
if (frames->len < frame_number)
return NULL;
return &g_array_index (frames, Frame, frame_number);
}
if (frames->len == 1) {
Frame *iframe = &g_array_index (frames, Frame, 0);
if (iframe->ts == ts)
return iframe;
return NULL;
}
for (i = 1; i < frames->len; i++) {
Frame *iframe = &g_array_index (frames, Frame, i);
if (ts >= lframe->ts && iframe->ts > ts) {
if (get_next)
return iframe;
return lframe;
} else if (i + 1 == frames->len) {
return iframe;
}
lframe = iframe;
}
return NULL;
}
static GArray *
_get_ref_frame_cache (GstValidateSsim * self, const gchar * ref_file)
{
GFile *ref_dir_file = NULL;
GFileInfo *info;
GFileEnumerator *fenum;
GArray *frames = NULL;
gchar *ref_dir = NULL;
ref_dir = g_path_get_dirname (ref_file);
frames = g_hash_table_lookup (self->priv->ref_frames_cache, ref_file);
if (frames)
goto done;
ref_dir_file = g_file_new_for_path (ref_dir);
if (!(fenum = g_file_enumerate_children (ref_dir_file,
"standard::*", G_FILE_QUERY_INFO_NONE, NULL, NULL))) {
GST_INFO ("%s is not a folder", ref_dir);
goto done;
}
for (info = g_file_enumerator_next_file (fenum, NULL, NULL);
info; info = g_file_enumerator_next_file (fenum, NULL, NULL)) {
Frame iframe;
const gchar *display_name = g_file_info_get_display_name (info);
if (!_filename_get_timestamp (self, display_name, &iframe.ts)) {
g_object_unref (info);
continue;
}
iframe.path = g_build_path (G_DIR_SEPARATOR_S,
ref_dir, g_file_info_get_name (info), NULL);
g_object_unref (info);
if (!frames) {
frames = g_array_new (TRUE, TRUE, sizeof (Frame));
g_array_set_clear_func (frames, (GDestroyNotify) _free_frame);
}
g_array_append_val (frames, iframe);
}
g_object_unref (fenum);
if (frames) {
g_array_sort (frames, (GCompareFunc) _sort_frames);
g_hash_table_insert (self->priv->ref_frames_cache, g_strdup (ref_dir),
frames);
}
done:
g_clear_object (&ref_dir_file);
g_free (ref_dir);
return frames;
}
static gchar *
_get_ref_file_path (GstValidateSsim * self, const gchar * ref_file,
const gchar * file, gboolean get_next)
{
Frame *frame;
GArray *frames;
gchar *real_ref_file = NULL;
GstClockTime file_ts;
if (!g_strrstr (ref_file, "*"))
return g_strdup (ref_file);
if (!_filename_get_timestamp (self, file, &file_ts)) {
goto done;
}
frames = _get_ref_frame_cache (self, ref_file);
if (frames) {
frame = _find_frame (self, frames, file_ts, get_next);
if (frame)
real_ref_file = g_strdup (frame->path);
}
done:
return real_ref_file;
}
static gboolean
gst_validate_ssim_compare_image_file (GstValidateSsim * self,
const gchar * ref_file, const gchar * file, gfloat * mean, gfloat * lowest,
gfloat * highest, const gchar * outfolder)
{
GstBuffer *outbuf = NULL, **poutbuf = NULL;
gboolean res = TRUE;
GstVideoFrame ref_frame, frame;
gchar *real_ref_file = NULL;
gchar *output_failure_image = NULL, *failure_info = NULL;
real_ref_file = _get_ref_file_path (self, ref_file, file, FALSE);
if (!real_ref_file) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not find ref file: %s for file: %s", ref_file, file);
goto fail;
}
if (!gst_validate_ssim_get_frame_from_file (self, real_ref_file, &ref_frame))
goto fail;
if (!gst_validate_ssim_get_frame_from_file (self, file, &frame)) {
gst_video_frame_unmap (&ref_frame);
goto fail;
}
if (outfolder) {
poutbuf = &outbuf;
}
gst_validate_ssim_compare_frames (self, &ref_frame, &frame,
poutbuf, mean, lowest, highest);
if (*mean < self->priv->min_avg_similarity) {
GstClockTime ref_ts, f_ts;
gst_video_frame_unmap (&ref_frame);
gst_video_frame_unmap (&frame);
_filename_get_timestamp (self, real_ref_file, &ref_ts);
_filename_get_timestamp (self, file, &f_ts);
if (g_strcmp0 (ref_file, real_ref_file) && ref_ts != f_ts) {
gchar *tmpref = real_ref_file;
real_ref_file = _get_ref_file_path (self, ref_file, file, TRUE);
GST_VALIDATE_REPORT (self, SIMILARITY_ISSUE_WITH_PREVIOUS,
"\nComparing %s with %s failed, (mean %f "
" min %f), checking next %s\n",
tmpref, file, *mean, *lowest, real_ref_file);
g_free (tmpref);
res = gst_validate_ssim_compare_image_file (self,
real_ref_file, file, mean, lowest, highest, outfolder);
goto done;
}
if (outbuf)
output_failure_image =
gst_validate_ssim_save_out (self, outbuf, real_ref_file, file,
outfolder);
if (output_failure_image)
failure_info =
g_strdup_printf (" (See %s to check differences in images)",
output_failure_image);
GST_VALIDATE_REPORT (self, SIMILARITY_ISSUE,
"Average similarity '%f' between %s and %s inferior"
" than the minimum average: %f%s", *mean,
real_ref_file, file, self->priv->min_avg_similarity, failure_info);
goto fail;
}
if (*lowest < self->priv->min_lowest_similarity) {
if (outbuf)
output_failure_image =
gst_validate_ssim_save_out (self, outbuf, real_ref_file, file,
outfolder);
if (output_failure_image)
failure_info =
g_strdup_printf (" (See %s to check differences in images)",
output_failure_image);
GST_VALIDATE_REPORT (self, SIMILARITY_ISSUE,
"Lowest similarity '%f' between %s and %s inferior"
" than the minimum lowest similarity: %f%s", *lowest,
real_ref_file, file, self->priv->min_lowest_similarity, failure_info);
gst_video_frame_unmap (&ref_frame);
gst_video_frame_unmap (&frame);
goto fail;
}
gst_video_frame_unmap (&ref_frame);
gst_video_frame_unmap (&frame);
done:
g_free (failure_info);
g_free (output_failure_image);
g_free (real_ref_file);
if (outbuf)
gst_buffer_unref (outbuf);
return res;
fail:
res = FALSE;
goto done;
}
static gboolean
_check_directory (GstValidateSsim * self, const gchar * ref_dir,
const gchar * compared_dir, gfloat * mean, gfloat * lowest,
gfloat * highest, const gchar * outfolder)
{
gint nfiles = 0, nnotfound = 0, nfailures = 0;
gboolean res = TRUE;
GFileInfo *info;
GFileEnumerator *fenum;
gfloat min_avg = 1.0, min_min = 1.0, total_avg = 0;
GFile *file = g_file_new_for_path (ref_dir);
if (!(fenum = g_file_enumerate_children (file,
"standard::*", G_FILE_QUERY_INFO_NONE, NULL, NULL))) {
GST_INFO ("%s is not a folder", ref_dir);
res = FALSE;
goto done;
}
for (info = g_file_enumerator_next_file (fenum, NULL, NULL);
info; info = g_file_enumerator_next_file (fenum, NULL, NULL)) {
if (g_file_info_get_file_type (info) == G_FILE_TYPE_REGULAR ||
g_file_info_get_file_type (info) == G_FILE_TYPE_SYMBOLIC_LINK) {
gchar *compared_file = g_build_path (G_DIR_SEPARATOR_S,
compared_dir, g_file_info_get_name (info), NULL);
gchar *ref_file = NULL;
if (!g_file_test (compared_file, G_FILE_TEST_IS_REGULAR)) {
GST_ERROR_OBJECT (self, "Could not find file %s", compared_file);
nnotfound++;
res = FALSE;
} else {
ref_file =
g_build_path (G_DIR_SEPARATOR_S, ref_dir,
g_file_info_get_name (info), NULL);
if (!gst_validate_ssim_compare_image_files (self, ref_file,
compared_file, mean, lowest, highest, outfolder)) {
nfailures++;
res = FALSE;
} else {
nfiles++;
}
}
min_avg = MIN (min_avg, *mean);
min_min = MIN (min_min, *lowest);
total_avg += *mean;
gst_validate_printf (NULL,
"<position: %s duration: %" GST_TIME_FORMAT
" avg: %f min: %f (Passed: %d failed: %d, %d not found)/>\r",
g_file_info_get_display_name (info),
GST_TIME_ARGS (GST_CLOCK_TIME_NONE),
*mean, *lowest, nfiles, nfailures, nnotfound);
g_free (compared_file);
g_free (ref_file);
}
g_object_unref (info);
}
if (nfiles == 0) {
gst_validate_printf (NULL, "\nNo files to verify.\n");
} else {
gst_validate_printf (NULL,
"\nAverage similarity: %f, min_avg: %f, min_min: %f\n",
total_avg / nfiles, min_avg, min_min);
}
done:
gst_object_unref (file);
if (fenum)
gst_object_unref (fenum);
return res;
}
gboolean
gst_validate_ssim_compare_image_files (GstValidateSsim * self,
const gchar * ref_file, const gchar * file, gfloat * mean, gfloat * lowest,
gfloat * highest, const gchar * outfolder)
{
if (g_file_test (ref_file, G_FILE_TEST_IS_DIR)) {
if (!g_file_test (file, G_FILE_TEST_IS_DIR)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"%s is a directory but %s is not", ref_file, file);
return FALSE;
}
return _check_directory (self, ref_file, file, mean, lowest, highest,
outfolder);
} else {
return gst_validate_ssim_compare_image_file (self, ref_file, file, mean,
lowest, highest, outfolder);
}
}
static void
gst_validate_ssim_get_property (GObject * object,
guint property_id, GValue * value, GParamSpec * pspec)
{
switch (property_id) {
case PROP_RUNNER:
/* we assume the runner is valid as long as this scenario is,
* no ref taken */
g_value_set_object (value,
gst_validate_reporter_get_runner (GST_VALIDATE_REPORTER (object)));
break;
default:
break;
}
}
static void
gst_validate_ssim_set_property (GObject * object,
guint property_id, const GValue * value, GParamSpec * pspec)
{
switch (property_id) {
case PROP_RUNNER:
/* we assume the runner is valid as long as this scenario is,
* no ref taken */
gst_validate_reporter_set_runner (GST_VALIDATE_REPORTER (object),
g_value_get_object (value));
break;
default:
break;
}
}
static void
gst_validate_ssim_dispose (GObject * object)
{
GstValidateSsim *self = GST_VALIDATE_SSIM (object);
void (*chain_up) (GObject *) =
((GObjectClass *) gst_validate_ssim_parent_class)->dispose;
gst_object_unref (self->priv->ssim);
chain_up (object);
}
static void
gst_validate_ssim_finalize (GObject * object)
{
GstValidateSsim *self = GST_VALIDATE_SSIM (object);
void (*chain_up) (GObject *) =
((GObjectClass *) gst_validate_ssim_parent_class)->finalize;
g_list_free_full (self->priv->converters,
(GDestroyNotify) ssim_convert_info_free);
if (self->priv->outconverter_info.converter)
gst_video_converter_free (self->priv->outconverter_info.converter);
g_hash_table_unref (self->priv->ref_frames_cache);
chain_up (object);
}
static gpointer
_register_issues (gpointer data)
{
gst_validate_issue_register (gst_validate_issue_new_full (SIMILARITY_ISSUE,
"Compared images were not similar enough",
"The images checker detected that the images"
" it is comparing do not have the similarity"
" level defined with min-avg-similarity or"
" min-lowest-similarity", GST_VALIDATE_REPORT_LEVEL_CRITICAL,
GST_VALIDATE_ISSUE_FLAGS_FULL_DETAILS |
GST_VALIDATE_ISSUE_FLAGS_NO_BACKTRACE));
gst_validate_issue_register (gst_validate_issue_new
(SIMILARITY_ISSUE_WITH_PREVIOUS,
"Comparison with theoretical reference image failed",
" In a case where we have reference frames with the following"
" timestamps: [0.00, 0.10, 0.20, 0.30], comparing a frame with"
" 0.05 as a timestamp will be done with the first frame."
" If this fails, a ssim::image-not-similar-enough-with-theoretical-reference"
" warning is issued and the system then tries with the second reference frame.",
GST_VALIDATE_REPORT_LEVEL_WARNING));
gst_validate_issue_register (gst_validate_issue_new (GENERAL_INPUT_ERROR,
"Something went wrong handling image files for ssim comparison",
"An error occurred when working with input files",
GST_VALIDATE_REPORT_LEVEL_CRITICAL));
gst_validate_issue_register (gst_validate_issue_new (WRONG_FORMAT,
"The format or dimensions of the compared images do not match",
"The format or dimensions of the compared images do not match",
GST_VALIDATE_REPORT_LEVEL_CRITICAL));
return NULL;
}
static void
gst_validate_ssim_class_init (GstValidateSsimClass * klass)
{
GObjectClass *oclass = G_OBJECT_CLASS (klass);
static GOnce _once = G_ONCE_INIT;
GST_DEBUG_CATEGORY_INIT (gstvalidatessim_debug, "validatessim", 0,
"Validate ssim plugin");
oclass->get_property = gst_validate_ssim_get_property;
oclass->set_property = gst_validate_ssim_set_property;
oclass->dispose = gst_validate_ssim_dispose;
oclass->finalize = gst_validate_ssim_finalize;
g_once (&_once, _register_issues, NULL);
g_object_class_install_property (oclass, PROP_RUNNER,
g_param_spec_object ("validate-runner", "VALIDATE Runner",
"The Validate runner to report errors to",
GST_TYPE_VALIDATE_RUNNER,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
}
static void
gst_validate_ssim_init (GstValidateSsim * self)
{
self->priv = gst_validate_ssim_get_instance_private (self);
self->priv->ssim = gssim_new ();
self->priv->ref_frames_cache = g_hash_table_new_full (g_str_hash,
g_str_equal, g_free, (GDestroyNotify) g_array_unref);
}
GstValidateSsim *
gst_validate_ssim_new (GstValidateRunner * runner,
gfloat min_avg_similarity, gfloat min_lowest_similarity,
gint fps_n, gint fps_d)
{
GstValidateSsim *self =
g_object_new (GST_VALIDATE_SSIM_TYPE, "validate-runner", runner, NULL);
self->priv->min_avg_similarity = min_avg_similarity;
self->priv->min_lowest_similarity = min_lowest_similarity;
self->priv->fps_n = fps_n;
self->priv->fps_d = fps_d;
gst_validate_reporter_set_name (GST_VALIDATE_REPORTER (self),
g_strdup ("gst-validate-images-checker"));
return self;
}
Reference in a new issue View git blame Copy permalink