tests/check/elements/videocrop.c

   1 /* GStreamer unit test for the videocrop element
   2  * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 #ifdef HAVE_VALGRIND
  25 # include <valgrind/valgrind.h>
  26 #endif
  27
  28 #include <unistd.h>
  29
  30 #include <gst/check/gstcheck.h>
  31 #include <gst/video/video.h>
  32 #include <gst/base/gstbasetransform.h>
  33
  34 /* return a list of caps where we only need to set
  35  * width and height to get fixed caps */
  36 static GList *
  37 video_crop_get_test_caps (GstElement * videocrop)
  38 {
  39   GstCaps *templ, *allowed_caps;
  40   GstPad *srcpad;
  41   GList *list = NULL;
  42   guint i;
  43
  44   srcpad = gst_element_get_static_pad (videocrop, "src");
  45   fail_unless (srcpad != NULL);
  46   templ = gst_pad_get_pad_template_caps (srcpad);
  47   fail_unless (templ != NULL);
  48
  49   allowed_caps = gst_caps_normalize (templ);
  50
  51   for (i = 0; i < gst_caps_get_size (allowed_caps); ++i) {
  52     GstStructure *new_structure;
  53     GstCaps *single_caps;
  54
  55     single_caps = gst_caps_new_empty ();
  56     new_structure =
  57         gst_structure_copy (gst_caps_get_structure (allowed_caps, i));
  58     gst_structure_set (new_structure, "framerate", GST_TYPE_FRACTION,
  59         1, 1, NULL);
  60     gst_structure_remove_field (new_structure, "width");
  61     gst_structure_remove_field (new_structure, "height");
  62     gst_caps_append_structure (single_caps, new_structure);
  63
  64     GST_DEBUG ("have caps %" GST_PTR_FORMAT, single_caps);
  65     /* should be fixed without width/height */
  66     fail_unless (gst_caps_is_fixed (single_caps));
  67
  68     list = g_list_prepend (list, single_caps);
  69   }
  70
  71   gst_caps_unref (allowed_caps);
  72   gst_object_unref (srcpad);
  73
  74   return list;
  75 }
  76
  77 GST_START_TEST (test_unit_sizes)
  78 {
  79   GstBaseTransformClass *csp_klass, *vcrop_klass;
  80   GstElement *videocrop, *csp;
  81   GList *caps_list, *l;
  82
  83   videocrop = gst_element_factory_make ("videocrop", "videocrop");
  84   fail_unless (videocrop != NULL, "Failed to create videocrop element");
  85   vcrop_klass = GST_BASE_TRANSFORM_GET_CLASS (videocrop);
  86
  87   csp = gst_element_factory_make ("videoconvert", "csp");
  88   fail_unless (csp != NULL, "Failed to create videoconvert element");
  89   csp_klass = GST_BASE_TRANSFORM_GET_CLASS (csp);
  90
  91   caps_list = video_crop_get_test_caps (videocrop);
  92
  93   for (l = caps_list; l != NULL; l = l->next) {
  94     const struct
  95     {
  96       gint width, height;
  97     } sizes_to_try[] = {
  98       {
  99       160, 120}, {
 100       161, 120}, {
 101       160, 121}, {
 102       161, 121}, {
 103       159, 120}, {
 104       160, 119}, {
 105       159, 119}, {
 106       159, 121}
 107     };
 108     GstStructure *s;
 109     GstCaps *caps;
 110     gint i;
 111
 112     caps = gst_caps_copy (GST_CAPS (l->data));
 113     s = gst_caps_get_structure (caps, 0);
 114     fail_unless (s != NULL);
 115
 116     for (i = 0; i < G_N_ELEMENTS (sizes_to_try); ++i) {
 117       gchar *caps_str;
 118       gsize csp_size = 0;
 119       gsize vc_size = 0;
 120
 121       gst_structure_set (s, "width", G_TYPE_INT, sizes_to_try[i].width,
 122           "height", G_TYPE_INT, sizes_to_try[i].height, NULL);
 123
 124       caps_str = gst_caps_to_string (caps);
 125       GST_INFO ("Testing unit size for %s", caps_str);
 126
 127       /* skip if videoconvert doesn't support these caps
 128        * (only works with gst-plugins-base 0.10.9.1 or later) */
 129       if (!csp_klass->get_unit_size ((GstBaseTransform *) csp, caps, &csp_size)) {
 130         GST_INFO ("videoconvert does not support format %s", caps_str);
 131         g_free (caps_str);
 132         continue;
 133       }
 134
 135       fail_unless (vcrop_klass->get_unit_size ((GstBaseTransform *) videocrop,
 136               caps, &vc_size));
 137
 138       fail_unless (vc_size == csp_size,
 139           "videocrop and videoconvert return different unit sizes for "
 140           "caps %s: vc_size=%d, csp_size=%d", caps_str, vc_size, csp_size);
 141
 142       g_free (caps_str);
 143     }
 144
 145     gst_caps_unref (caps);
 146   }
 147
 148   g_list_foreach (caps_list, (GFunc) gst_caps_unref, NULL);
 149   g_list_free (caps_list);
 150
 151   gst_object_unref (csp);
 152   gst_object_unref (videocrop);
 153 }
 154
 155 GST_END_TEST;
 156
 157 typedef struct
 158 {
 159   GstElement *pipeline;
 160   GstElement *src;
 161   GstElement *filter;
 162   GstElement *crop;
 163   GstElement *sink;
 164   GstBuffer *last_buf;
 165   GstCaps *last_caps;
 166 } GstVideoCropTestContext;
 167
 168 static void
 169 handoff_cb (GstElement * sink, GstBuffer * buf, GstPad * pad,
 170     GstVideoCropTestContext * ctx)
 171 {
 172   GstCaps *caps;
 173
 174   gst_buffer_replace (&ctx->last_buf, buf);
 175   caps = gst_pad_get_current_caps (pad);
 176   gst_caps_replace (&ctx->last_caps, caps);
 177   gst_caps_unref (caps);
 178 }
 179
 180 static void
 181 videocrop_test_cropping_init_context (GstVideoCropTestContext * ctx)
 182 {
 183   fail_unless (ctx != NULL);
 184
 185   ctx->pipeline = gst_pipeline_new ("pipeline");
 186   fail_unless (ctx->pipeline != NULL);
 187   ctx->src = gst_element_factory_make ("videotestsrc", "src");
 188   fail_unless (ctx->src != NULL, "Failed to create videotestsrc element");
 189   ctx->filter = gst_element_factory_make ("capsfilter", "filter");
 190   fail_unless (ctx->filter != NULL, "Failed to create capsfilter element");
 191   ctx->crop = gst_element_factory_make ("videocrop", "crop");
 192   fail_unless (ctx->crop != NULL, "Failed to create videocrop element");
 193   ctx->sink = gst_element_factory_make ("fakesink", "sink");
 194   fail_unless (ctx->sink != NULL, "Failed to create fakesink element");
 195
 196   gst_bin_add_many (GST_BIN (ctx->pipeline), ctx->src, ctx->filter,
 197       ctx->crop, ctx->sink, NULL);
 198   gst_element_link_many (ctx->src, ctx->filter, ctx->crop, ctx->sink, NULL);
 199
 200   /* set pattern to 'red' - for our purposes it doesn't matter anyway */
 201   g_object_set (ctx->src, "pattern", 4, NULL);
 202
 203   g_object_set (ctx->sink, "signal-handoffs", TRUE, NULL);
 204   g_signal_connect (ctx->sink, "preroll-handoff", G_CALLBACK (handoff_cb), ctx);
 205
 206   ctx->last_buf = NULL;
 207   ctx->last_caps = NULL;
 208
 209   GST_LOG ("context inited");
 210 }
 211
 212 static void
 213 videocrop_test_cropping_deinit_context (GstVideoCropTestContext * ctx)
 214 {
 215   GST_LOG ("deiniting context");
 216
 217   gst_element_set_state (ctx->pipeline, GST_STATE_NULL);
 218   gst_object_unref (ctx->pipeline);
 219   gst_buffer_replace (&ctx->last_buf, NULL);
 220   gst_caps_replace (&ctx->last_caps, NULL);
 221   memset (ctx, 0x00, sizeof (GstVideoCropTestContext));
 222 }
 223
 224 typedef void (*GstVideoCropTestBufferFunc) (GstBuffer * buffer, GstCaps * caps);
 225
 226 static void
 227 videocrop_test_cropping (GstVideoCropTestContext * ctx, GstCaps * in_caps,
 228     gint left, gint right, gint top, gint bottom,
 229     GstVideoCropTestBufferFunc func)
 230 {
 231   GST_LOG ("lrtb = %03u %03u %03u %03u, caps = %" GST_PTR_FORMAT, left, right,
 232       top, bottom, in_caps);
 233
 234   g_object_set (ctx->filter, "caps", in_caps, NULL);
 235
 236   g_object_set (ctx->crop, "left", left, "right", right, "top", top,
 237       "bottom", bottom, NULL);
 238
 239   /* this will fail if videotestsrc doesn't support our format; we need
 240    * videotestsrc from -base CVS 0.10.9.1 with RGBA and AYUV support */
 241   fail_unless (gst_element_set_state (ctx->pipeline,
 242           GST_STATE_PAUSED) != GST_STATE_CHANGE_FAILURE);
 243   fail_unless (gst_element_get_state (ctx->pipeline, NULL, NULL,
 244           -1) == GST_STATE_CHANGE_SUCCESS);
 245
 246   if (func != NULL) {
 247     func (ctx->last_buf, ctx->last_caps);
 248   }
 249
 250   gst_element_set_state (ctx->pipeline, GST_STATE_NULL);
 251 }
 252
 253 static void
 254 check_1x1_buffer (GstBuffer * buf, GstCaps * caps)
 255 {
 256   GstVideoInfo info;
 257   GstVideoFrame frame;
 258   /* the exact values we check for come from videotestsrc */
 259   static const guint yuv_values[] = { 81, 90, 240, 255 };
 260   static const guint rgb_values[] = { 0xff, 0, 0, 255 };
 261   static const guint gray_values[] = { 63, 63, 63, 255 };
 262   const guint *values;
 263   guint i;
 264   const GstVideoFormatInfo *finfo;
 265
 266   fail_unless (buf != NULL);
 267   fail_unless (caps != NULL);
 268
 269   fail_unless (gst_video_info_from_caps (&info, caps));
 270   fail_unless (gst_video_frame_map (&frame, &info, buf, GST_MAP_READ));
 271
 272   finfo = info.finfo;
 273
 274
 275   if (GST_VIDEO_INFO_FORMAT (&info) == GST_VIDEO_FORMAT_Y800)
 276     values = gray_values;
 277   else if (GST_VIDEO_INFO_IS_YUV (&info))
 278     values = yuv_values;
 279   else if (GST_VIDEO_INFO_IS_GRAY (&info))
 280     values = gray_values;
 281   else
 282     values = rgb_values;
 283
 284   GST_MEMDUMP ("buffer", GST_VIDEO_FRAME_PLANE_DATA (&frame, 0), 8);
 285
 286   for (i = 0; i < GST_VIDEO_FRAME_N_COMPONENTS (&frame); i++) {
 287     guint8 *data = GST_VIDEO_FRAME_COMP_DATA (&frame, i);
 288
 289     GST_DEBUG ("W: %d", GST_VIDEO_FORMAT_INFO_W_SUB (finfo, i));
 290     GST_DEBUG ("H: %d", GST_VIDEO_FORMAT_INFO_H_SUB (finfo, i));
 291
 292     if (GST_VIDEO_FORMAT_INFO_W_SUB (finfo,
 293             i) >= GST_VIDEO_FRAME_WIDTH (&frame))
 294       continue;
 295     if (GST_VIDEO_FORMAT_INFO_H_SUB (finfo,
 296             i) >= GST_VIDEO_FRAME_HEIGHT (&frame))
 297       continue;
 298
 299     if (GST_VIDEO_FORMAT_INFO_BITS (finfo) == 8) {
 300       fail_unless_equals_int (data[0], values[i]);
 301     } else if (GST_VIDEO_FORMAT_INFO_BITS (finfo) == 16) {
 302       guint16 pixels, val;
 303       gint depth;
 304
 305       if (GST_VIDEO_FORMAT_INFO_IS_LE (finfo))
 306         pixels = GST_READ_UINT16_LE (data);
 307       else
 308         pixels = GST_READ_UINT16_BE (data);
 309
 310       depth = GST_VIDEO_FORMAT_INFO_DEPTH (finfo, i);
 311       val = pixels >> GST_VIDEO_FORMAT_INFO_SHIFT (finfo, i);
 312       val = val & ((1 << depth) - 1);
 313
 314       GST_DEBUG ("val %08x %d : %d", pixels, i, val);
 315       fail_unless_equals_int (val, values[i] >> (8 - depth));
 316     } else {
 317     }
 318   }
 319
 320   gst_video_frame_unmap (&frame);
 321
 322   /*
 323      fail_unless_equals_int ((pixel & rmask) >> rshift, 0xff);
 324      fail_unless_equals_int ((pixel & gmask) >> gshift, 0x00);
 325      fail_unless_equals_int ((pixel & bmask) >> bshift, 0x00);
 326    */
 327 }
 328
 329 GST_START_TEST (test_crop_to_1x1)
 330 {
 331   GstVideoCropTestContext ctx;
 332   GList *caps_list, *node;
 333
 334   videocrop_test_cropping_init_context (&ctx);
 335
 336   caps_list = video_crop_get_test_caps (ctx.crop);
 337
 338   for (node = caps_list; node != NULL; node = node->next) {
 339     GstStructure *s;
 340     GstCaps *caps;
 341
 342     caps = gst_caps_copy (GST_CAPS (node->data));
 343     s = gst_caps_get_structure (caps, 0);
 344     fail_unless (s != NULL);
 345
 346     GST_INFO ("testing format: %" GST_PTR_FORMAT, caps);
 347
 348     gst_structure_set (s, "width", G_TYPE_INT, 160,
 349         "height", G_TYPE_INT, 160, NULL);
 350
 351     videocrop_test_cropping (&ctx, caps, 159, 0, 159, 0, check_1x1_buffer);
 352     /* commented out because they don't really add anything useful check-wise:
 353        videocrop_test_cropping (&ctx, caps, 0, 159, 0, 159, check_1x1_buffer);
 354        videocrop_test_cropping (&ctx, caps, 159, 0, 0, 159, check_1x1_buffer);
 355        videocrop_test_cropping (&ctx, caps, 0, 159, 159, 0, check_1x1_buffer);
 356      */
 357     gst_caps_unref (caps);
 358   }
 359   g_list_foreach (caps_list, (GFunc) gst_caps_unref, NULL);
 360   g_list_free (caps_list);
 361
 362   videocrop_test_cropping_deinit_context (&ctx);
 363 }
 364
 365 GST_END_TEST;
 366
 367 GST_START_TEST (test_cropping)
 368 {
 369   GstVideoCropTestContext ctx;
 370   struct
 371   {
 372     gint width, height;
 373   } sizes_to_try[] = {
 374     {
 375     160, 160}, {
 376     161, 160}, {
 377     160, 161}, {
 378     161, 161}, {
 379     159, 160}, {
 380     160, 159}, {
 381     159, 159}, {
 382     159, 161}
 383   };
 384   GList *caps_list, *node;
 385   gint i;
 386
 387   videocrop_test_cropping_init_context (&ctx);
 388
 389   caps_list = video_crop_get_test_caps (ctx.crop);
 390   node = g_list_nth (caps_list, __i__);
 391
 392   if (node != NULL) {
 393     GstStructure *s;
 394     GstCaps *caps;
 395
 396     caps = gst_caps_copy (GST_CAPS (node->data));
 397     s = gst_caps_get_structure (caps, 0);
 398     fail_unless (s != NULL);
 399
 400     GST_INFO ("testing format: %" GST_PTR_FORMAT, caps);
 401
 402     for (i = 0; i < G_N_ELEMENTS (sizes_to_try); ++i) {
 403       GstCaps *in_caps;
 404
 405       GST_INFO (" - %d x %d", sizes_to_try[i].width, sizes_to_try[i].height);
 406
 407       gst_structure_set (s, "width", G_TYPE_INT, sizes_to_try[i].width,
 408           "height", G_TYPE_INT, sizes_to_try[i].height, NULL);
 409       in_caps = gst_caps_copy (caps);
 410
 411       videocrop_test_cropping (&ctx, in_caps, 0, 0, 0, 0, NULL);
 412       videocrop_test_cropping (&ctx, in_caps, 1, 0, 0, 0, NULL);
 413       videocrop_test_cropping (&ctx, in_caps, 0, 1, 0, 0, NULL);
 414       videocrop_test_cropping (&ctx, in_caps, 0, 0, 1, 0, NULL);
 415       videocrop_test_cropping (&ctx, in_caps, 0, 0, 0, 1, NULL);
 416       videocrop_test_cropping (&ctx, in_caps, 63, 0, 0, 0, NULL);
 417       videocrop_test_cropping (&ctx, in_caps, 0, 63, 0, 0, NULL);
 418       videocrop_test_cropping (&ctx, in_caps, 0, 0, 63, 0, NULL);
 419       videocrop_test_cropping (&ctx, in_caps, 0, 0, 0, 63, NULL);
 420       videocrop_test_cropping (&ctx, in_caps, 63, 0, 0, 1, NULL);
 421       videocrop_test_cropping (&ctx, in_caps, 0, 63, 1, 0, NULL);
 422       videocrop_test_cropping (&ctx, in_caps, 0, 1, 63, 0, NULL);
 423       videocrop_test_cropping (&ctx, in_caps, 1, 0, 0, 63, NULL);
 424       videocrop_test_cropping (&ctx, in_caps, 0, 0, 0, 0, NULL);
 425       videocrop_test_cropping (&ctx, in_caps, 32, 0, 0, 128, NULL);
 426       videocrop_test_cropping (&ctx, in_caps, 0, 32, 128, 0, NULL);
 427       videocrop_test_cropping (&ctx, in_caps, 0, 128, 32, 0, NULL);
 428       videocrop_test_cropping (&ctx, in_caps, 128, 0, 0, 32, NULL);
 429       videocrop_test_cropping (&ctx, in_caps, 1, 1, 1, 1, NULL);
 430       videocrop_test_cropping (&ctx, in_caps, 63, 63, 63, 63, NULL);
 431       videocrop_test_cropping (&ctx, in_caps, 64, 64, 64, 64, NULL);
 432
 433       gst_caps_unref (in_caps);
 434     }
 435
 436     gst_caps_unref (caps);
 437   } else {
 438     GST_INFO ("no caps #%d", __i__);
 439   }
 440   g_list_foreach (caps_list, (GFunc) gst_caps_unref, NULL);
 441   g_list_free (caps_list);
 442
 443   videocrop_test_cropping_deinit_context (&ctx);
 444 }
 445
 446 GST_END_TEST;
 447
 448
 449 static GstPadProbeReturn
 450 buffer_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer data)
 451 {
 452   GstBuffer **p_buf = data;
 453   GstBuffer *buf = GST_PAD_PROBE_INFO_BUFFER (info);
 454
 455   gst_buffer_replace (p_buf, buf);
 456
 457   return GST_PAD_PROBE_OK;      /* keep data */
 458 }
 459
 460 GST_START_TEST (test_passthrough)
 461 {
 462   GstStateChangeReturn state_ret;
 463   GstVideoCropTestContext ctx;
 464   GstPad *srcpad;
 465   GstBuffer *gen_buf = NULL;    /* buffer generated by videotestsrc */
 466
 467   videocrop_test_cropping_init_context (&ctx);
 468
 469   g_object_set (ctx.src, "num-buffers", 1, NULL);
 470
 471   srcpad = gst_element_get_static_pad (ctx.src, "src");
 472   fail_unless (srcpad != NULL);
 473   gst_pad_add_probe (srcpad, GST_PAD_PROBE_TYPE_BUFFER, buffer_probe_cb,
 474       &gen_buf, NULL);
 475   gst_object_unref (srcpad);
 476
 477   g_object_set (ctx.crop, "left", 0, "right", 0, "top", 0, "bottom", 0, NULL);
 478
 479   state_ret = gst_element_set_state (ctx.pipeline, GST_STATE_PAUSED);
 480   fail_unless (state_ret != GST_STATE_CHANGE_FAILURE,
 481       "couldn't set pipeline to PAUSED state");
 482
 483   state_ret = gst_element_get_state (ctx.pipeline, NULL, NULL, -1);
 484   fail_unless (state_ret == GST_STATE_CHANGE_SUCCESS,
 485       "pipeline failed to go to PAUSED state");
 486
 487   fail_unless (gen_buf != NULL);
 488   fail_unless (ctx.last_buf != NULL);
 489
 490   /* pass through should do nothing */
 491   fail_unless (gen_buf == ctx.last_buf);
 492
 493   videocrop_test_cropping_deinit_context (&ctx);
 494
 495   fail_unless_equals_int (GST_MINI_OBJECT_REFCOUNT_VALUE (gen_buf), 1);
 496   gst_buffer_unref (gen_buf);
 497 }
 498
 499 GST_END_TEST;
 500
 501 static gint
 502 notgst_value_list_get_nth_int (const GValue * list_val, guint n)
 503 {
 504   const GValue *v;
 505
 506   fail_unless (GST_VALUE_HOLDS_LIST (list_val));
 507   fail_unless (n < gst_value_list_get_size (list_val));
 508
 509   v = gst_value_list_get_value (list_val, n);
 510   fail_unless (G_VALUE_HOLDS_INT (v));
 511   return g_value_get_int (v);
 512 }
 513
 514 GST_START_TEST (test_caps_transform)
 515 {
 516   GstVideoCropTestContext ctx;
 517   GstBaseTransformClass *klass;
 518   GstBaseTransform *crop;
 519   const GValue *w_val;
 520   const GValue *h_val;
 521   GstCaps *caps, *adj_caps;
 522
 523   videocrop_test_cropping_init_context (&ctx);
 524
 525   crop = GST_BASE_TRANSFORM (ctx.crop);
 526   klass = GST_BASE_TRANSFORM_GET_CLASS (ctx.crop);
 527   fail_unless (klass != NULL);
 528
 529   caps = gst_caps_new_simple ("video/x-raw",
 530       "format", G_TYPE_STRING, "I420",
 531       "framerate", GST_TYPE_FRACTION, 1, 1,
 532       "width", G_TYPE_INT, 200, "height", G_TYPE_INT, 100, NULL);
 533
 534   /* by default, it should be no cropping and hence passthrough */
 535   adj_caps = klass->transform_caps (crop, GST_PAD_SRC, caps, NULL);
 536   fail_unless (adj_caps != NULL);
 537   fail_unless (gst_caps_is_equal (adj_caps, caps));
 538   gst_caps_unref (adj_caps);
 539
 540   adj_caps = klass->transform_caps (crop, GST_PAD_SINK, caps, NULL);
 541   fail_unless (adj_caps != NULL);
 542   fail_unless (gst_caps_is_equal (adj_caps, caps));
 543   gst_caps_unref (adj_caps);
 544
 545   /* make sure that's still true after changing properties back and forth */
 546   g_object_set (ctx.crop, "left", 1, "right", 3, "top", 5, "bottom", 7, NULL);
 547   g_object_set (ctx.crop, "left", 0, "right", 0, "top", 0, "bottom", 0, NULL);
 548
 549   adj_caps = klass->transform_caps (crop, GST_PAD_SRC, caps, NULL);
 550   fail_unless (adj_caps != NULL);
 551   fail_unless (gst_caps_is_equal (adj_caps, caps));
 552   gst_caps_unref (adj_caps);
 553
 554   adj_caps = klass->transform_caps (crop, GST_PAD_SINK, caps, NULL);
 555   fail_unless (adj_caps != NULL);
 556   fail_unless (gst_caps_is_equal (adj_caps, caps));
 557   gst_caps_unref (adj_caps);
 558
 559   /* now check adjustments made ... */
 560   g_object_set (ctx.crop, "left", 1, "right", 3, "top", 5, "bottom", 7, NULL);
 561
 562   /* ========= (1) fixed value ============================================= */
 563
 564   /* sink => source, source must be bigger if we crop stuff off */
 565   adj_caps = klass->transform_caps (crop, GST_PAD_SRC, caps, NULL);
 566   fail_unless (adj_caps != NULL);
 567   fail_unless (gst_caps_get_size (adj_caps) == 1);
 568   w_val =
 569       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 570   fail_unless (w_val != NULL);
 571   fail_unless (G_VALUE_HOLDS_INT (w_val));
 572   fail_unless_equals_int (g_value_get_int (w_val), 200 + (1 + 3));
 573   h_val =
 574       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 575   fail_unless (h_val != NULL);
 576   fail_unless (G_VALUE_HOLDS_INT (h_val));
 577   fail_unless_equals_int (g_value_get_int (h_val), 100 + (5 + 7));
 578   gst_caps_unref (adj_caps);
 579
 580   /* source => sink becomes smaller */
 581   adj_caps = klass->transform_caps (crop, GST_PAD_SINK, caps, NULL);
 582   fail_unless (adj_caps != NULL);
 583   fail_unless (gst_caps_get_size (adj_caps) == 1);
 584   w_val =
 585       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 586   fail_unless (w_val != NULL);
 587   fail_unless (G_VALUE_HOLDS_INT (w_val));
 588   fail_unless_equals_int (g_value_get_int (w_val), 200 - (1 + 3));
 589   h_val =
 590       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 591   fail_unless (h_val != NULL);
 592   fail_unless (G_VALUE_HOLDS_INT (h_val));
 593   fail_unless_equals_int (g_value_get_int (h_val), 100 - (5 + 7));
 594   gst_caps_unref (adj_caps);
 595
 596   /* ========= (2) range (simple adjustment) =============================== */
 597
 598   gst_structure_set (gst_caps_get_structure (caps, 0),
 599       "width", GST_TYPE_INT_RANGE, 1000, 2000,
 600       "height", GST_TYPE_INT_RANGE, 3000, 4000, NULL);
 601
 602   /* sink => source, source must be bigger if we crop stuff off */
 603   adj_caps = klass->transform_caps (crop, GST_PAD_SRC, caps, NULL);
 604   fail_unless (adj_caps != NULL);
 605   fail_unless (gst_caps_get_size (adj_caps) == 1);
 606   w_val =
 607       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 608   fail_unless (w_val != NULL);
 609   fail_unless (GST_VALUE_HOLDS_INT_RANGE (w_val));
 610   fail_unless_equals_int (gst_value_get_int_range_min (w_val), 1000 + (1 + 3));
 611   fail_unless_equals_int (gst_value_get_int_range_max (w_val), 2000 + (1 + 3));
 612   h_val =
 613       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 614   fail_unless (h_val != NULL);
 615   fail_unless (GST_VALUE_HOLDS_INT_RANGE (h_val));
 616   fail_unless_equals_int (gst_value_get_int_range_min (h_val), 3000 + (5 + 7));
 617   fail_unless_equals_int (gst_value_get_int_range_max (h_val), 4000 + (5 + 7));
 618   gst_caps_unref (adj_caps);
 619
 620   /* source => sink becomes smaller */
 621   adj_caps = klass->transform_caps (crop, GST_PAD_SINK, caps, NULL);
 622   fail_unless (adj_caps != NULL);
 623   fail_unless (gst_caps_get_size (adj_caps) == 1);
 624   w_val =
 625       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 626   fail_unless (w_val != NULL);
 627   fail_unless (GST_VALUE_HOLDS_INT_RANGE (w_val));
 628   fail_unless_equals_int (gst_value_get_int_range_min (w_val), 1000 - (1 + 3));
 629   fail_unless_equals_int (gst_value_get_int_range_max (w_val), 2000 - (1 + 3));
 630   h_val =
 631       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 632   fail_unless (h_val != NULL);
 633   fail_unless (GST_VALUE_HOLDS_INT_RANGE (h_val));
 634   fail_unless_equals_int (gst_value_get_int_range_min (h_val), 3000 - (5 + 7));
 635   fail_unless_equals_int (gst_value_get_int_range_max (h_val), 4000 - (5 + 7));
 636   gst_caps_unref (adj_caps);
 637
 638   /* ========= (3) range (adjustment at boundary) ========================== */
 639
 640   gst_structure_set (gst_caps_get_structure (caps, 0),
 641       "width", GST_TYPE_INT_RANGE, 2, G_MAXINT,
 642       "height", GST_TYPE_INT_RANGE, 2, G_MAXINT, NULL);
 643
 644   /* sink => source, source must be bigger if we crop stuff off */
 645   adj_caps = klass->transform_caps (crop, GST_PAD_SRC, caps, NULL);
 646   fail_unless (adj_caps != NULL);
 647   fail_unless (gst_caps_get_size (adj_caps) == 1);
 648   w_val =
 649       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 650   fail_unless (w_val != NULL);
 651   fail_unless (GST_VALUE_HOLDS_INT_RANGE (w_val));
 652   fail_unless_equals_int (gst_value_get_int_range_min (w_val), 2 + (1 + 3));
 653   fail_unless_equals_int (gst_value_get_int_range_max (w_val), G_MAXINT);
 654   h_val =
 655       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 656   fail_unless (h_val != NULL);
 657   fail_unless (GST_VALUE_HOLDS_INT_RANGE (h_val));
 658   fail_unless_equals_int (gst_value_get_int_range_min (h_val), 2 + (5 + 7));
 659   fail_unless_equals_int (gst_value_get_int_range_max (h_val), G_MAXINT);
 660   gst_caps_unref (adj_caps);
 661
 662   /* source => sink becomes smaller */
 663   adj_caps = klass->transform_caps (crop, GST_PAD_SINK, caps, NULL);
 664   fail_unless (adj_caps != NULL);
 665   fail_unless (gst_caps_get_size (adj_caps) == 1);
 666   w_val =
 667       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 668   fail_unless (w_val != NULL);
 669   fail_unless (GST_VALUE_HOLDS_INT_RANGE (w_val));
 670   fail_unless_equals_int (gst_value_get_int_range_min (w_val), 1);
 671   fail_unless_equals_int (gst_value_get_int_range_max (w_val),
 672       G_MAXINT - (1 + 3));
 673   h_val =
 674       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 675   fail_unless (h_val != NULL);
 676   fail_unless (GST_VALUE_HOLDS_INT_RANGE (h_val));
 677   fail_unless_equals_int (gst_value_get_int_range_min (h_val), 1);
 678   fail_unless_equals_int (gst_value_get_int_range_max (h_val),
 679       G_MAXINT - (5 + 7));
 680   gst_caps_unref (adj_caps);
 681
 682   /* ========= (4) list of values ========================================== */
 683
 684   {
 685     GValue list = { 0, };
 686     GValue ival = { 0, };
 687
 688     g_value_init (&ival, G_TYPE_INT);
 689     g_value_init (&list, GST_TYPE_LIST);
 690     g_value_set_int (&ival, 2);
 691     gst_value_list_append_value (&list, &ival);
 692     g_value_set_int (&ival, G_MAXINT);
 693     gst_value_list_append_value (&list, &ival);
 694     gst_structure_set_value (gst_caps_get_structure (caps, 0), "width", &list);
 695     g_value_unset (&list);
 696     g_value_unset (&ival);
 697
 698     g_value_init (&ival, G_TYPE_INT);
 699     g_value_init (&list, GST_TYPE_LIST);
 700     g_value_set_int (&ival, 5);
 701     gst_value_list_append_value (&list, &ival);
 702     g_value_set_int (&ival, 1000);
 703     gst_value_list_append_value (&list, &ival);
 704     gst_structure_set_value (gst_caps_get_structure (caps, 0), "height", &list);
 705     g_value_unset (&list);
 706     g_value_unset (&ival);
 707   }
 708
 709   /* sink => source, source must be bigger if we crop stuff off */
 710   adj_caps = klass->transform_caps (crop, GST_PAD_SRC, caps, NULL);
 711   fail_unless (adj_caps != NULL);
 712   fail_unless (gst_caps_get_size (adj_caps) == 1);
 713   w_val =
 714       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 715   fail_unless (w_val != NULL);
 716   fail_unless (GST_VALUE_HOLDS_LIST (w_val));
 717   fail_unless_equals_int (notgst_value_list_get_nth_int (w_val, 0),
 718       2 + (1 + 3));
 719   fail_unless_equals_int (notgst_value_list_get_nth_int (w_val, 1), G_MAXINT);
 720   h_val =
 721       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 722   fail_unless (h_val != NULL);
 723   fail_unless (GST_VALUE_HOLDS_LIST (h_val));
 724   fail_unless_equals_int (notgst_value_list_get_nth_int (h_val, 0),
 725       5 + (5 + 7));
 726   fail_unless_equals_int (notgst_value_list_get_nth_int (h_val, 1),
 727       1000 + (5 + 7));
 728   gst_caps_unref (adj_caps);
 729
 730   /* source => sink becomes smaller */
 731   adj_caps = klass->transform_caps (crop, GST_PAD_SINK, caps, NULL);
 732   fail_unless (adj_caps != NULL);
 733   fail_unless (gst_caps_get_size (adj_caps) == 1);
 734   w_val =
 735       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "width");
 736   fail_unless (w_val != NULL);
 737   fail_unless (GST_VALUE_HOLDS_LIST (w_val));
 738   fail_unless_equals_int (notgst_value_list_get_nth_int (w_val, 0), 1);
 739   fail_unless_equals_int (notgst_value_list_get_nth_int (w_val, 1),
 740       G_MAXINT - (1 + 3));
 741   h_val =
 742       gst_structure_get_value (gst_caps_get_structure (adj_caps, 0), "height");
 743   fail_unless (h_val != NULL);
 744   fail_unless (GST_VALUE_HOLDS_LIST (h_val));
 745   fail_unless_equals_int (notgst_value_list_get_nth_int (h_val, 0), 1);
 746   fail_unless_equals_int (notgst_value_list_get_nth_int (h_val, 1),
 747       1000 - (5 + 7));
 748   gst_caps_unref (adj_caps);
 749
 750   gst_caps_unref (caps);
 751   videocrop_test_cropping_deinit_context (&ctx);
 752 }
 753
 754 GST_END_TEST;
 755
 756 static Suite *
 757 videocrop_suite (void)
 758 {
 759   Suite *s = suite_create ("videocrop");
 760   TCase *tc_chain = tcase_create ("general");
 761
 762 #ifdef HAVE_VALGRIND
 763   if (RUNNING_ON_VALGRIND) {
 764     /* our tests take quite a long time, so increase
 765      * timeout (~25 minutes on my 1.6GHz AMD K7) */
 766     tcase_set_timeout (tc_chain, 30 * 60);
 767   } else
 768 #endif
 769   {
 770     /* increase timeout, these tests take a long time (60 secs here) */
 771     tcase_set_timeout (tc_chain, 2 * 60);
 772   }
 773
 774   suite_add_tcase (s, tc_chain);
 775   tcase_add_test (tc_chain, test_crop_to_1x1);
 776   tcase_add_test (tc_chain, test_caps_transform);
 777   tcase_add_test (tc_chain, test_passthrough);
 778   tcase_add_test (tc_chain, test_unit_sizes);
 779   tcase_add_loop_test (tc_chain, test_cropping, 0, 25);
 780
 781   return s;
 782 }
 783
 784 int
 785 main (int argc, char **argv)
 786 {
 787   int nf;
 788
 789   Suite *s = videocrop_suite ();
 790   SRunner *sr = srunner_create (s);
 791
 792 #ifdef HAVE_VALGRIND
 793   if (RUNNING_ON_VALGRIND) {
 794     /* otherwise valgrind errors out when liboil probes CPU extensions
 795      * in oil_init() during which it causes SIGILLs etc. to be fired */
 796     g_setenv ("OIL_CPU_FLAGS", "0", 0);
 797   }
 798 #endif
 799
 800   gst_check_init (&argc, &argv);
 801
 802   srunner_run_all (sr, CK_NORMAL);
 803   nf = srunner_ntests_failed (sr);
 804   srunner_free (sr);
 805
 806   return nf;
 807 }