X-Git-Url: http://vcs.maemo.org/git/?a=blobdiff_plain;f=gst-plugins-base-subtitles0.10%2Ftests%2Fcheck%2Flibs%2Fvideo.c;fp=gst-plugins-base-subtitles0.10%2Ftests%2Fcheck%2Flibs%2Fvideo.c;h=05b840cb8c8537ef4bd8e817e18486f52c9f5084;hb=57ba96e291a055f69dbfd4ae9f1ae2390e36986e;hp=0000000000000000000000000000000000000000;hpb=be2c98fb83895d10ac44af7b9a9c3e00ca54bf49;p=mafwsubrenderer diff --git a/gst-plugins-base-subtitles0.10/tests/check/libs/video.c b/gst-plugins-base-subtitles0.10/tests/check/libs/video.c new file mode 100644 index 0000000..05b840c --- /dev/null +++ b/gst-plugins-base-subtitles0.10/tests/check/libs/video.c @@ -0,0 +1,770 @@ +/* GStreamer unit test for video + * + * Copyright (C) <2003> David A. Schleef + * Copyright (C) <2006> Jan Schmidt + * Copyright (C) <2008> Tim-Philipp Müller + * + * 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. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include + +#include +#include + +/* These are from the current/old videotestsrc; we check our new public API + * in libgstvideo against the old one to make sure the sizes and offsets + * end up the same */ + +typedef struct paintinfo_struct paintinfo; +struct paintinfo_struct +{ + unsigned char *dest; /* pointer to first byte of video data */ + unsigned char *yp, *up, *vp; /* pointers to first byte of each component + * for both packed/planar YUV and RGB */ + unsigned char *ap; /* pointer to first byte of alpha component */ + unsigned char *endptr; /* pointer to byte beyond last video data */ + int ystride; + int ustride; + int vstride; + int width; + int height; +}; + +struct fourcc_list_struct +{ + const char *fourcc; + const char *name; + int bitspp; + void (*paint_setup) (paintinfo * p, unsigned char *dest); +}; + +static void paint_setup_I420 (paintinfo * p, unsigned char *dest); +static void paint_setup_YV12 (paintinfo * p, unsigned char *dest); +static void paint_setup_YUY2 (paintinfo * p, unsigned char *dest); +static void paint_setup_UYVY (paintinfo * p, unsigned char *dest); +static void paint_setup_YVYU (paintinfo * p, unsigned char *dest); +static void paint_setup_IYU2 (paintinfo * p, unsigned char *dest); +static void paint_setup_Y41B (paintinfo * p, unsigned char *dest); +static void paint_setup_Y42B (paintinfo * p, unsigned char *dest); +static void paint_setup_Y800 (paintinfo * p, unsigned char *dest); +static void paint_setup_AYUV (paintinfo * p, unsigned char *dest); + +#if 0 +static void paint_setup_IMC1 (paintinfo * p, unsigned char *dest); +static void paint_setup_IMC2 (paintinfo * p, unsigned char *dest); +static void paint_setup_IMC3 (paintinfo * p, unsigned char *dest); +static void paint_setup_IMC4 (paintinfo * p, unsigned char *dest); +#endif +static void paint_setup_YUV9 (paintinfo * p, unsigned char *dest); +static void paint_setup_YVU9 (paintinfo * p, unsigned char *dest); + +int fourcc_get_size (struct fourcc_list_struct *fourcc, int w, int h); + +struct fourcc_list_struct fourcc_list[] = { +/* packed */ + {"YUY2", "YUY2", 16, paint_setup_YUY2}, + {"UYVY", "UYVY", 16, paint_setup_UYVY}, + {"Y422", "Y422", 16, paint_setup_UYVY}, + {"UYNV", "UYNV", 16, paint_setup_UYVY}, /* FIXME: UYNV? */ + {"YVYU", "YVYU", 16, paint_setup_YVYU}, + {"AYUV", "AYUV", 32, paint_setup_AYUV}, + + /* interlaced */ + /*{ "IUYV", "IUY2", 16, paint_setup_YVYU }, */ + + /* inverted */ + /*{ "cyuv", "cyuv", 16, paint_setup_YVYU }, */ + + /*{ "Y41P", "Y41P", 12, paint_setup_YVYU }, */ + + /* interlaced */ + /*{ "IY41", "IY41", 12, paint_setup_YVYU }, */ + + /*{ "Y211", "Y211", 8, paint_setup_YVYU }, */ + + /*{ "Y41T", "Y41T", 12, paint_setup_YVYU }, */ + /*{ "Y42P", "Y42P", 16, paint_setup_YVYU }, */ + /*{ "CLJR", "CLJR", 8, paint_setup_YVYU }, */ + /*{ "IYU1", "IYU1", 12, paint_setup_YVYU }, */ + {"IYU2", "IYU2", 24, paint_setup_IYU2}, + +/* planar */ + /* YVU9 */ + {"YVU9", "YVU9", 9, paint_setup_YVU9}, + /* YUV9 */ + {"YUV9", "YUV9", 9, paint_setup_YUV9}, + /* IF09 */ + /* YV12 */ + {"YV12", "YV12", 12, paint_setup_YV12}, + /* I420 */ + {"I420", "I420", 12, paint_setup_I420}, + /* NV12 */ + /* NV21 */ +#if 0 + /* IMC1 */ + {"IMC1", "IMC1", 16, paint_setup_IMC1}, + /* IMC2 */ + {"IMC2", "IMC2", 12, paint_setup_IMC2}, + /* IMC3 */ + {"IMC3", "IMC3", 16, paint_setup_IMC3}, + /* IMC4 */ + {"IMC4", "IMC4", 12, paint_setup_IMC4}, +#endif + /* CLPL */ + /* Y41B */ + {"Y41B", "Y41B", 12, paint_setup_Y41B}, + /* Y42B */ + {"Y42B", "Y42B", 16, paint_setup_Y42B}, + /* Y800 grayscale */ + {"Y800", "Y800", 8, paint_setup_Y800} +}; + +/* returns the size in bytes for one video frame of the given dimensions + * given the fourcc */ +int +fourcc_get_size (struct fourcc_list_struct *fourcc, int w, int h) +{ + paintinfo pi = { NULL, }; + paintinfo *p = π + + p->width = w; + p->height = h; + + fourcc->paint_setup (p, NULL); + + return (unsigned long) p->endptr; +} + +static void +paint_setup_I420 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->ystride = GST_ROUND_UP_4 (p->width); + p->up = p->yp + p->ystride * GST_ROUND_UP_2 (p->height); + p->ustride = GST_ROUND_UP_8 (p->width) / 2; + p->vp = p->up + p->ustride * GST_ROUND_UP_2 (p->height) / 2; + p->vstride = GST_ROUND_UP_8 (p->ystride) / 2; + p->endptr = p->vp + p->vstride * GST_ROUND_UP_2 (p->height) / 2; +} + +static void +paint_setup_YV12 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->ystride = GST_ROUND_UP_4 (p->width); + p->vp = p->yp + p->ystride * GST_ROUND_UP_2 (p->height); + p->vstride = GST_ROUND_UP_8 (p->ystride) / 2; + p->up = p->vp + p->vstride * GST_ROUND_UP_2 (p->height) / 2; + p->ustride = GST_ROUND_UP_8 (p->ystride) / 2; + p->endptr = p->up + p->ustride * GST_ROUND_UP_2 (p->height) / 2; +} + +static void +paint_setup_AYUV (paintinfo * p, unsigned char *dest) +{ + p->ap = dest; + p->yp = dest + 1; + p->up = dest + 2; + p->vp = dest + 3; + p->ystride = p->width * 4; + p->endptr = dest + p->ystride * p->height; +} + +static void +paint_setup_YUY2 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->up = dest + 1; + p->vp = dest + 3; + p->ystride = GST_ROUND_UP_2 (p->width) * 2; + p->endptr = dest + p->ystride * p->height; +} + +static void +paint_setup_UYVY (paintinfo * p, unsigned char *dest) +{ + p->yp = dest + 1; + p->up = dest; + p->vp = dest + 2; + p->ystride = GST_ROUND_UP_2 (p->width) * 2; + p->endptr = dest + p->ystride * p->height; +} + +static void +paint_setup_YVYU (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->up = dest + 3; + p->vp = dest + 1; + p->ystride = GST_ROUND_UP_2 (p->width) * 2; + p->endptr = dest + p->ystride * p->height; +} + +static void +paint_setup_IYU2 (paintinfo * p, unsigned char *dest) +{ + /* untested */ + p->yp = dest + 1; + p->up = dest + 0; + p->vp = dest + 2; + p->ystride = GST_ROUND_UP_4 (p->width * 3); + p->endptr = dest + p->ystride * p->height; +} + +static void +paint_setup_Y41B (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->ystride = GST_ROUND_UP_4 (p->width); + p->up = p->yp + p->ystride * p->height; + p->ustride = GST_ROUND_UP_16 (p->width) / 4; + p->vp = p->up + p->ustride * p->height; + p->vstride = GST_ROUND_UP_16 (p->width) / 4; + p->endptr = p->vp + p->vstride * p->height; +} + +static void +paint_setup_Y42B (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->ystride = GST_ROUND_UP_4 (p->width); + p->up = p->yp + p->ystride * p->height; + p->ustride = GST_ROUND_UP_8 (p->width) / 2; + p->vp = p->up + p->ustride * p->height; + p->vstride = GST_ROUND_UP_8 (p->width) / 2; + p->endptr = p->vp + p->vstride * p->height; +} + +static void +paint_setup_Y800 (paintinfo * p, unsigned char *dest) +{ + /* untested */ + p->yp = dest; + p->ystride = GST_ROUND_UP_4 (p->width); + p->endptr = dest + p->ystride * p->height; +} + +#if 0 +static void +paint_setup_IMC1 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->up = dest + p->width * p->height; + p->vp = dest + p->width * p->height + p->width * p->height / 2; +} + +static void +paint_setup_IMC2 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->vp = dest + p->width * p->height; + p->up = dest + p->width * p->height + p->width / 2; +} + +static void +paint_setup_IMC3 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->up = dest + p->width * p->height + p->width * p->height / 2; + p->vp = dest + p->width * p->height; +} + +static void +paint_setup_IMC4 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->vp = dest + p->width * p->height + p->width / 2; + p->up = dest + p->width * p->height; +} +#endif + +static void +paint_setup_YVU9 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->ystride = GST_ROUND_UP_4 (p->width); + p->vp = p->yp + p->ystride * p->height; + p->vstride = GST_ROUND_UP_4 (p->ystride / 4); + p->up = p->vp + p->vstride * (GST_ROUND_UP_4 (p->height) / 4); + p->ustride = GST_ROUND_UP_4 (p->ystride / 4); + p->endptr = p->up + p->ustride * (GST_ROUND_UP_4 (p->height) / 4); +} + +static void +paint_setup_YUV9 (paintinfo * p, unsigned char *dest) +{ + p->yp = dest; + p->ystride = GST_ROUND_UP_4 (p->width); + p->up = p->yp + p->ystride * p->height; + p->ustride = GST_ROUND_UP_4 (p->ystride / 4); + p->vp = p->up + p->ustride * (GST_ROUND_UP_4 (p->height) / 4); + p->vstride = GST_ROUND_UP_4 (p->ystride / 4); + p->endptr = p->vp + p->vstride * (GST_ROUND_UP_4 (p->height) / 4); +} + +#define gst_video_format_is_packed video_format_is_packed +static gboolean +video_format_is_packed (GstVideoFormat fmt) +{ + switch (fmt) { + case GST_VIDEO_FORMAT_I420: + case GST_VIDEO_FORMAT_YV12: + case GST_VIDEO_FORMAT_Y41B: + case GST_VIDEO_FORMAT_Y42B: + case GST_VIDEO_FORMAT_Y800: + case GST_VIDEO_FORMAT_YUV9: + case GST_VIDEO_FORMAT_YVU9: + return FALSE; + case GST_VIDEO_FORMAT_IYU1: + case GST_VIDEO_FORMAT_YUY2: + case GST_VIDEO_FORMAT_YVYU: + case GST_VIDEO_FORMAT_UYVY: + case GST_VIDEO_FORMAT_AYUV: + case GST_VIDEO_FORMAT_RGBx: + case GST_VIDEO_FORMAT_BGRx: + case GST_VIDEO_FORMAT_xRGB: + case GST_VIDEO_FORMAT_xBGR: + case GST_VIDEO_FORMAT_RGBA: + case GST_VIDEO_FORMAT_BGRA: + case GST_VIDEO_FORMAT_ARGB: + case GST_VIDEO_FORMAT_ABGR: + case GST_VIDEO_FORMAT_RGB: + case GST_VIDEO_FORMAT_BGR: + case GST_VIDEO_FORMAT_RGB8_PALETTED: + return TRUE; + default: + g_return_val_if_reached (FALSE); + } + return FALSE; +} + +GST_START_TEST (test_video_formats) +{ + guint i; + + for (i = 0; i < G_N_ELEMENTS (fourcc_list); ++i) { + GstVideoFormat fmt; + const gchar *s; + guint32 fourcc; + guint w, h; + + s = fourcc_list[i].fourcc; + fourcc = GST_MAKE_FOURCC (s[0], s[1], s[2], s[3]); + fmt = gst_video_format_from_fourcc (fourcc); + + if (fmt == GST_VIDEO_FORMAT_UNKNOWN) + continue; + + GST_INFO ("Fourcc %s, packed=%d", fourcc_list[i].fourcc, + gst_video_format_is_packed (fmt)); + + fail_unless (gst_video_format_is_yuv (fmt)); + + /* use any non-NULL pointer so we can compare against NULL */ + { + paintinfo paintinfo = { 0, }; + fourcc_list[i].paint_setup (&paintinfo, (unsigned char *) s); + if (paintinfo.ap != NULL) { + fail_unless (gst_video_format_has_alpha (fmt)); + } else { + fail_if (gst_video_format_has_alpha (fmt)); + } + } + + for (w = 1; w <= 65; ++w) { + for (h = 1; h <= 65; ++h) { + paintinfo paintinfo = { 0, }; + guint off0, off1, off2, off3; + guint size; + + GST_LOG ("%s, %dx%d", fourcc_list[i].fourcc, w, h); + + paintinfo.width = w; + paintinfo.height = h; + fourcc_list[i].paint_setup (&paintinfo, NULL); + fail_unless_equals_int (gst_video_format_get_row_stride (fmt, 0, w), + paintinfo.ystride); + if (!gst_video_format_is_packed (fmt) + && !gst_video_format_is_gray (fmt)) { + /* planar */ + fail_unless_equals_int (gst_video_format_get_row_stride (fmt, 1, w), + paintinfo.ustride); + fail_unless_equals_int (gst_video_format_get_row_stride (fmt, 2, w), + paintinfo.vstride); + /* check component_width * height against offsets/size somehow? */ + } + + size = gst_video_format_get_size (fmt, w, h); + off0 = gst_video_format_get_component_offset (fmt, 0, w, h); + off1 = gst_video_format_get_component_offset (fmt, 1, w, h); + off2 = gst_video_format_get_component_offset (fmt, 2, w, h); + + fail_unless_equals_int (size, (unsigned long) paintinfo.endptr); + fail_unless_equals_int (off0, (unsigned long) paintinfo.yp); + fail_unless_equals_int (off1, (unsigned long) paintinfo.up); + fail_unless_equals_int (off2, (unsigned long) paintinfo.vp); + + /* should be 0 if there's no alpha component */ + off3 = gst_video_format_get_component_offset (fmt, 3, w, h); + fail_unless_equals_int (off3, (unsigned long) paintinfo.ap); + + /* some gstvideo checks ... (FIXME: fails for Y41B and Y42B; not sure + * if the check or the _get_component_size implementation is wrong) */ + if (fmt != GST_VIDEO_FORMAT_Y41B && fmt != GST_VIDEO_FORMAT_Y42B + && fmt != GST_VIDEO_FORMAT_Y800) { + guint cs0, cs1, cs2, cs3; + + cs0 = gst_video_format_get_component_width (fmt, 0, w) * + gst_video_format_get_component_height (fmt, 0, h); + cs1 = gst_video_format_get_component_width (fmt, 1, w) * + gst_video_format_get_component_height (fmt, 1, h); + cs2 = gst_video_format_get_component_width (fmt, 2, w) * + gst_video_format_get_component_height (fmt, 2, h); + + /* GST_LOG ("cs0=%d,cs1=%d,cs2=%d,off0=%d,off1=%d,off2=%d,size=%d", + cs0, cs1, cs2, off0, off1, off2, size); */ + + if (!gst_video_format_is_packed (fmt)) + fail_unless (cs0 <= off1); + + if (gst_video_format_has_alpha (fmt)) { + cs3 = gst_video_format_get_component_width (fmt, 3, w) * + gst_video_format_get_component_height (fmt, 3, h); + fail_unless (cs3 < size); + /* U/V/alpha shouldn't take up more space than the Y component */ + fail_if (cs1 > cs0, "cs1 (%d) should be <= cs0 (%d)", cs1, cs0); + fail_if (cs2 > cs0, "cs2 (%d) should be <= cs0 (%d)", cs2, cs0); + fail_if (cs3 > cs0, "cs3 (%d) should be <= cs0 (%d)", cs3, cs0); + + /* all components together shouldn't take up more space than size */ + fail_unless (cs0 + cs1 + cs2 + cs3 <= size); + } else { + /* U/V shouldn't take up more space than the Y component */ + fail_if (cs1 > cs0, "cs1 (%d) should be <= cs0 (%d)", cs1, cs0); + fail_if (cs2 > cs0, "cs2 (%d) should be <= cs0 (%d)", cs2, cs0); + + /* all components together shouldn't take up more space than size */ + fail_unless (cs0 + cs1 + cs2 <= size, + "cs0 (%d) + cs1 (%d) + cs2 (%d) should be <= size (%d)", + cs0, cs1, cs2, size); + } + } + } + } + } +} + +GST_END_TEST; + +GST_START_TEST (test_video_formats_rgb) +{ + gint width, height, framerate_n, framerate_d, par_n, par_d; + GstCaps *caps = + gst_video_format_new_caps (GST_VIDEO_FORMAT_RGB, 800, 600, 0, 1, 1, 1); + GstStructure *structure; + + structure = gst_caps_get_structure (caps, 0); + + fail_unless (gst_structure_get_int (structure, "width", &width)); + fail_unless (gst_structure_get_int (structure, "height", &height)); + fail_unless (gst_structure_get_fraction (structure, "framerate", &framerate_n, + &framerate_d)); + fail_unless (gst_structure_get_fraction (structure, "pixel-aspect-ratio", + &par_n, &par_d)); + + fail_unless (width == 800); + fail_unless (height == 600); + fail_unless (framerate_n == 0); + fail_unless (framerate_d == 1); + fail_unless (par_n == 1); + fail_unless (par_d == 1); + + gst_caps_unref (caps); +} + +GST_END_TEST; + +GST_START_TEST (test_video_template_caps) +{ + GstCaps *caps = gst_video_format_new_template_caps (GST_VIDEO_FORMAT_RGB); + gst_caps_unref (caps); +} + +GST_END_TEST; + + +GST_START_TEST (test_dar_calc) +{ + guint display_ratio_n, display_ratio_d; + + /* Ensure that various Display Ratio calculations are correctly done */ + /* video 768x576, par 16/15, display par 16/15 = 4/3 */ + fail_unless (gst_video_calculate_display_ratio (&display_ratio_n, + &display_ratio_d, 768, 576, 16, 15, 16, 15)); + fail_unless (display_ratio_n == 4 && display_ratio_d == 3); + + /* video 720x480, par 32/27, display par 1/1 = 16/9 */ + fail_unless (gst_video_calculate_display_ratio (&display_ratio_n, + &display_ratio_d, 720, 480, 32, 27, 1, 1)); + fail_unless (display_ratio_n == 16 && display_ratio_d == 9); + + /* video 360x288, par 533333/500000, display par 16/15 = + * dar 1599999/1600000 */ + fail_unless (gst_video_calculate_display_ratio (&display_ratio_n, + &display_ratio_d, 360, 288, 533333, 500000, 16, 15)); + fail_unless (display_ratio_n == 1599999 && display_ratio_d == 1280000); +} + +GST_END_TEST; + +GST_START_TEST (test_parse_caps_rgb) +{ + struct + { + const gchar *tmpl_caps_string; + GstVideoFormat fmt; + } formats[] = { + /* 24 bit */ + { + GST_VIDEO_CAPS_RGB, GST_VIDEO_FORMAT_RGB}, { + GST_VIDEO_CAPS_BGR, GST_VIDEO_FORMAT_BGR}, + /* 32 bit (no alpha) */ + { + GST_VIDEO_CAPS_RGBx, GST_VIDEO_FORMAT_RGBx}, { + GST_VIDEO_CAPS_xRGB, GST_VIDEO_FORMAT_xRGB}, { + GST_VIDEO_CAPS_BGRx, GST_VIDEO_FORMAT_BGRx}, { + GST_VIDEO_CAPS_xBGR, GST_VIDEO_FORMAT_xBGR}, + /* 32 bit (with alpha) */ + { + GST_VIDEO_CAPS_RGBA, GST_VIDEO_FORMAT_RGBA}, { + GST_VIDEO_CAPS_ARGB, GST_VIDEO_FORMAT_ARGB}, { + GST_VIDEO_CAPS_BGRA, GST_VIDEO_FORMAT_BGRA}, { + GST_VIDEO_CAPS_ABGR, GST_VIDEO_FORMAT_ABGR} + }; + gint i; + + for (i = 0; i < G_N_ELEMENTS (formats); ++i) { + GstVideoFormat fmt = GST_VIDEO_FORMAT_UNKNOWN; + GstCaps *caps, *caps2; + int w = -1, h = -1; + + caps = gst_caps_from_string (formats[i].tmpl_caps_string); + gst_caps_set_simple (caps, "width", G_TYPE_INT, 2 * (i + 1), "height", + G_TYPE_INT, i + 1, "framerate", GST_TYPE_FRACTION, 15, 1, + "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1, NULL); + g_assert (gst_caps_is_fixed (caps)); + + GST_DEBUG ("testing caps: %" GST_PTR_FORMAT, caps); + + fail_unless (gst_video_format_parse_caps (caps, &fmt, &w, &h)); + fail_unless_equals_int (fmt, formats[i].fmt); + fail_unless_equals_int (w, 2 * (i + 1)); + fail_unless_equals_int (h, i + 1); + + /* make sure they're serialised back correctly */ + caps2 = gst_video_format_new_caps (fmt, w, h, 15, 1, 1, 1); + fail_unless (caps != NULL); + fail_unless (gst_caps_is_equal (caps, caps2)); + + gst_caps_unref (caps); + gst_caps_unref (caps2); + } +} + +GST_END_TEST; + +GST_START_TEST (test_events) +{ + GstEvent *e; + gboolean in_still; + + e = gst_video_event_new_still_frame (TRUE); + fail_if (e == NULL, "Failed to create still frame event"); + fail_unless (gst_video_event_parse_still_frame (e, &in_still), + "Failed to parse still frame event"); + fail_unless (gst_video_event_parse_still_frame (e, NULL), + "Failed to parse still frame event w/ in_still == NULL"); + fail_unless (in_still == TRUE); + gst_event_unref (e); + + e = gst_video_event_new_still_frame (FALSE); + fail_if (e == NULL, "Failed to create still frame event"); + fail_unless (gst_video_event_parse_still_frame (e, &in_still), + "Failed to parse still frame event"); + fail_unless (gst_video_event_parse_still_frame (e, NULL), + "Failed to parse still frame event w/ in_still == NULL"); + fail_unless (in_still == FALSE); + gst_event_unref (e); +} + +GST_END_TEST; + +GST_START_TEST (test_convert_frame) +{ + GstCaps *from_caps, *to_caps; + GstBuffer *from_buffer, *to_buffer; + GError *error = NULL; + gint i; + guint8 *data; + + from_buffer = gst_buffer_new_and_alloc (640 * 480 * 4); + data = GST_BUFFER_DATA (from_buffer); + + for (i = 0; i < 640 * 480; i++) { + data[4 * i + 0] = 0; /* x */ + data[4 * i + 1] = 255; /* R */ + data[4 * i + 2] = 0; /* G */ + data[4 * i + 3] = 0; /* B */ + } + from_caps = gst_video_format_new_caps (GST_VIDEO_FORMAT_xRGB, + 640, 480, 25, 1, 1, 1); + gst_buffer_set_caps (from_buffer, from_caps); + + to_caps = + gst_caps_from_string + ("something/that, does=(string)not, exist=(boolean)FALSE"); + + to_buffer = + gst_video_convert_frame (from_buffer, to_caps, GST_CLOCK_TIME_NONE, + &error); + fail_if (to_buffer != NULL); + fail_unless (error != NULL); + g_error_free (error); + error = NULL; + + gst_caps_unref (to_caps); + to_caps = + gst_video_format_new_caps (GST_VIDEO_FORMAT_I420, 240, 320, 25, 1, 1, 2); + to_buffer = + gst_video_convert_frame (from_buffer, to_caps, GST_CLOCK_TIME_NONE, + &error); + fail_unless (to_buffer != NULL); + fail_unless (gst_caps_can_intersect (to_caps, GST_BUFFER_CAPS (to_buffer))); + fail_unless (error == NULL); + + gst_buffer_unref (from_buffer); + gst_caps_unref (from_caps); + gst_buffer_unref (to_buffer); + gst_caps_unref (to_caps); +} + +GST_END_TEST; + +typedef struct +{ + GMainLoop *loop; + GstBuffer *buffer; + GError *error; +} ConvertFrameContext; + +static void +convert_frame_async_callback (GstBuffer * buf, GError * err, + ConvertFrameContext * cf_data) +{ + cf_data->buffer = buf; + cf_data->error = err; + + g_main_loop_quit (cf_data->loop); +} + +GST_START_TEST (test_convert_frame_async) +{ + GstCaps *from_caps, *to_caps; + GstBuffer *from_buffer; + gint i; + guint8 *data; + GMainLoop *loop; + ConvertFrameContext cf_data = { NULL, NULL, NULL }; + + from_buffer = gst_buffer_new_and_alloc (640 * 480 * 4); + data = GST_BUFFER_DATA (from_buffer); + + for (i = 0; i < 640 * 480; i++) { + data[4 * i + 0] = 0; /* x */ + data[4 * i + 1] = 255; /* R */ + data[4 * i + 2] = 0; /* G */ + data[4 * i + 3] = 0; /* B */ + } + from_caps = gst_video_format_new_caps (GST_VIDEO_FORMAT_xRGB, + 640, 480, 25, 1, 1, 1); + gst_buffer_set_caps (from_buffer, from_caps); + + to_caps = + gst_caps_from_string + ("something/that, does=(string)not, exist=(boolean)FALSE"); + + loop = cf_data.loop = g_main_loop_new (NULL, FALSE); + + gst_video_convert_frame_async (from_buffer, to_caps, GST_CLOCK_TIME_NONE, + (GstVideoConvertFrameCallback) convert_frame_async_callback, &cf_data, + NULL); + + g_main_loop_run (loop); + + fail_if (cf_data.buffer != NULL); + fail_unless (cf_data.error != NULL); + g_error_free (cf_data.error); + cf_data.error = NULL; + + gst_caps_unref (to_caps); + to_caps = + gst_video_format_new_caps (GST_VIDEO_FORMAT_I420, 240, 320, 25, 1, 1, 2); + gst_video_convert_frame_async (from_buffer, to_caps, GST_CLOCK_TIME_NONE, + (GstVideoConvertFrameCallback) convert_frame_async_callback, &cf_data, + NULL); + g_main_loop_run (loop); + fail_unless (cf_data.buffer != NULL); + fail_unless (gst_caps_can_intersect (to_caps, + GST_BUFFER_CAPS (cf_data.buffer))); + fail_unless (cf_data.error == NULL); + + gst_buffer_unref (from_buffer); + gst_caps_unref (from_caps); + gst_buffer_unref (cf_data.buffer); + gst_caps_unref (to_caps); + + g_main_loop_unref (loop); +} + +GST_END_TEST; + +static Suite * +video_suite (void) +{ + Suite *s = suite_create ("video support library"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + tcase_add_test (tc_chain, test_video_formats); + tcase_add_test (tc_chain, test_video_formats_rgb); + tcase_add_test (tc_chain, test_video_template_caps); + tcase_add_test (tc_chain, test_dar_calc); + tcase_add_test (tc_chain, test_parse_caps_rgb); + tcase_add_test (tc_chain, test_events); + tcase_add_test (tc_chain, test_convert_frame); + tcase_add_test (tc_chain, test_convert_frame_async); + + return s; +} + +GST_CHECK_MAIN (video);