validate/gst/validate/gst-validate-pad-monitor.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2013 Collabora Ltd.
   4  *  Author: Thiago Sousa Santos <thiago.sousa.santos@collabora.com>
   5  *
   6  * gst-validate-pad-monitor.c - Validate PadMonitor class
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include "config.h"
  26 #endif
  27
  28 #include "gst-validate-internal.h"
  29 #include "gst-validate-pad-monitor.h"
  30 #include "gst-validate-element-monitor.h"
  31 #include "gst-validate-pipeline-monitor.h"
  32 #include "gst-validate-reporter.h"
  33 #include "gst-validate-utils.h"
  34 #include "validate.h"
  35 #include <string.h>
  36 #include <stdarg.h>
  37
  38 /**
  39  * SECTION:gst-validate-pad-monitor
  40  * @short_description: Class that wraps a #GstPad for Validate checks
  41  *
  42  * TODO
  43  */
  44 #define _GET_PAD_MONITOR(p) g_object_get_qdata ((GObject*) p, _Q_VALIDATE_MONITOR)
  45 #define _SET_PAD_MONITOR(p,d) g_object_set_qdata ((GObject*) p, _Q_VALIDATE_MONITOR, d)
  46
  47 static GstValidateInterceptionReturn
  48 gst_validate_pad_monitor_intercept_report (GstValidateReporter * reporter,
  49     GstValidateReport * report);
  50
  51 #define _do_init \
  52   G_IMPLEMENT_INTERFACE (GST_TYPE_VALIDATE_REPORTER, _reporter_iface_init)
  53
  54 static void
  55 _reporter_iface_init (GstValidateReporterInterface * iface)
  56 {
  57   iface->intercept_report = gst_validate_pad_monitor_intercept_report;
  58 }
  59
  60 #define gst_validate_pad_monitor_parent_class parent_class
  61 G_DEFINE_TYPE_WITH_CODE (GstValidatePadMonitor, gst_validate_pad_monitor,
  62     GST_TYPE_VALIDATE_MONITOR, _do_init);
  63
  64 #define PENDING_FIELDS "pending-fields"
  65 #define AUDIO_TIMESTAMP_TOLERANCE (GST_MSECOND * 100)
  66
  67 #define PAD_PARENT_IS_DEMUXER(m) \
  68     (GST_VALIDATE_MONITOR_GET_PARENT(m) ? \
  69         GST_VALIDATE_ELEMENT_MONITOR_ELEMENT_IS_DEMUXER ( \
  70             GST_VALIDATE_MONITOR_GET_PARENT(m)) : \
  71         FALSE)
  72
  73 #define PAD_PARENT_IS_DECODER(m) \
  74     (GST_VALIDATE_MONITOR_GET_PARENT(m) ? \
  75         GST_VALIDATE_ELEMENT_MONITOR_ELEMENT_IS_DECODER ( \
  76             GST_VALIDATE_MONITOR_GET_PARENT(m)) : \
  77         FALSE)
  78
  79 #define PAD_PARENT_IS_ENCODER(m) \
  80     (GST_VALIDATE_MONITOR_GET_PARENT(m) ? \
  81         GST_VALIDATE_ELEMENT_MONITOR_ELEMENT_IS_ENCODER ( \
  82             GST_VALIDATE_MONITOR_GET_PARENT(m)) : \
  83         FALSE)
  84
  85 #define PAD_PARENT_IS_SINK(m) \
  86     (GST_VALIDATE_MONITOR_GET_PARENT(m) ? \
  87         GST_VALIDATE_ELEMENT_MONITOR_ELEMENT_IS_SINK ( \
  88             GST_VALIDATE_MONITOR_GET_PARENT(m)) : \
  89         FALSE)
  90
  91
  92 /*
  93  * Locking the parent should always be done before locking the
  94  * pad-monitor to prevent deadlocks in case another monitor from
  95  * another pad on the same element starts an operation that also
  96  * requires locking itself and some other monitors from internally
  97  * linked pads.
  98  *
  99  * An example:
 100  * An element has a sink and a src pad. Some test starts running at sinkpad
 101  * and it locks the parent, and then it locks itself. In case it needs to get
 102  * some information from the srcpad, it is able to lock the srcpad and get it
 103  * because the srcpad should never lock itself before locking the parent (which
 104  * it won't be able as sinkpad already locked it).
 105  *
 106  * As a side one, it is possible that srcpad locks itself without locking the
 107  * parent in case it wants to do a check that won't need to use other internally
 108  * linked pads (sinkpad). But in this case it might lock and unlock freely without
 109  * causing deadlocks.
 110  */
 111 #define GST_VALIDATE_PAD_MONITOR_PARENT_LOCK(m)                  \
 112 G_STMT_START {                                             \
 113   if (G_LIKELY (GST_VALIDATE_MONITOR_GET_PARENT (m))) {          \
 114     GST_VALIDATE_MONITOR_LOCK (GST_VALIDATE_MONITOR_GET_PARENT (m));   \
 115   } else {                                                 \
 116     GST_WARNING_OBJECT (m, "No parent found, can't lock"); \
 117   }                                                        \
 118 } G_STMT_END
 119
 120 #define GST_VALIDATE_PAD_MONITOR_PARENT_UNLOCK(m)                  \
 121 G_STMT_START {                                               \
 122   if (G_LIKELY (GST_VALIDATE_MONITOR_GET_PARENT (m))) {            \
 123     GST_VALIDATE_MONITOR_UNLOCK (GST_VALIDATE_MONITOR_GET_PARENT (m));   \
 124   } else {                                                   \
 125     GST_WARNING_OBJECT (m, "No parent found, can't unlock"); \
 126   }                                                          \
 127 } G_STMT_END
 128
 129 /* Structure used to store all seek-related information */
 130 struct _GstValidatePadSeekData
 131 {
 132   guint32 seqnum;
 133   gdouble rate;
 134   GstFormat format;
 135   GstSeekFlags flags;
 136   GstSeekType start_type, stop_type;
 137   gint64 start, stop;
 138 };
 139
 140 typedef struct
 141 {
 142   GstClockTime timestamp;
 143   GstEvent *event;
 144 } SerializedEventData;
 145
 146 static GstPad *
 147 _get_actual_pad (GstPad * pad)
 148 {
 149   pad = gst_object_ref (pad);
 150
 151   while (GST_IS_PROXY_PAD (pad)) {
 152     GstPad *next_pad;
 153
 154     if (GST_PAD_IS_SINK (pad)) {
 155       if (GST_IS_GHOST_PAD (pad))
 156         next_pad = gst_ghost_pad_get_target (GST_GHOST_PAD (pad));
 157       else
 158         next_pad = GST_PAD (gst_proxy_pad_get_internal (GST_PROXY_PAD (pad)));
 159     } else {
 160       next_pad = gst_pad_get_peer (pad);
 161     }
 162
 163     gst_object_unref (pad);
 164     if (!next_pad)
 165       return NULL;
 166
 167     pad = next_pad;
 168   }
 169
 170   return pad;
 171 }
 172
 173 static gboolean
 174 _find_master_report_on_pad (GstPad * pad, GstValidateReport * report)
 175 {
 176   GstValidatePadMonitor *pad_monitor;
 177   GstValidateReport *prev_report;
 178   gboolean result = FALSE;
 179   GstPad *tmppad = pad;
 180
 181   pad = _get_actual_pad (pad);
 182   if (pad == NULL) {
 183     GST_ERROR_OBJECT (tmppad, "Does not have a target yet");
 184
 185     return FALSE;
 186   }
 187
 188   pad_monitor = _GET_PAD_MONITOR (pad);
 189
 190   /* For some reason this pad isn't monitored */
 191   if (pad_monitor == NULL)
 192     goto done;
 193
 194   prev_report = gst_validate_reporter_get_report ((GstValidateReporter *)
 195       pad_monitor, report->issue->issue_id);
 196
 197   if (prev_report) {
 198     if (prev_report->master_report)
 199       result = gst_validate_report_set_master_report (report,
 200           prev_report->master_report);
 201     else
 202       result = gst_validate_report_set_master_report (report, prev_report);
 203   }
 204
 205 done:
 206   gst_object_unref (pad);
 207
 208   return result;
 209 }
 210
 211 static gboolean
 212 _find_master_report_for_sink_pad (GstValidatePadMonitor * pad_monitor,
 213     GstValidateReport * report)
 214 {
 215   GstPad *peerpad;
 216   gboolean result = FALSE;
 217   GstPad *pad =
 218       GST_PAD_CAST (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
 219           (pad_monitor)));
 220
 221   peerpad = gst_pad_get_peer (pad);
 222   gst_object_unref (pad);
 223
 224   /* If the peer src pad already has a similar report no need to look
 225    * any further */
 226   if (peerpad && _find_master_report_on_pad (peerpad, report))
 227     result = TRUE;
 228
 229   if (peerpad)
 230     gst_object_unref (peerpad);
 231
 232   return result;
 233 }
 234
 235 static gboolean
 236 _find_master_report_for_src_pad (GstValidatePadMonitor * pad_monitor,
 237     GstValidateReport * report)
 238 {
 239   GstIterator *iter;
 240   gboolean done;
 241   gboolean result = FALSE;
 242   GstPad *target =
 243       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
 244           (pad_monitor)));
 245
 246   iter = gst_pad_iterate_internal_links (target);
 247   done = FALSE;
 248   while (!done) {
 249     GValue value = { 0, };
 250     switch (gst_iterator_next (iter, &value)) {
 251       case GST_ITERATOR_OK:
 252       {
 253         GstPad *pad = g_value_get_object (&value);
 254
 255         if (_find_master_report_on_pad (pad, report)) {
 256           result = TRUE;
 257           done = TRUE;
 258         }
 259
 260         g_value_reset (&value);
 261         break;
 262       }
 263       case GST_ITERATOR_RESYNC:
 264         gst_iterator_resync (iter);
 265         break;
 266       case GST_ITERATOR_ERROR:
 267         GST_WARNING_OBJECT (target, "Internal links pad iteration error");
 268         done = TRUE;
 269         break;
 270       case GST_ITERATOR_DONE:
 271         done = TRUE;
 272         break;
 273     }
 274   }
 275   gst_object_unref (target);
 276   gst_iterator_free (iter);
 277
 278   return result;
 279 }
 280
 281 static GstValidateInterceptionReturn
 282 _concatenate_issues (GstValidatePadMonitor * pad_monitor,
 283     GstValidateReport * report)
 284 {
 285   GstPad *pad =
 286       GST_PAD_CAST (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
 287           (pad_monitor)));
 288
 289   if (GST_PAD_IS_SINK (pad)
 290       && _find_master_report_for_sink_pad (pad_monitor, report)) {
 291     gst_object_unref (pad);
 292     return GST_VALIDATE_REPORTER_KEEP;
 293   } else if (GST_PAD_IS_SRC (pad)
 294       && _find_master_report_for_src_pad (pad_monitor, report)) {
 295     gst_object_unref (pad);
 296     return GST_VALIDATE_REPORTER_KEEP;
 297   }
 298
 299   gst_object_unref (pad);
 300   return GST_VALIDATE_REPORTER_REPORT;
 301 }
 302
 303 static GstValidateInterceptionReturn
 304 gst_validate_pad_monitor_intercept_report (GstValidateReporter *
 305     reporter, GstValidateReport * report)
 306 {
 307   GstValidateReporterInterface *iface_class, *old_iface_class;
 308   GstValidatePadMonitor *pad_monitor = GST_VALIDATE_PAD_MONITOR (reporter);
 309   GstValidateReportingDetails monitor_reporting_level;
 310   GstValidateInterceptionReturn ret;
 311
 312   monitor_reporting_level =
 313       gst_validate_reporter_get_reporting_level (reporter);
 314
 315   iface_class =
 316       G_TYPE_INSTANCE_GET_INTERFACE (reporter, GST_TYPE_VALIDATE_REPORTER,
 317       GstValidateReporterInterface);
 318   old_iface_class = g_type_interface_peek_parent (iface_class);
 319
 320   old_iface_class->intercept_report (reporter, report);
 321
 322   switch (monitor_reporting_level) {
 323     case GST_VALIDATE_SHOW_NONE:
 324       ret = GST_VALIDATE_REPORTER_DROP;
 325       break;
 326     case GST_VALIDATE_SHOW_UNKNOWN:
 327       ret = _concatenate_issues (pad_monitor, report);
 328       break;
 329     default:
 330       ret = GST_VALIDATE_REPORTER_REPORT;
 331       break;
 332   }
 333
 334   gst_validate_report_set_reporting_level (report, monitor_reporting_level);
 335   return ret;
 336 }
 337
 338 static void
 339 debug_pending_event (GstPad * pad, GPtrArray * array)
 340 {
 341   guint i, len;
 342
 343   len = array->len;
 344   for (i = 0; i < len; i++) {
 345     SerializedEventData *data = g_ptr_array_index (array, i);
 346     GST_DEBUG_OBJECT (pad, "event #%d %" GST_TIME_FORMAT " %s %p",
 347         i, GST_TIME_ARGS (data->timestamp),
 348         GST_EVENT_TYPE_NAME (data->event), data->event);
 349   }
 350 }
 351
 352 static void
 353 _serialized_event_data_free (SerializedEventData * serialized_event)
 354 {
 355   gst_event_unref (serialized_event->event);
 356   g_slice_free (SerializedEventData, serialized_event);
 357 }
 358
 359 static gboolean gst_validate_pad_monitor_do_setup (GstValidateMonitor *
 360     monitor);
 361 static GstElement *gst_validate_pad_monitor_get_element (GstValidateMonitor *
 362     monitor);
 363 static void
 364 gst_validate_pad_monitor_setcaps_pre (GstValidatePadMonitor * pad_monitor,
 365     GstCaps * caps);
 366 static void gst_validate_pad_monitor_setcaps_post (GstValidatePadMonitor *
 367     pad_monitor, GstCaps * caps, gboolean ret);
 368
 369 #define PAD_IS_IN_PUSH_MODE(p) ((p)->mode == GST_PAD_MODE_PUSH)
 370
 371 static gboolean
 372 _structure_is_raw_video (GstStructure * structure)
 373 {
 374   return gst_structure_has_name (structure, "video/x-raw");
 375 }
 376
 377 static gboolean
 378 _structure_is_raw_audio (GstStructure * structure)
 379 {
 380   return gst_structure_has_name (structure, "audio/x-raw");
 381 }
 382
 383 static gchar *
 384 _get_event_string (GstEvent * event)
 385 {
 386   const GstStructure *st;
 387
 388   if ((st = gst_event_get_structure (event)))
 389     return gst_structure_to_string (st);
 390   else
 391     return g_strdup_printf ("%s", GST_EVENT_TYPE_NAME (event));
 392 }
 393
 394 static void
 395 _check_field_type (GstValidatePadMonitor * monitor,
 396     GstStructure * structure, gboolean mandatory, const gchar * field, ...)
 397 {
 398   va_list var_args;
 399   GType type;
 400   gchar *joined_types = NULL;
 401   const gchar *rejected_types[5];
 402   gint rejected_types_index = 0;
 403   gchar *struct_str;
 404
 405   if (!gst_structure_has_field (structure, field)) {
 406     if (mandatory) {
 407       gchar *str = gst_structure_to_string (structure);
 408
 409       GST_VALIDATE_REPORT (monitor, CAPS_IS_MISSING_FIELD,
 410           "Field '%s' is missing from structure: %s", field, str);
 411       g_free (str);
 412     } else {
 413       GST_DEBUG_OBJECT (monitor, "Field %s is missing but is not mandatory",
 414           field);
 415     }
 416     return;
 417   }
 418
 419   memset ((gchar **) rejected_types, 0, sizeof (rejected_types));
 420   va_start (var_args, field);
 421   while ((type = va_arg (var_args, GType)) != 0) {
 422     if (gst_structure_has_field_typed (structure, field, type)) {
 423       va_end (var_args);
 424       return;
 425     }
 426     rejected_types[rejected_types_index++] = g_type_name (type);
 427   }
 428   va_end (var_args);
 429
 430   joined_types = g_strjoinv (" / ", (gchar **) rejected_types);
 431   struct_str = gst_structure_to_string (structure);
 432   GST_VALIDATE_REPORT (monitor, CAPS_FIELD_HAS_BAD_TYPE,
 433       "Field '%s' has wrong type %s in structure '%s'. Expected: %s", field,
 434       g_type_name (gst_structure_get_field_type (structure, field)), struct_str,
 435       joined_types);
 436   g_free (joined_types);
 437   g_free (struct_str);
 438 }
 439
 440 static void
 441 gst_validate_pad_monitor_check_raw_video_caps_complete (GstValidatePadMonitor *
 442     monitor, GstStructure * structure)
 443 {
 444   _check_field_type (monitor, structure, TRUE, "width", G_TYPE_INT,
 445       GST_TYPE_INT_RANGE, 0);
 446   _check_field_type (monitor, structure, TRUE, "height", G_TYPE_INT,
 447       GST_TYPE_INT_RANGE, 0);
 448   _check_field_type (monitor, structure, TRUE, "framerate", GST_TYPE_FRACTION,
 449       GST_TYPE_FRACTION_RANGE, 0);
 450   _check_field_type (monitor, structure, FALSE, "pixel-aspect-ratio",
 451       GST_TYPE_FRACTION, GST_TYPE_FRACTION_RANGE, 0);
 452   _check_field_type (monitor, structure, TRUE, "format", G_TYPE_STRING,
 453       GST_TYPE_LIST);
 454 }
 455
 456 static void
 457 gst_validate_pad_monitor_check_raw_audio_caps_complete (GstValidatePadMonitor *
 458     monitor, GstStructure * structure)
 459 {
 460   gint channels;
 461   _check_field_type (monitor, structure, TRUE, "format", G_TYPE_STRING,
 462       GST_TYPE_LIST, 0);
 463   _check_field_type (monitor, structure, TRUE, "layout", G_TYPE_STRING,
 464       GST_TYPE_LIST, 0);
 465   _check_field_type (monitor, structure, TRUE, "rate", G_TYPE_INT,
 466       GST_TYPE_LIST, GST_TYPE_INT_RANGE, 0);
 467   _check_field_type (monitor, structure, TRUE, "channels", G_TYPE_INT,
 468       GST_TYPE_LIST, GST_TYPE_INT_RANGE, 0);
 469   if (gst_structure_get_int (structure, "channels", &channels)) {
 470     if (channels > 2)
 471       _check_field_type (monitor, structure, TRUE, "channel-mask",
 472           GST_TYPE_BITMASK, GST_TYPE_LIST, 0);
 473   }
 474 }
 475
 476 static void
 477 gst_validate_pad_monitor_check_caps_complete (GstValidatePadMonitor * monitor,
 478     GstCaps * caps)
 479 {
 480   GstStructure *structure;
 481   gint i;
 482
 483   GST_DEBUG_OBJECT (monitor, "Checking caps %" GST_PTR_FORMAT, caps);
 484
 485   for (i = 0; i < gst_caps_get_size (caps); i++) {
 486     structure = gst_caps_get_structure (caps, i);
 487
 488     if (_structure_is_raw_video (structure)) {
 489       gst_validate_pad_monitor_check_raw_video_caps_complete (monitor,
 490           structure);
 491
 492     } else if (_structure_is_raw_audio (structure)) {
 493       gst_validate_pad_monitor_check_raw_audio_caps_complete (monitor,
 494           structure);
 495     }
 496   }
 497 }
 498
 499 static GstCaps *
 500 gst_validate_pad_monitor_get_othercaps (GstValidatePadMonitor * monitor,
 501     GstCaps * filter)
 502 {
 503   GstCaps *caps = gst_caps_new_empty ();
 504   GstIterator *iter;
 505   gboolean done;
 506   GstPad *otherpad;
 507   GstCaps *peercaps;
 508   GstPad *pad =
 509       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
 510           (monitor)));
 511
 512   iter = gst_pad_iterate_internal_links (pad);
 513   done = FALSE;
 514   while (!done) {
 515     GValue value = { 0, };
 516     switch (gst_iterator_next (iter, &value)) {
 517       case GST_ITERATOR_OK:
 518         otherpad = g_value_get_object (&value);
 519
 520         /* TODO What would be the correct caps operation to merge the caps in
 521          * case one sink is internally linked to multiple srcs? */
 522         peercaps = gst_pad_peer_query_caps (otherpad, filter);
 523         if (peercaps)
 524           caps = gst_caps_merge (caps, peercaps);
 525
 526         g_value_reset (&value);
 527         break;
 528       case GST_ITERATOR_RESYNC:
 529         gst_iterator_resync (iter);
 530         gst_caps_unref (caps);
 531         caps = gst_caps_new_empty ();
 532         break;
 533       case GST_ITERATOR_ERROR:
 534         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
 535         done = TRUE;
 536         break;
 537       case GST_ITERATOR_DONE:
 538         done = TRUE;
 539         break;
 540     }
 541   }
 542   GST_DEBUG_OBJECT (pad, "Otherpad caps: %" GST_PTR_FORMAT, caps);
 543
 544   gst_iterator_free (iter);
 545   gst_object_unref (pad);
 546
 547   return caps;
 548 }
 549
 550 static gboolean
 551 _structure_is_video (GstStructure * structure)
 552 {
 553   const gchar *name = gst_structure_get_name (structure);
 554
 555   return g_strstr_len (name, 6, "video/")
 556       && g_strcmp0 (name, "video/quicktime") != 0;
 557 }
 558
 559 static gboolean
 560 _structure_is_audio (GstStructure * structure)
 561 {
 562   const gchar *name = gst_structure_get_name (structure);
 563
 564   return g_strstr_len (name, 6, "audio/") != NULL;
 565 }
 566
 567 static gboolean
 568 gst_validate_pad_monitor_pad_should_proxy_othercaps (GstValidatePadMonitor *
 569     monitor)
 570 {
 571   GstValidateMonitor *parent = GST_VALIDATE_MONITOR_GET_PARENT (monitor);
 572
 573   if (!parent)
 574     return FALSE;
 575
 576   /* We only know how to handle othercaps checks for codecs so far */
 577   return (GST_VALIDATE_ELEMENT_MONITOR_ELEMENT_IS_DECODER (parent) ||
 578       GST_VALIDATE_ELEMENT_MONITOR_ELEMENT_IS_ENCODER (parent)) &&
 579       !GST_VALIDATE_ELEMENT_MONITOR_ELEMENT_IS_CONVERTER (parent);
 580 }
 581
 582
 583 /* Check if the field @f from @s2 (if present) is represented in @s1
 584  * Represented here means either equal or @s1's value is in a list/range
 585  * from @s2
 586  */
 587 static gboolean
 588 _structures_field_is_contained (GstStructure * s1, GstStructure * s2,
 589     gboolean mandatory, const gchar * f)
 590 {
 591   const GValue *v1;
 592   const GValue *v2;
 593
 594   v2 = gst_structure_get_value (s2, f);
 595   if (!v2)
 596     return TRUE;                /* nothing to compare to */
 597
 598   v1 = gst_structure_get_value (s1, f);
 599   if (!v1)
 600     return !mandatory;
 601
 602   if (!gst_value_is_fixed (v1))
 603     return TRUE;
 604
 605   if (gst_value_compare (v1, v2) == GST_VALUE_EQUAL)
 606     return TRUE;
 607
 608   if (GST_VALUE_HOLDS_LIST (v2)) {
 609     gint i;
 610     for (i = 0; i < gst_value_list_get_size (v2); i++) {
 611       const GValue *v2_subvalue = gst_value_list_get_value (v2, i);
 612       if (gst_value_compare (v1, v2_subvalue) == GST_VALUE_EQUAL)
 613         return TRUE;
 614     }
 615   }
 616
 617   if (GST_VALUE_HOLDS_ARRAY (v2)) {
 618     gint i;
 619     for (i = 0; i < gst_value_array_get_size (v2); i++) {
 620       const GValue *v2_subvalue = gst_value_array_get_value (v2, i);
 621       if (gst_value_compare (v1, v2_subvalue) == GST_VALUE_EQUAL)
 622         return TRUE;
 623     }
 624   }
 625
 626   if (GST_VALUE_HOLDS_INT_RANGE (v2)) {
 627     gint min, max;
 628
 629     min = gst_value_get_int_range_min (v2);
 630     max = gst_value_get_int_range_max (v2);
 631
 632     if (G_VALUE_HOLDS_INT (v1)) {
 633       gint v = g_value_get_int (v1);
 634
 635       return v >= min && v <= max;
 636     } else {
 637       /* TODO compare int ranges with int ranges
 638        * or with lists if useful */
 639     }
 640   }
 641
 642   if (GST_VALUE_HOLDS_FRACTION_RANGE (v2)) {
 643     const GValue *min, *max;
 644
 645     min = gst_value_get_fraction_range_min (v2);
 646     max = gst_value_get_fraction_range_max (v2);
 647
 648     if (GST_VALUE_HOLDS_FRACTION (v1)) {
 649       gint v_min = gst_value_compare (v1, min);
 650       gint v_max = gst_value_compare (v1, max);
 651
 652       return (v_min == GST_VALUE_EQUAL || v_min == GST_VALUE_GREATER_THAN) &&
 653           (v_max == GST_VALUE_EQUAL || v_max == GST_VALUE_LESS_THAN);
 654     } else {
 655       /* TODO compare fraction ranges with fraction ranges
 656        * or with lists if useful */
 657     }
 658   }
 659
 660   return FALSE;
 661 }
 662
 663 static void
 664 _check_and_copy_structure_field (GstStructure * from, GstStructure * to,
 665     const gchar * name)
 666 {
 667   if (gst_structure_has_field (from, name)) {
 668     gst_structure_set_value (to, name, gst_structure_get_value (from, name));
 669   }
 670 }
 671
 672 static GstCaps *
 673 gst_validate_pad_monitor_copy_caps_fields_into_caps (GstValidatePadMonitor *
 674     monitor, GstCaps * from_caps, GstCaps * into_caps)
 675 {
 676   gint i, j, into_size, from_size;
 677   GstStructure *structure;
 678   GstCaps *res = gst_caps_new_empty ();
 679
 680   into_size = gst_caps_get_size (into_caps);
 681   from_size = gst_caps_get_size (from_caps);
 682
 683   for (i = 0; i < into_size; i++) {
 684     GstStructure *s = gst_caps_get_structure (into_caps, i);
 685
 686     for (j = 0; j < from_size; j++) {
 687       GstStructure *new_structure = gst_structure_copy (s);
 688
 689       structure = gst_caps_get_structure (from_caps, j);
 690       if (_structure_is_video (structure)) {
 691         _check_and_copy_structure_field (structure, new_structure, "width");
 692         _check_and_copy_structure_field (structure, new_structure, "height");
 693         _check_and_copy_structure_field (structure, new_structure, "framerate");
 694         _check_and_copy_structure_field (structure, new_structure,
 695             "pixel-aspect-ratio");
 696       } else if (_structure_is_audio (s)) {
 697         _check_and_copy_structure_field (structure, new_structure, "rate");
 698         _check_and_copy_structure_field (structure, new_structure, "channels");
 699       }
 700
 701       gst_caps_append_structure (res, new_structure);
 702     }
 703   }
 704   return res;
 705 }
 706
 707 static GstCaps *
 708 gst_validate_pad_monitor_transform_caps (GstValidatePadMonitor * monitor,
 709     GstCaps * caps)
 710 {
 711   GstCaps *othercaps;
 712   GstCaps *new_caps;
 713   GstIterator *iter;
 714   gboolean done;
 715   GstPad *otherpad;
 716   GstCaps *template_caps;
 717   GstPad *pad;
 718
 719
 720   GST_DEBUG_OBJECT (monitor, "Transform caps %" GST_PTR_FORMAT, caps);
 721
 722   if (caps == NULL)
 723     return NULL;
 724
 725   othercaps = gst_caps_new_empty ();
 726
 727   pad =
 728       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
 729           (monitor)));
 730   iter = gst_pad_iterate_internal_links (pad);
 731   done = FALSE;
 732   while (!done) {
 733     GValue value = { 0, };
 734     switch (gst_iterator_next (iter, &value)) {
 735       case GST_ITERATOR_OK:
 736         otherpad = g_value_get_object (&value);
 737         template_caps = gst_pad_get_pad_template_caps (otherpad);
 738
 739         new_caps =
 740             gst_validate_pad_monitor_copy_caps_fields_into_caps (monitor, caps,
 741             template_caps);
 742         if (!gst_caps_is_empty (new_caps))
 743           gst_caps_append (othercaps, new_caps);
 744         else
 745           gst_caps_unref (new_caps);
 746
 747         gst_caps_unref (template_caps);
 748         g_value_reset (&value);
 749         break;
 750       case GST_ITERATOR_RESYNC:
 751         gst_iterator_resync (iter);
 752         gst_caps_unref (othercaps);
 753         othercaps = gst_caps_new_empty ();
 754         break;
 755       case GST_ITERATOR_ERROR:
 756         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
 757         done = TRUE;
 758         break;
 759       case GST_ITERATOR_DONE:
 760         done = TRUE;
 761         break;
 762     }
 763   }
 764   gst_iterator_free (iter);
 765
 766   GST_DEBUG_OBJECT (pad, "Transformed caps: %" GST_PTR_FORMAT, othercaps);
 767   gst_object_unref (pad);
 768
 769   return othercaps;
 770 }
 771
 772 static void
 773 gst_validate_pad_monitor_check_caps_fields_proxied (GstValidatePadMonitor *
 774     monitor, GstCaps * caps, GstCaps * filter)
 775 {
 776   GstStructure *structure;
 777   GstStructure *otherstructure;
 778   GstCaps *othercaps;
 779   GstCaps *otherfilter;
 780   gint i, j;
 781
 782   if (!gst_validate_pad_monitor_pad_should_proxy_othercaps (monitor))
 783     return;
 784
 785   otherfilter = gst_validate_pad_monitor_transform_caps (monitor, filter);
 786   othercaps = gst_validate_pad_monitor_get_othercaps (monitor, otherfilter);
 787   if (otherfilter)
 788     gst_caps_unref (otherfilter);
 789
 790   for (i = 0; i < gst_caps_get_size (othercaps); i++) {
 791     gboolean found = FALSE;
 792     gboolean type_match = FALSE;
 793
 794     otherstructure = gst_caps_get_structure (othercaps, i);
 795
 796     /* look for a proxied version of 'otherstructure' */
 797     if (_structure_is_video (otherstructure)) {
 798       for (j = 0; j < gst_caps_get_size (caps); j++) {
 799         structure = gst_caps_get_structure (caps, j);
 800         if (_structure_is_video (structure)) {
 801           type_match = TRUE;
 802           if (_structures_field_is_contained (structure, otherstructure, TRUE,
 803                   "width")
 804               && _structures_field_is_contained (structure, otherstructure,
 805                   TRUE, "height")
 806               && _structures_field_is_contained (structure, otherstructure,
 807                   TRUE, "framerate")
 808               && _structures_field_is_contained (structure, otherstructure,
 809                   FALSE, "pixel-aspect-ratio")) {
 810             found = TRUE;
 811             break;
 812           }
 813         }
 814       }
 815     } else if (_structure_is_audio (otherstructure)) {
 816       for (j = 0; j < gst_caps_get_size (caps); j++) {
 817         structure = gst_caps_get_structure (caps, j);
 818         if (_structure_is_audio (structure)) {
 819           type_match = TRUE;
 820           if (_structures_field_is_contained (structure, otherstructure, TRUE,
 821                   "rate")
 822               && _structures_field_is_contained (structure, otherstructure,
 823                   TRUE, "channels")) {
 824             found = TRUE;
 825             break;
 826           }
 827         }
 828       }
 829     }
 830
 831     if (type_match && !found) {
 832       gchar *otherstruct_str = gst_structure_to_string (otherstructure),
 833           *caps_str = gst_caps_to_string (caps);
 834
 835       GST_VALIDATE_REPORT (monitor, GET_CAPS_NOT_PROXYING_FIELDS,
 836           "Peer pad structure '%s' has no similar version "
 837           "on pad's caps '%s'", otherstruct_str, caps_str);
 838
 839       g_free (otherstruct_str);
 840       g_free (caps_str);
 841     }
 842   }
 843
 844   gst_caps_unref (othercaps);
 845 }
 846
 847 static void
 848 gst_validate_pad_monitor_check_late_serialized_events (GstValidatePadMonitor *
 849     monitor, GstClockTime ts)
 850 {
 851   gint i;
 852   GstPad *pad;
 853
 854   if (!GST_CLOCK_TIME_IS_VALID (ts))
 855     return;
 856
 857   pad =
 858       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
 859           (monitor)));
 860
 861   GST_DEBUG_OBJECT (pad, "Timestamp to check %" GST_TIME_FORMAT,
 862       GST_TIME_ARGS (ts));
 863
 864   for (i = 0; i < monitor->serialized_events->len; i++) {
 865     SerializedEventData *data =
 866         g_ptr_array_index (monitor->serialized_events, i);
 867
 868     GST_DEBUG_OBJECT (pad, "Event #%d (%s) ts: %" GST_TIME_FORMAT,
 869         i, GST_EVENT_TYPE_NAME (data->event), GST_TIME_ARGS (data->timestamp));
 870
 871     if (GST_CLOCK_TIME_IS_VALID (data->timestamp) && data->timestamp < ts) {
 872       gchar *event_str = _get_event_string (data->event);
 873
 874       GST_VALIDATE_REPORT (monitor, SERIALIZED_EVENT_WASNT_PUSHED_IN_TIME,
 875           "Serialized event %s wasn't pushed before expected timestamp %"
 876           GST_TIME_FORMAT " on pad %s:%s", event_str,
 877           GST_TIME_ARGS (data->timestamp), GST_DEBUG_PAD_NAME (pad));
 878
 879       g_free (event_str);
 880     } else {
 881       /* events should be ordered by ts */
 882       break;
 883     }
 884   }
 885
 886   if (i) {
 887     debug_pending_event (pad, monitor->serialized_events);
 888     g_ptr_array_remove_range (monitor->serialized_events, 0, i);
 889   }
 890
 891   gst_object_unref (pad);
 892 }
 893
 894 static void
 895 seek_data_free (GstValidatePadSeekData * data)
 896 {
 897   g_slice_free (GstValidatePadSeekData, data);
 898 }
 899
 900 static GstValidatePadSeekData *
 901 seek_data_for_seqnum (GstValidatePadMonitor * monitor, guint32 seqnum)
 902 {
 903   GList *tmp;
 904
 905   for (tmp = monitor->seeks; tmp; tmp = tmp->next) {
 906     GstValidatePadSeekData *data = (GstValidatePadSeekData *) tmp->data;
 907     if (data->seqnum == seqnum)
 908       return data;
 909   }
 910
 911   return NULL;
 912 }
 913
 914 static void
 915 gst_validate_pad_monitor_dispose (GObject * object)
 916 {
 917   GstValidatePadMonitor *monitor = GST_VALIDATE_PAD_MONITOR_CAST (object);
 918   GstPad *pad =
 919       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
 920           (monitor)));
 921
 922   if (pad) {
 923     if (monitor->pad_probe_id)
 924       gst_pad_remove_probe (pad, monitor->pad_probe_id);
 925     gst_object_unref (pad);
 926   }
 927
 928   if (monitor->expected_segment)
 929     gst_event_unref (monitor->expected_segment);
 930
 931   gst_structure_free (monitor->pending_setcaps_fields);
 932   g_ptr_array_unref (monitor->serialized_events);
 933   g_list_free_full (monitor->expired_events, (GDestroyNotify) gst_event_unref);
 934   g_list_free_full (monitor->all_bufs, (GDestroyNotify) gst_buffer_unref);
 935   gst_caps_replace (&monitor->last_caps, NULL);
 936   gst_caps_replace (&monitor->last_query_res, NULL);
 937   gst_caps_replace (&monitor->last_query_filter, NULL);
 938
 939   g_list_free_full (monitor->seeks, (GDestroyNotify) seek_data_free);
 940
 941   G_OBJECT_CLASS (parent_class)->dispose (object);
 942 }
 943
 944 static void
 945 gst_validate_pad_monitor_class_init (GstValidatePadMonitorClass * klass)
 946 {
 947   GObjectClass *gobject_class;
 948   GstValidateMonitorClass *monitor_klass;
 949
 950   gobject_class = G_OBJECT_CLASS (klass);
 951   monitor_klass = GST_VALIDATE_MONITOR_CLASS (klass);
 952
 953   gobject_class->dispose = gst_validate_pad_monitor_dispose;
 954
 955   monitor_klass->setup = gst_validate_pad_monitor_do_setup;
 956   monitor_klass->get_element = gst_validate_pad_monitor_get_element;
 957 }
 958
 959 /* Called when a pad is being flushed */
 960 static void
 961 gst_validate_pad_monitor_flush (GstValidatePadMonitor * pad_monitor)
 962 {
 963   /* Note: Keep in the same order as in the GstValidatePadMonitor structure */
 964
 965   gst_caps_replace (&pad_monitor->last_caps, NULL);
 966   pad_monitor->caps_is_audio = pad_monitor->caps_is_video =
 967       pad_monitor->caps_is_raw = FALSE;
 968
 969   pad_monitor->first_buffer = TRUE;
 970
 971   pad_monitor->has_segment = FALSE;
 972   pad_monitor->is_eos = FALSE;
 973
 974   pad_monitor->pending_buffer_discont = TRUE;
 975
 976   gst_event_replace (&pad_monitor->expected_segment, NULL);
 977   if (pad_monitor->serialized_events->len)
 978     g_ptr_array_remove_range (pad_monitor->serialized_events, 0,
 979         pad_monitor->serialized_events->len);
 980   g_list_free_full (pad_monitor->expired_events,
 981       (GDestroyNotify) gst_event_unref);
 982   pad_monitor->expired_events = NULL;
 983
 984   gst_segment_init (&pad_monitor->segment, GST_FORMAT_BYTES);
 985   pad_monitor->current_timestamp = GST_CLOCK_TIME_NONE;
 986   pad_monitor->current_duration = GST_CLOCK_TIME_NONE;
 987
 988   pad_monitor->last_flow_return = GST_FLOW_OK;
 989
 990   pad_monitor->timestamp_range_start = GST_CLOCK_TIME_NONE;
 991   pad_monitor->timestamp_range_end = GST_CLOCK_TIME_NONE;
 992 }
 993
 994 /* Called when the pad monitor is initialized or when
 995  * the pad is deactivated */
 996 static void
 997 gst_validate_pad_monitor_reset (GstValidatePadMonitor * pad_monitor)
 998 {
 999   gst_validate_pad_monitor_flush (pad_monitor);
1000
1001   /* Note : For the entries that haven't been reset in _flush(), do
1002    * it here and keep in the same order as the GstValidatePadMonitor
1003    * structure */
1004
1005   pad_monitor->pending_flush_stop = FALSE;
1006   pad_monitor->pending_newsegment_seqnum = GST_SEQNUM_INVALID;
1007   pad_monitor->pending_eos_seqnum = GST_SEQNUM_INVALID;
1008
1009   if (pad_monitor->pending_setcaps_fields)
1010     gst_structure_free (pad_monitor->pending_setcaps_fields);
1011   pad_monitor->pending_setcaps_fields =
1012       gst_structure_new_empty (PENDING_FIELDS);
1013   if (pad_monitor->seeks)
1014     g_list_free_full (pad_monitor->seeks, (GDestroyNotify) seek_data_free);
1015   pad_monitor->current_seek = NULL;
1016   pad_monitor->seeks = NULL;
1017
1018   /* FIXME : Why BYTES and not UNDEFINED ? */
1019   gst_segment_init (&pad_monitor->segment, GST_FORMAT_BYTES);
1020
1021   pad_monitor->min_buf_freq = 0;
1022   pad_monitor->buffers_pushed = 0;
1023   pad_monitor->last_buffers_pushed = 0;
1024   pad_monitor->min_buf_freq_interval_ts = GST_CLOCK_TIME_NONE;
1025   pad_monitor->min_buf_freq_first_buffer_ts = GST_CLOCK_TIME_NONE;
1026   pad_monitor->min_buf_freq_start = GST_CLOCK_TIME_NONE;
1027 }
1028
1029 static void
1030 gst_validate_pad_monitor_init (GstValidatePadMonitor * pad_monitor)
1031 {
1032   pad_monitor->serialized_events =
1033       g_ptr_array_new_with_free_func ((GDestroyNotify)
1034       _serialized_event_data_free);
1035
1036   gst_validate_pad_monitor_reset (pad_monitor);
1037 }
1038
1039 /**
1040  * gst_validate_pad_monitor_new:
1041  * @pad: (transfer none): a #GstPad to run Validate on
1042  */
1043 GstValidatePadMonitor *
1044 gst_validate_pad_monitor_new (GstPad * pad, GstValidateRunner * runner,
1045     GstValidateElementMonitor * parent)
1046 {
1047   GstValidatePadMonitor *monitor = g_object_new (GST_TYPE_VALIDATE_PAD_MONITOR,
1048       "object", pad, "validate-runner", runner, "validate-parent",
1049       parent, NULL);
1050   GstObject *target =
1051       gst_validate_monitor_get_target (GST_VALIDATE_MONITOR (monitor));
1052
1053   if (target == NULL) {
1054     g_object_unref (monitor);
1055     return NULL;
1056   }
1057
1058   gst_object_unref (target);
1059   return monitor;
1060 }
1061
1062 static GstElement *
1063 gst_validate_pad_monitor_get_element (GstValidateMonitor * monitor)
1064 {
1065   GstPad *pad =
1066       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1067           (monitor)));
1068   GstElement *parent = GST_ELEMENT (gst_pad_get_parent (pad));
1069
1070   gst_object_unref (pad);
1071
1072   return parent;
1073 }
1074
1075 static void
1076 gst_validate_pad_monitor_event_overrides (GstValidatePadMonitor * pad_monitor,
1077     GstEvent * event)
1078 {
1079   GList *iter;
1080
1081   GST_VALIDATE_MONITOR_OVERRIDES_LOCK (pad_monitor);
1082   for (iter = GST_VALIDATE_MONITOR_OVERRIDES (pad_monitor).head; iter;
1083       iter = g_list_next (iter)) {
1084     GstValidateOverride *override = iter->data;
1085
1086     gst_validate_override_event_handler (override,
1087         GST_VALIDATE_MONITOR_CAST (pad_monitor), event);
1088   }
1089   GST_VALIDATE_MONITOR_OVERRIDES_UNLOCK (pad_monitor);
1090 }
1091
1092 static void
1093 gst_validate_pad_monitor_buffer_overrides (GstValidatePadMonitor * pad_monitor,
1094     GstBuffer * buffer)
1095 {
1096   GList *iter;
1097
1098   GST_VALIDATE_MONITOR_OVERRIDES_LOCK (pad_monitor);
1099   for (iter = GST_VALIDATE_MONITOR_OVERRIDES (pad_monitor).head; iter;
1100       iter = g_list_next (iter)) {
1101     GstValidateOverride *override = iter->data;
1102
1103     gst_validate_override_buffer_handler (override,
1104         GST_VALIDATE_MONITOR_CAST (pad_monitor), buffer);
1105   }
1106   GST_VALIDATE_MONITOR_OVERRIDES_UNLOCK (pad_monitor);
1107 }
1108
1109 static void
1110 gst_validate_pad_monitor_buffer_probe_overrides (GstValidatePadMonitor *
1111     pad_monitor, GstBuffer * buffer)
1112 {
1113   GList *iter;
1114
1115   GST_VALIDATE_MONITOR_OVERRIDES_LOCK (pad_monitor);
1116   for (iter = GST_VALIDATE_MONITOR_OVERRIDES (pad_monitor).head; iter;
1117       iter = g_list_next (iter)) {
1118     GstValidateOverride *override = iter->data;
1119
1120     gst_validate_override_buffer_probe_handler (override,
1121         GST_VALIDATE_MONITOR_CAST (pad_monitor), buffer);
1122   }
1123   GST_VALIDATE_MONITOR_OVERRIDES_UNLOCK (pad_monitor);
1124 }
1125
1126 static void
1127 gst_validate_pad_monitor_query_overrides (GstValidatePadMonitor * pad_monitor,
1128     GstQuery * query)
1129 {
1130   GList *iter;
1131
1132   GST_VALIDATE_MONITOR_OVERRIDES_LOCK (pad_monitor);
1133   for (iter = GST_VALIDATE_MONITOR_OVERRIDES (pad_monitor).head; iter;
1134       iter = g_list_next (iter)) {
1135     GstValidateOverride *override = iter->data;
1136
1137     gst_validate_override_query_handler (override,
1138         GST_VALIDATE_MONITOR_CAST (pad_monitor), query);
1139   }
1140   GST_VALIDATE_MONITOR_OVERRIDES_UNLOCK (pad_monitor);
1141 }
1142
1143 static void
1144 gst_validate_pad_monitor_setcaps_overrides (GstValidatePadMonitor * pad_monitor,
1145     GstCaps * caps)
1146 {
1147   GList *iter;
1148
1149   GST_VALIDATE_MONITOR_OVERRIDES_LOCK (pad_monitor);
1150   for (iter = GST_VALIDATE_MONITOR_OVERRIDES (pad_monitor).head; iter;
1151       iter = g_list_next (iter)) {
1152     GstValidateOverride *override = iter->data;
1153
1154     gst_validate_override_setcaps_handler (override,
1155         GST_VALIDATE_MONITOR_CAST (pad_monitor), caps);
1156   }
1157   GST_VALIDATE_MONITOR_OVERRIDES_UNLOCK (pad_monitor);
1158 }
1159
1160 /* FIXME : This is a bit dubious, what's the point of this check ? */
1161 static gboolean
1162 gst_validate_pad_monitor_timestamp_is_in_received_range (GstValidatePadMonitor *
1163     monitor, GstClockTime ts, GstClockTime tolerance)
1164 {
1165   GstPad *pad =
1166       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1167           (monitor)));
1168
1169   GST_DEBUG_OBJECT (pad,
1170       "Checking if timestamp %" GST_TIME_FORMAT " is in range: %"
1171       GST_TIME_FORMAT " - %" GST_TIME_FORMAT " for pad "
1172       "%s:%s with tolerance: %" GST_TIME_FORMAT, GST_TIME_ARGS (ts),
1173       GST_TIME_ARGS (monitor->timestamp_range_start),
1174       GST_TIME_ARGS (monitor->timestamp_range_end), GST_DEBUG_PAD_NAME (pad),
1175       GST_TIME_ARGS (tolerance));
1176   gst_object_unref (pad);
1177
1178   return !GST_CLOCK_TIME_IS_VALID (monitor->timestamp_range_start) ||
1179       !GST_CLOCK_TIME_IS_VALID (monitor->timestamp_range_end) ||
1180       ((monitor->timestamp_range_start >= tolerance ?
1181           monitor->timestamp_range_start - tolerance : 0) <= ts
1182       && (ts >= tolerance ? ts - tolerance : 0) <=
1183       monitor->timestamp_range_end);
1184 }
1185
1186 /* Iterates over internal links (sinkpads) to check that this buffer has
1187  * a timestamp that is in the range of the lastly received buffers */
1188 static void
1189     gst_validate_pad_monitor_check_buffer_timestamp_in_received_range
1190     (GstValidatePadMonitor * monitor, GstBuffer * buffer,
1191     GstClockTime tolerance)
1192 {
1193   GstClockTime ts;
1194   GstClockTime ts_end;
1195   GstIterator *iter;
1196   gboolean has_one = FALSE;
1197   gboolean found = FALSE;
1198   gboolean done;
1199   GstPad *otherpad;
1200   GstValidatePadMonitor *othermonitor;
1201   GstPad *pad =
1202       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1203           (monitor)));
1204
1205   if (!GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buffer))
1206       || !GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DURATION (buffer))) {
1207     GST_DEBUG_OBJECT (pad,
1208         "Can't check buffer timestamps range as "
1209         "buffer has no valid timestamp/duration");
1210     goto done;
1211   }
1212
1213   ts = GST_BUFFER_TIMESTAMP (buffer);
1214   ts_end = ts + GST_BUFFER_DURATION (buffer);
1215
1216   iter = gst_pad_iterate_internal_links (pad);
1217
1218   if (iter == NULL) {
1219     GST_WARNING_OBJECT (pad, "No iterator available");
1220     goto done;
1221   }
1222
1223   done = FALSE;
1224   while (!done) {
1225     GValue value = { 0, };
1226     switch (gst_iterator_next (iter, &value)) {
1227       case GST_ITERATOR_OK:
1228         otherpad = g_value_get_object (&value);
1229         GST_DEBUG_OBJECT (pad, "Checking pad %s:%s input timestamps",
1230             GST_DEBUG_PAD_NAME (otherpad));
1231         othermonitor = _GET_PAD_MONITOR (otherpad);
1232         if (!othermonitor)
1233           continue;
1234
1235         GST_VALIDATE_MONITOR_LOCK (othermonitor);
1236         if (gst_validate_pad_monitor_timestamp_is_in_received_range
1237             (othermonitor, ts, tolerance)
1238             &&
1239             gst_validate_pad_monitor_timestamp_is_in_received_range
1240             (othermonitor, ts_end, tolerance)) {
1241           done = TRUE;
1242           found = TRUE;
1243         }
1244         GST_VALIDATE_MONITOR_UNLOCK (othermonitor);
1245         g_value_reset (&value);
1246         has_one = TRUE;
1247         break;
1248       case GST_ITERATOR_RESYNC:
1249         gst_iterator_resync (iter);
1250         has_one = FALSE;
1251         found = FALSE;
1252         break;
1253       case GST_ITERATOR_ERROR:
1254         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
1255         done = TRUE;
1256         break;
1257       case GST_ITERATOR_DONE:
1258         done = TRUE;
1259         break;
1260     }
1261   }
1262   gst_iterator_free (iter);
1263
1264   if (!has_one) {
1265     GST_DEBUG_OBJECT (pad, "Skipping timestamp in range check as no "
1266         "internal linked pad was found");
1267     goto done;
1268   }
1269   if (!found) {
1270     GST_VALIDATE_REPORT (monitor, BUFFER_TIMESTAMP_OUT_OF_RECEIVED_RANGE,
1271         "Timestamp %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT
1272         " is out of range of received input", GST_TIME_ARGS (ts),
1273         GST_TIME_ARGS (ts_end));
1274   }
1275 done:
1276   if (pad)
1277     gst_object_unref (pad);
1278 }
1279
1280 static void
1281 gst_validate_pad_monitor_check_discont (GstValidatePadMonitor * pad_monitor,
1282     GstBuffer * buffer)
1283 {
1284   if (pad_monitor->pending_buffer_discont) {
1285     if (!GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))
1286       GST_VALIDATE_REPORT (pad_monitor, BUFFER_MISSING_DISCONT,
1287           "Buffer is missing a DISCONT flag");
1288     pad_monitor->pending_buffer_discont = FALSE;
1289   }
1290 }
1291
1292 static void
1293 gst_validate_pad_monitor_check_first_buffer (GstValidatePadMonitor *
1294     pad_monitor, GstBuffer * buffer)
1295 {
1296   GstPad *pad =
1297       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1298           (pad_monitor)));
1299
1300   if (G_UNLIKELY (pad_monitor->first_buffer)) {
1301     pad_monitor->first_buffer = FALSE;
1302
1303     if (!pad_monitor->has_segment && PAD_IS_IN_PUSH_MODE (pad)) {
1304       GST_VALIDATE_REPORT (pad_monitor, BUFFER_BEFORE_SEGMENT,
1305           "Received buffer before Segment event");
1306     }
1307
1308     GST_DEBUG_OBJECT (pad,
1309         "Checking first buffer (pts:%" GST_TIME_FORMAT " dts:%" GST_TIME_FORMAT
1310         ")", GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
1311         GST_TIME_ARGS (GST_BUFFER_DTS (buffer)));
1312
1313   }
1314
1315   gst_object_unref (pad);
1316 }
1317
1318 static void
1319 gst_validate_pad_monitor_check_eos (GstValidatePadMonitor *
1320     pad_monitor, GstBuffer * buffer)
1321 {
1322   if (G_UNLIKELY (pad_monitor->is_eos)) {
1323     GST_VALIDATE_REPORT (pad_monitor, BUFFER_AFTER_EOS,
1324         "Received buffer %" GST_PTR_FORMAT " after EOS", buffer);
1325   }
1326 }
1327
1328 static void
1329 gst_validate_pad_monitor_update_buffer_data (GstValidatePadMonitor *
1330     pad_monitor, GstBuffer * buffer)
1331 {
1332   GstPad *pad =
1333       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1334           (pad_monitor)));
1335   pad_monitor->current_timestamp = GST_BUFFER_TIMESTAMP (buffer);
1336   pad_monitor->current_duration = GST_BUFFER_DURATION (buffer);
1337   if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buffer))) {
1338     if (GST_CLOCK_TIME_IS_VALID (pad_monitor->timestamp_range_start)) {
1339       pad_monitor->timestamp_range_start =
1340           MIN (pad_monitor->timestamp_range_start,
1341           GST_BUFFER_TIMESTAMP (buffer));
1342     } else {
1343       pad_monitor->timestamp_range_start = GST_BUFFER_TIMESTAMP (buffer);
1344     }
1345
1346     if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DURATION (buffer))) {
1347       GstClockTime endts =
1348           GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer);
1349       if (GST_CLOCK_TIME_IS_VALID (pad_monitor->timestamp_range_end)) {
1350         pad_monitor->timestamp_range_end =
1351             MAX (pad_monitor->timestamp_range_end, endts);
1352       } else {
1353         pad_monitor->timestamp_range_end = endts;
1354       }
1355     }
1356   }
1357   GST_DEBUG_OBJECT (pad, "Current stored range: %" GST_TIME_FORMAT
1358       " - %" GST_TIME_FORMAT,
1359       GST_TIME_ARGS (pad_monitor->timestamp_range_start),
1360       GST_TIME_ARGS (pad_monitor->timestamp_range_end));
1361
1362   gst_object_unref (pad);
1363 }
1364
1365 static GstFlowReturn
1366 _combine_flows (GstFlowReturn ret1, GstFlowReturn ret2)
1367 {
1368   if (ret1 == ret2)
1369     return ret1;
1370   if (ret1 <= GST_FLOW_NOT_NEGOTIATED)
1371     return ret1;
1372   if (ret2 <= GST_FLOW_NOT_NEGOTIATED)
1373     return ret2;
1374   if (ret1 == GST_FLOW_FLUSHING || ret2 == GST_FLOW_FLUSHING)
1375     return GST_FLOW_FLUSHING;
1376   if (ret1 == GST_FLOW_OK || ret2 == GST_FLOW_OK)
1377     return GST_FLOW_OK;
1378   return ret2;
1379 }
1380
1381 static void
1382 gst_validate_pad_monitor_check_aggregated_return (GstValidatePadMonitor *
1383     monitor, GstObject * parent, GstFlowReturn ret)
1384 {
1385   GstIterator *iter;
1386   gboolean done;
1387   GstPad *otherpad;
1388   GstPad *peerpad;
1389   GstState state, pending;
1390   GstValidatePadMonitor *othermonitor;
1391   GstFlowReturn aggregated = GST_FLOW_NOT_LINKED;
1392   gboolean found_a_pad = FALSE;
1393   GstPad *pad =
1394       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1395           (monitor)));
1396
1397   iter = gst_pad_iterate_internal_links (pad);
1398   done = FALSE;
1399   while (!done) {
1400     GValue value = { 0, };
1401     switch (gst_iterator_next (iter, &value)) {
1402       case GST_ITERATOR_OK:
1403         otherpad = g_value_get_object (&value);
1404         peerpad = gst_pad_get_peer (otherpad);
1405         if (peerpad) {
1406           othermonitor = _GET_PAD_MONITOR (peerpad);
1407           if (othermonitor) {
1408             found_a_pad = TRUE;
1409             GST_VALIDATE_MONITOR_LOCK (othermonitor);
1410             aggregated =
1411                 _combine_flows (aggregated, othermonitor->last_flow_return);
1412             GST_VALIDATE_MONITOR_UNLOCK (othermonitor);
1413           }
1414
1415           gst_object_unref (peerpad);
1416         }
1417         g_value_reset (&value);
1418         break;
1419       case GST_ITERATOR_RESYNC:
1420         gst_iterator_resync (iter);
1421         break;
1422       case GST_ITERATOR_ERROR:
1423         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
1424         done = TRUE;
1425         break;
1426       case GST_ITERATOR_DONE:
1427         done = TRUE;
1428         break;
1429     }
1430   }
1431   gst_iterator_free (iter);
1432   if (!found_a_pad) {
1433     /* no peer pad found, nothing to do */
1434     goto done;
1435   }
1436
1437   if (aggregated == GST_FLOW_FLUSHING) {
1438     gst_element_get_state (GST_ELEMENT (parent), &state, &pending, 0);
1439     if (state < GST_STATE_PAUSED || pending < GST_STATE_PAUSED) {
1440       /* Aggregated is flushing, we might have been aggregating a combination
1441        * of pads that are not what was present on the element during the actual
1442        * data flow combination (pads might have been removed meanwhile) */
1443
1444       goto done;
1445     }
1446   } else if (aggregated == GST_FLOW_OK || aggregated == GST_FLOW_EOS) {
1447
1448     /* those are acceptable situations */
1449     if (GST_PAD_IS_FLUSHING (pad) && ret == GST_FLOW_FLUSHING) {
1450       /* pad is flushing, always acceptable to return flushing */
1451       goto done;
1452     }
1453
1454     gst_element_get_state (GST_ELEMENT (parent), &state, &pending, 0);
1455     if (ret == GST_FLOW_FLUSHING && (state < GST_STATE_PAUSED
1456             || pending < GST_STATE_PAUSED)) {
1457       /* Element is being teared down, accept FLOW_FLUSHING */
1458
1459       goto done;
1460     }
1461
1462     if (monitor->is_eos && ret == GST_FLOW_EOS) {
1463       /* this element received eos and returned eos */
1464       goto done;
1465     }
1466
1467     if (PAD_PARENT_IS_DEMUXER (monitor) && ret == GST_FLOW_EOS) {
1468       /* a demuxer can return EOS when the samples end */
1469       goto done;
1470     }
1471   }
1472
1473   if (aggregated != ret) {
1474     GST_VALIDATE_REPORT (monitor, WRONG_FLOW_RETURN,
1475         "Wrong combined flow return %s(%d). Expected: %s(%d)",
1476         gst_flow_get_name (ret), ret, gst_flow_get_name (aggregated),
1477         aggregated);
1478   }
1479
1480 done:
1481   gst_object_unref (pad);
1482 }
1483
1484 static void
1485     gst_validate_pad_monitor_otherpad_add_pending_serialized_event
1486     (GstValidatePadMonitor * monitor, GstEvent * event, GstClockTime last_ts)
1487 {
1488   GstIterator *iter;
1489   gboolean done;
1490   GstPad *otherpad;
1491   GstValidatePadMonitor *othermonitor;
1492   GstPad *pad;
1493
1494
1495   if (!GST_EVENT_IS_SERIALIZED (event))
1496     return;
1497
1498   pad =
1499       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1500           (monitor)));
1501   iter = gst_pad_iterate_internal_links (pad);
1502   if (iter == NULL) {
1503     /* inputselector will return NULL if the sinkpad is not the active one .... */
1504     GST_FIXME_OBJECT (pad, "No iterator");
1505     gst_object_unref (pad);
1506     return;
1507   }
1508
1509   done = FALSE;
1510   while (!done) {
1511     GValue value = { 0, };
1512     switch (gst_iterator_next (iter, &value)) {
1513       case GST_ITERATOR_OK:
1514         otherpad = g_value_get_object (&value);
1515         othermonitor = _GET_PAD_MONITOR (otherpad);
1516         if (othermonitor) {
1517           SerializedEventData *data = g_slice_new0 (SerializedEventData);
1518           data->timestamp = last_ts;
1519           data->event = gst_event_ref (event);
1520           GST_VALIDATE_MONITOR_LOCK (othermonitor);
1521           GST_DEBUG_OBJECT (pad, "Storing for pad %s:%s event %p %s",
1522               GST_DEBUG_PAD_NAME (otherpad), event,
1523               GST_EVENT_TYPE_NAME (event));
1524           g_ptr_array_add (othermonitor->serialized_events, data);
1525           debug_pending_event (otherpad, othermonitor->serialized_events);
1526           GST_VALIDATE_MONITOR_UNLOCK (othermonitor);
1527         }
1528         g_value_reset (&value);
1529         break;
1530       case GST_ITERATOR_RESYNC:
1531         gst_iterator_resync (iter);
1532         break;
1533       case GST_ITERATOR_ERROR:
1534         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
1535         done = TRUE;
1536         break;
1537       case GST_ITERATOR_DONE:
1538         done = TRUE;
1539         break;
1540     }
1541   }
1542   gst_iterator_free (iter);
1543   gst_object_unref (pad);
1544 }
1545
1546 static void
1547 gst_validate_pad_monitor_otherpad_add_pending_field (GstValidatePadMonitor *
1548     monitor, GstStructure * structure, const gchar * field)
1549 {
1550   GstIterator *iter;
1551   gboolean done;
1552   GstPad *otherpad;
1553   GstValidatePadMonitor *othermonitor;
1554   const GValue *v;
1555   GstPad *pad;
1556
1557   v = gst_structure_get_value (structure, field);
1558   pad =
1559       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1560           (monitor)));
1561
1562   if (v == NULL) {
1563     GST_DEBUG_OBJECT (pad, "Not adding pending field %s as it isn't "
1564         "present on structure %" GST_PTR_FORMAT, field, structure);
1565     gst_object_unref (pad);
1566     return;
1567   }
1568
1569   iter = gst_pad_iterate_internal_links (pad);
1570   done = FALSE;
1571   while (!done) {
1572     GValue value = { 0, };
1573     switch (gst_iterator_next (iter, &value)) {
1574       case GST_ITERATOR_OK:
1575         otherpad = g_value_get_object (&value);
1576         othermonitor = _GET_PAD_MONITOR (otherpad);
1577         if (othermonitor) {
1578           GST_VALIDATE_MONITOR_LOCK (othermonitor);
1579           g_assert (othermonitor->pending_setcaps_fields != NULL);
1580           gst_structure_set_value (othermonitor->pending_setcaps_fields,
1581               field, v);
1582           GST_VALIDATE_MONITOR_UNLOCK (othermonitor);
1583         }
1584         g_value_reset (&value);
1585         break;
1586       case GST_ITERATOR_RESYNC:
1587         gst_iterator_resync (iter);
1588         break;
1589       case GST_ITERATOR_ERROR:
1590         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
1591         done = TRUE;
1592         break;
1593       case GST_ITERATOR_DONE:
1594         done = TRUE;
1595         break;
1596     }
1597   }
1598   gst_iterator_free (iter);
1599   gst_object_unref (pad);
1600 }
1601
1602 static void
1603 gst_validate_pad_monitor_otherpad_clear_pending_fields (GstValidatePadMonitor *
1604     monitor)
1605 {
1606   GstIterator *iter;
1607   gboolean done;
1608   GstPad *otherpad;
1609   GstValidatePadMonitor *othermonitor;
1610
1611   GstPad *pad =
1612       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1613           (monitor)));
1614
1615   iter = gst_pad_iterate_internal_links (pad);
1616   if (iter == NULL) {
1617     gst_object_unref (pad);
1618     GST_DEBUG_OBJECT (monitor, "No internally linked pad");
1619
1620     return;
1621   }
1622
1623   done = FALSE;
1624   while (!done) {
1625     GValue value = { 0, };
1626     switch (gst_iterator_next (iter, &value)) {
1627       case GST_ITERATOR_OK:
1628         otherpad = g_value_get_object (&value);
1629         othermonitor = _GET_PAD_MONITOR (otherpad);
1630         if (othermonitor) {
1631           GST_VALIDATE_MONITOR_LOCK (othermonitor);
1632           g_assert (othermonitor->pending_setcaps_fields != NULL);
1633           gst_structure_free (othermonitor->pending_setcaps_fields);
1634           othermonitor->pending_setcaps_fields =
1635               gst_structure_new_empty (PENDING_FIELDS);
1636           GST_VALIDATE_MONITOR_UNLOCK (othermonitor);
1637         }
1638         g_value_reset (&value);
1639         break;
1640       case GST_ITERATOR_RESYNC:
1641         gst_iterator_resync (iter);
1642         break;
1643       case GST_ITERATOR_ERROR:
1644         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
1645         done = TRUE;
1646         break;
1647       case GST_ITERATOR_DONE:
1648         done = TRUE;
1649         break;
1650     }
1651   }
1652   gst_object_unref (pad);
1653   gst_iterator_free (iter);
1654 }
1655
1656 static void
1657 gst_validate_pad_monitor_add_expected_newsegment (GstValidatePadMonitor *
1658     monitor, GstEvent * event)
1659 {
1660   GstIterator *iter;
1661   gboolean done;
1662   GstPad *otherpad;
1663   GstValidatePadMonitor *othermonitor;
1664   GstPad *pad =
1665       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1666           (monitor)));
1667
1668   iter = gst_pad_iterate_internal_links (pad);
1669   if (iter == NULL) {
1670     GST_DEBUG_OBJECT (monitor, "No internally linked pad");
1671     gst_object_unref (pad);
1672     return;
1673   }
1674
1675   done = FALSE;
1676   while (!done) {
1677     GValue value = { 0, };
1678     switch (gst_iterator_next (iter, &value)) {
1679       case GST_ITERATOR_OK:
1680         otherpad = g_value_get_object (&value);
1681         if (!otherpad) {
1682           g_value_reset (&value);
1683           continue;
1684         }
1685
1686         othermonitor = _GET_PAD_MONITOR (otherpad);
1687         if (!othermonitor) {
1688           g_value_reset (&value);
1689           continue;
1690         }
1691
1692         GST_VALIDATE_MONITOR_LOCK (othermonitor);
1693         gst_event_replace (&othermonitor->expected_segment, event);
1694         GST_VALIDATE_MONITOR_UNLOCK (othermonitor);
1695         g_value_reset (&value);
1696         break;
1697       case GST_ITERATOR_RESYNC:
1698         gst_iterator_resync (iter);
1699         break;
1700       case GST_ITERATOR_ERROR:
1701         GST_WARNING_OBJECT (pad, "Internal links pad iteration error");
1702         done = TRUE;
1703         break;
1704       case GST_ITERATOR_DONE:
1705         done = TRUE;
1706         break;
1707     }
1708   }
1709   gst_iterator_free (iter);
1710   gst_object_unref (pad);
1711 }
1712
1713 /* common checks for both sink and src event functions */
1714 static void
1715 gst_validate_pad_monitor_common_event_check (GstValidatePadMonitor *
1716     pad_monitor, GstEvent * event)
1717 {
1718   guint32 seqnum = gst_event_get_seqnum (event);
1719
1720   if (seqnum == GST_SEQNUM_INVALID)
1721     GST_VALIDATE_REPORT (pad_monitor, EVENT_INVALID_SEQNUM,
1722         "Event %p (%s) has an invalid SEQNUM", event,
1723         GST_EVENT_TYPE_NAME (event));
1724
1725   switch (GST_EVENT_TYPE (event)) {
1726     case GST_EVENT_FLUSH_START:
1727     {
1728       if (pad_monitor->seeks) {
1729         GstValidatePadSeekData *seekdata =
1730             seek_data_for_seqnum (pad_monitor, seqnum);
1731
1732         if (!seekdata)
1733           GST_VALIDATE_REPORT (pad_monitor, FLUSH_START_HAS_WRONG_SEQNUM,
1734               "Got: %" G_GUINT32_FORMAT " Expected: %" G_GUINT32_FORMAT, seqnum,
1735               ((GstValidatePadSeekData *) pad_monitor->seeks->data)->seqnum);
1736         else {
1737           if (!(seekdata->flags & GST_SEEK_FLAG_FLUSH)) {
1738             GST_VALIDATE_REPORT (pad_monitor, EVENT_FLUSH_START_UNEXPECTED,
1739                 "Received flush-start for a non-flushing seek");
1740           }
1741         }
1742       }
1743
1744       if (pad_monitor->pending_flush_stop) {
1745         GST_VALIDATE_REPORT (pad_monitor, EVENT_FLUSH_START_UNEXPECTED,
1746             "Received flush-start from when flush-stop was expected");
1747       }
1748       pad_monitor->pending_flush_stop = TRUE;
1749       /* Remove the current segment seekdata */
1750       if (pad_monitor->current_seek) {
1751         pad_monitor->seeks =
1752             g_list_remove (pad_monitor->seeks, pad_monitor->current_seek);
1753         seek_data_free (pad_monitor->current_seek);
1754         pad_monitor->current_seek = NULL;
1755       }
1756     }
1757       break;
1758     case GST_EVENT_FLUSH_STOP:
1759     {
1760       if (pad_monitor->seeks && !seek_data_for_seqnum (pad_monitor, seqnum)) {
1761         GST_VALIDATE_REPORT (pad_monitor, FLUSH_STOP_HAS_WRONG_SEQNUM,
1762             "Got: %" G_GUINT32_FORMAT " Expected: %" G_GUINT32_FORMAT, seqnum,
1763             ((GstValidatePadSeekData *) pad_monitor->seeks->data)->seqnum);
1764       }
1765
1766       pad_monitor->pending_newsegment_seqnum = seqnum;
1767       pad_monitor->pending_eos_seqnum = seqnum;
1768
1769       if (!pad_monitor->pending_flush_stop) {
1770         gchar *event_str = _get_event_string (event);
1771
1772         GST_VALIDATE_REPORT (pad_monitor, EVENT_FLUSH_STOP_UNEXPECTED,
1773             "Unexpected flush-stop %s", event_str);
1774         g_free (event_str);
1775       }
1776       pad_monitor->pending_flush_stop = FALSE;
1777
1778       /* Buffers following a FLUSH should have the DISCONT flag set */
1779       pad_monitor->pending_buffer_discont = TRUE;
1780
1781       /* cleanup our data */
1782       gst_validate_pad_monitor_flush (pad_monitor);
1783     }
1784       break;
1785     default:
1786       break;
1787   }
1788 }
1789
1790 static void
1791 mark_pads_eos (GstValidatePadMonitor * pad_monitor)
1792 {
1793   GstValidatePadMonitor *peer_monitor;
1794   GstPad *real_peer;
1795   GstPad *pad =
1796       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1797           (pad_monitor)));
1798   GstPad *peer = gst_pad_get_peer (pad);
1799
1800   gst_object_unref (pad);
1801   pad_monitor->is_eos = TRUE;
1802   if (peer) {
1803     real_peer = _get_actual_pad (peer);
1804     peer_monitor = _GET_PAD_MONITOR (real_peer);
1805     if (peer_monitor)
1806       peer_monitor->is_eos = TRUE;
1807     gst_object_unref (peer);
1808     gst_object_unref (real_peer);
1809   }
1810 }
1811
1812 static inline gboolean
1813 _should_check_buffers (GstValidatePadMonitor * pad_monitor,
1814     gboolean force_checks)
1815 {
1816   GstPad *pad =
1817       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1818           (pad_monitor)));
1819   GstValidateMonitor *monitor = GST_VALIDATE_MONITOR (pad_monitor);
1820
1821   if (pad_monitor->first_buffer || force_checks) {
1822     if (pad_monitor->segment.rate != 1.0) {
1823       GST_INFO_OBJECT (pad_monitor, "We do not support buffer checking"
1824           " for trick modes");
1825
1826       pad_monitor->check_buffers = FALSE;
1827     } else if (!PAD_PARENT_IS_DECODER (pad_monitor)) {
1828       GST_DEBUG_OBJECT (pad, "Not on a decoder => no buffer checking");
1829
1830       pad_monitor->check_buffers = FALSE;
1831     } else if (GST_PAD_DIRECTION (pad) != GST_PAD_SINK) {
1832       GST_DEBUG_OBJECT (pad, "Not a sinkpad => no buffer checking");
1833
1834       pad_monitor->check_buffers = FALSE;
1835     } else if (!pad_monitor->caps_is_video) {
1836       GST_DEBUG_OBJECT (pad, "Not working with video => no buffer checking");
1837
1838       pad_monitor->check_buffers = FALSE;
1839     } else if (monitor->media_descriptor == NULL) {
1840       GST_DEBUG_OBJECT (pad, "No media_descriptor set => no buffer checking");
1841
1842       pad_monitor->check_buffers = FALSE;
1843     } else if (!gst_validate_media_descriptor_detects_frames
1844         (monitor->media_descriptor)) {
1845       GST_DEBUG_OBJECT (pad,
1846           "No frame detection media descriptor => no buffer checking");
1847       pad_monitor->check_buffers = FALSE;
1848     } else if (pad_monitor->all_bufs == NULL &&
1849         !gst_validate_media_descriptor_get_buffers (monitor->media_descriptor,
1850             pad, NULL, &pad_monitor->all_bufs)) {
1851
1852       GST_INFO_OBJECT (monitor,
1853           "The MediaInfo is marked as detecting frame, but getting frames"
1854           " from pad %" GST_PTR_FORMAT " did not work (some format conversion"
1855           " might be happening)", pad);
1856
1857       pad_monitor->check_buffers = FALSE;
1858     } else {
1859       if (!pad_monitor->current_buf)
1860         pad_monitor->current_buf = pad_monitor->all_bufs;
1861       pad_monitor->check_buffers = TRUE;
1862     }
1863   }
1864   gst_object_unref (pad);
1865
1866   return pad_monitor->check_buffers;
1867 }
1868
1869 static void
1870 gst_validate_monitor_find_next_buffer (GstValidatePadMonitor * pad_monitor)
1871 {
1872   GList *tmp;
1873   gboolean passed_start = FALSE;
1874
1875   if (!_should_check_buffers (pad_monitor, TRUE))
1876     return;
1877
1878   for (tmp = g_list_last (pad_monitor->all_bufs); tmp; tmp = tmp->prev) {
1879     GstBuffer *cbuf = (GstBuffer *) tmp->data;
1880     GstClockTime ts =
1881         GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DTS (cbuf)) ? GST_BUFFER_DTS (cbuf)
1882         : GST_BUFFER_PTS (cbuf);
1883
1884     if (!GST_CLOCK_TIME_IS_VALID (ts))
1885       continue;
1886
1887     if (ts <= pad_monitor->segment.start)
1888       passed_start = TRUE;
1889
1890     if (!passed_start)
1891       continue;
1892
1893     if (!GST_BUFFER_FLAG_IS_SET (cbuf, GST_BUFFER_FLAG_DELTA_UNIT)) {
1894       break;
1895     }
1896   }
1897
1898   if (tmp == NULL)
1899     pad_monitor->current_buf = pad_monitor->all_bufs;
1900   else
1901     pad_monitor->current_buf = tmp;
1902 }
1903
1904 static void
1905 post_segment_message (GstValidatePadMonitor * pad_monitor, GstPad * pad,
1906     const GstSegment * segment, guint32 seqnum)
1907 {
1908   GstValidateMonitor *element_monitor =
1909       GST_VALIDATE_MONITOR_GET_PARENT (pad_monitor);
1910   GstElement *element;
1911   GstStructure *structure;
1912   GstMessage *msg;
1913
1914   if (element_monitor == NULL)
1915     return;
1916
1917   element = gst_validate_monitor_get_element (element_monitor);
1918   if (element == NULL)
1919     return;
1920
1921   GST_DEBUG_OBJECT (pad,
1922       "Posting application message for seqnum:%" G_GUINT32_FORMAT " %"
1923       GST_SEGMENT_FORMAT, seqnum, segment);
1924
1925   structure =
1926       gst_structure_new ("validate-segment", "segment", GST_TYPE_SEGMENT,
1927       segment, NULL);
1928   msg = gst_message_new_application ((GstObject *) element, structure);
1929   gst_message_set_seqnum (msg, seqnum);
1930   gst_element_post_message (element, msg);
1931
1932   gst_object_unref (element);
1933
1934   return;
1935 }
1936
1937 /* Checks whether a segment is just an update of another,
1938  * That is to say that only the base and offset field differ and all
1939  * other fields are identical */
1940 static gboolean
1941 is_segment_update (GstSegment * a, const GstSegment * b)
1942 {
1943   /* Note : We never care about the position field, it is only
1944    * used for internal usage by elements */
1945   if (a->rate == b->rate &&
1946       a->applied_rate == b->applied_rate &&
1947       a->format == b->format && a->time == b->time) {
1948     /* Changes in base/offset are considered updates */
1949     /* Updating the end position of a segment is an update */
1950     /* Updating the duration of a segment is an update */
1951     if (a->rate > 0.0) {
1952       if (a->start == b->start)
1953         return TRUE;
1954     } else {
1955       if (a->stop == b->stop)
1956         return TRUE;
1957     }
1958   }
1959   return FALSE;
1960 }
1961
1962 static GstFlowReturn
1963 gst_validate_pad_monitor_downstream_event_check (GstValidatePadMonitor *
1964     pad_monitor, GstObject * parent, GstEvent * event,
1965     GstPadEventFunction handler)
1966 {
1967   GstFlowReturn ret = GST_FLOW_OK;
1968   const GstSegment *segment;
1969   guint32 seqnum = gst_event_get_seqnum (event);
1970   GstPad *pad =
1971       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
1972           (pad_monitor)));
1973
1974   gst_validate_pad_monitor_common_event_check (pad_monitor, event);
1975
1976   /* pre checks */
1977   switch (GST_EVENT_TYPE (event)) {
1978     case GST_EVENT_STREAM_START:
1979       /* Buffers following a STREAM_START should have the DISCONT flag set */
1980       pad_monitor->pending_buffer_discont = TRUE;
1981       break;
1982     case GST_EVENT_SEGMENT:
1983     {
1984       GstValidatePadSeekData *seekdata =
1985           seek_data_for_seqnum (pad_monitor, seqnum);
1986
1987       /* parse segment data to be used if event is handled */
1988       gst_event_parse_segment (event, &segment);
1989
1990       GST_DEBUG_OBJECT (pad,
1991           "Got segment seqnum:%" G_GUINT32_FORMAT " %" GST_SEGMENT_FORMAT,
1992           seqnum, segment);
1993
1994       if (pad_monitor->pending_newsegment_seqnum != GST_SEQNUM_INVALID) {
1995         /* FIXME: Convert to more robust checks */
1996         if (pad_monitor->pending_newsegment_seqnum != seqnum) {
1997           GST_VALIDATE_REPORT (pad_monitor, SEGMENT_HAS_WRONG_SEQNUM,
1998               "Got: %u Expected: %u", seqnum,
1999               pad_monitor->pending_newsegment_seqnum);
2000         }
2001       }
2002
2003       if (seekdata && seekdata != pad_monitor->current_seek) {
2004         /* Check for accurate seeks */
2005         if (seekdata->flags & GST_SEEK_FLAG_ACCURATE) {
2006           if (segment->time != seekdata->start)
2007             GST_VALIDATE_REPORT (pad_monitor, SEGMENT_HAS_WRONG_START,
2008                 "After an accurate seek, got: %" GST_TIME_FORMAT
2009                 " Expected: %" GST_TIME_FORMAT, GST_TIME_ARGS (segment->time),
2010                 GST_TIME_ARGS (seekdata->start));
2011         }
2012       }
2013
2014       pad_monitor->pending_eos_seqnum = seqnum;
2015
2016       if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK) {
2017         gst_validate_pad_monitor_add_expected_newsegment (pad_monitor, event);
2018       } else {
2019         /* check if this segment is the expected one */
2020         if (pad_monitor->expected_segment) {
2021           const GstSegment *exp_segment;
2022
2023           if (pad_monitor->expected_segment != event) {
2024             gst_event_parse_segment (pad_monitor->expected_segment,
2025                 &exp_segment);
2026             if (segment->format == exp_segment->format) {
2027               if ((exp_segment->rate * exp_segment->applied_rate !=
2028                       segment->rate * segment->applied_rate))
2029                 GST_VALIDATE_REPORT (pad_monitor, EVENT_NEW_SEGMENT_MISMATCH,
2030                     "Rate * applied_rate %f != expected %f",
2031                     segment->rate * segment->applied_rate,
2032                     exp_segment->rate * exp_segment->applied_rate);
2033               if (exp_segment->start != segment->start)
2034                 GST_VALIDATE_REPORT (pad_monitor, EVENT_NEW_SEGMENT_MISMATCH,
2035                     "Start %" GST_TIME_FORMAT " != expected %" GST_TIME_FORMAT,
2036                     GST_TIME_ARGS (segment->start),
2037                     GST_TIME_ARGS (exp_segment->start));
2038               if (exp_segment->stop != segment->stop)
2039                 GST_VALIDATE_REPORT (pad_monitor, EVENT_NEW_SEGMENT_MISMATCH,
2040                     "Stop %" GST_TIME_FORMAT " != expected %" GST_TIME_FORMAT,
2041                     GST_TIME_ARGS (segment->stop),
2042                     GST_TIME_ARGS (exp_segment->stop));
2043               if (exp_segment->position != segment->position)
2044                 GST_VALIDATE_REPORT (pad_monitor, EVENT_NEW_SEGMENT_MISMATCH,
2045                     "Position %" GST_TIME_FORMAT " != expected %"
2046                     GST_TIME_FORMAT, GST_TIME_ARGS (segment->position),
2047                     GST_TIME_ARGS (exp_segment->position));
2048             }
2049           }
2050           gst_event_replace (&pad_monitor->expected_segment, NULL);
2051         }
2052       }
2053
2054       /* Drop all expected seekdata from before this segment */
2055       if (seekdata) {
2056         while (pad_monitor->seeks && pad_monitor->seeks->data != seekdata) {
2057           GstValidatePadSeekData *tmp =
2058               (GstValidatePadSeekData *) pad_monitor->seeks->data;
2059           pad_monitor->seeks =
2060               g_list_delete_link (pad_monitor->seeks, pad_monitor->seeks);
2061           seek_data_free (tmp);
2062         }
2063       }
2064       pad_monitor->current_seek = seekdata;
2065     }
2066       break;
2067     case GST_EVENT_CAPS:{
2068       GstCaps *caps;
2069
2070       gst_event_parse_caps (event, &caps);
2071       gst_validate_pad_monitor_setcaps_pre (pad_monitor, caps);
2072       break;
2073     }
2074     case GST_EVENT_EOS:
2075       pad_monitor->is_eos = TRUE;
2076       /* FIXME : This feels and looks wrong ... */
2077       if (pad_monitor->pending_eos_seqnum == GST_SEQNUM_INVALID) {
2078         GST_VALIDATE_REPORT (pad_monitor, EVENT_EOS_WITHOUT_SEGMENT,
2079             "EOS %" GST_PTR_FORMAT " received before a segment was received",
2080             event);
2081       } else if (pad_monitor->pending_eos_seqnum != seqnum) {
2082         GST_VALIDATE_REPORT (pad_monitor, EOS_HAS_WRONG_SEQNUM,
2083             "Got: %u. Expected: %u", seqnum, pad_monitor->pending_eos_seqnum);
2084       }
2085
2086       /*
2087        * TODO add end of stream checks for
2088        *  - events not pushed
2089        *  - buffer data not pushed
2090        *  - pending events not received
2091        */
2092       break;
2093
2094       /* both flushes are handled by the common event function */
2095     case GST_EVENT_FLUSH_START:
2096     case GST_EVENT_FLUSH_STOP:
2097     case GST_EVENT_TAG:
2098     case GST_EVENT_SINK_MESSAGE:
2099     default:
2100       break;
2101   }
2102
2103   GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2104   GST_VALIDATE_PAD_MONITOR_PARENT_UNLOCK (pad_monitor);
2105   gst_validate_pad_monitor_event_overrides (pad_monitor, event);
2106   if (handler) {
2107     gst_event_ref (event);
2108     if (pad_monitor->event_full_func)
2109       ret = pad_monitor->event_full_func (pad, parent, event);
2110     else if (pad_monitor->event_func (pad, parent, event))
2111       ret = GST_FLOW_OK;
2112     else
2113       ret = GST_FLOW_ERROR;
2114   }
2115   GST_VALIDATE_PAD_MONITOR_PARENT_LOCK (pad_monitor);
2116   GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2117
2118   /* post checks */
2119   switch (GST_EVENT_TYPE (event)) {
2120     case GST_EVENT_SEGMENT:
2121       if (ret == GST_FLOW_OK) {
2122         /* If the new segment is not an update of the previous one, then
2123          * the following buffer should have the DISCONT flag set */
2124         if (!is_segment_update (&pad_monitor->segment, segment))
2125           pad_monitor->pending_buffer_discont = TRUE;
2126         if (!pad_monitor->has_segment
2127             && pad_monitor->segment.format != segment->format) {
2128           gst_segment_init (&pad_monitor->segment, segment->format);
2129         }
2130         gst_segment_copy_into (segment, &pad_monitor->segment);
2131         pad_monitor->has_segment = TRUE;
2132         gst_validate_monitor_find_next_buffer (pad_monitor);
2133         if (PAD_PARENT_IS_SINK (pad_monitor))
2134           post_segment_message (pad_monitor, pad, segment, seqnum);
2135       }
2136       break;
2137     case GST_EVENT_CAPS:{
2138       GstCaps *caps;
2139
2140       gst_event_parse_caps (event, &caps);
2141       gst_validate_pad_monitor_setcaps_post (pad_monitor, caps,
2142           ret == GST_FLOW_OK);
2143       break;
2144     }
2145     case GST_EVENT_FLUSH_START:
2146     case GST_EVENT_FLUSH_STOP:
2147     case GST_EVENT_EOS:
2148     case GST_EVENT_TAG:
2149     case GST_EVENT_SINK_MESSAGE:
2150     default:
2151       break;
2152   }
2153
2154   if (handler)
2155     gst_event_unref (event);
2156   gst_object_unref (pad);
2157   return ret;
2158 }
2159
2160 static GstValidatePadSeekData *
2161 _store_seek_event_data (GstValidatePadMonitor * pad_monitor, GstEvent * event)
2162 {
2163   GstValidatePadSeekData *data = g_slice_new0 (GstValidatePadSeekData);
2164
2165   data->seqnum = gst_event_get_seqnum (event);
2166   gst_event_parse_seek (event, &data->rate, &data->format, &data->flags,
2167       &data->start_type, &data->start, &data->stop_type, &data->stop);
2168
2169   pad_monitor->seeks = g_list_append (pad_monitor->seeks, data);
2170
2171   return data;
2172 }
2173
2174 static gboolean
2175 gst_validate_pad_monitor_src_event_check (GstValidatePadMonitor * pad_monitor,
2176     GstObject * parent, GstEvent * event, GstPadEventFunction handler)
2177 {
2178   gboolean ret = TRUE;
2179   GstPad *pad =
2180       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
2181           (pad_monitor)));
2182
2183   gst_validate_pad_monitor_common_event_check (pad_monitor, event);
2184
2185   if (handler) {
2186     GstValidatePadSeekData *seekdata = NULL;
2187
2188     GST_DEBUG_OBJECT (pad, "event %" GST_PTR_FORMAT, event);
2189
2190     /* Safely store pending accurate seek values */
2191     if (GST_EVENT_TYPE (event) == GST_EVENT_SEEK)
2192       seekdata = _store_seek_event_data (pad_monitor, event);
2193     GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2194     ret = pad_monitor->event_func (pad, parent, event);
2195
2196     GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2197
2198     if (seekdata && !ret) {
2199       /* Remove failed seek from list */
2200       GST_LOG_OBJECT (pad, "Failed seek, removing stored seek data");
2201       pad_monitor->seeks = g_list_remove (pad_monitor->seeks, seekdata);
2202       g_slice_free (GstValidatePadSeekData, seekdata);
2203     }
2204   }
2205
2206   gst_object_unref (pad);
2207   return ret;
2208 }
2209
2210 static gboolean
2211 gst_validate_pad_monitor_check_right_buffer (GstValidatePadMonitor *
2212     pad_monitor, GstBuffer * buffer)
2213 {
2214   gchar *checksum;
2215   GstBuffer *wanted_buf;
2216   GstMapInfo map, wanted_map;
2217
2218   gboolean ret = TRUE;
2219   GstPad *pad;
2220
2221
2222   if (_should_check_buffers (pad_monitor, FALSE) == FALSE)
2223     return FALSE;
2224
2225   pad =
2226       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
2227           (pad_monitor)));
2228   if (pad_monitor->current_buf == NULL) {
2229     GST_INFO_OBJECT (pad, "No current buffer one pad, Why?");
2230     gst_object_unref (pad);
2231     return FALSE;
2232   }
2233
2234   wanted_buf = pad_monitor->current_buf->data;
2235
2236   if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_PTS (wanted_buf)) &&
2237       GST_CLOCK_TIME_IS_VALID (GST_BUFFER_PTS (buffer)) &&
2238       GST_BUFFER_PTS (wanted_buf) != GST_BUFFER_PTS (buffer)) {
2239
2240     GST_VALIDATE_REPORT (pad_monitor, WRONG_BUFFER,
2241         "buffer %" GST_PTR_FORMAT " PTS %" GST_TIME_FORMAT
2242         " different than expected: %" GST_TIME_FORMAT, buffer,
2243         GST_TIME_ARGS (GST_BUFFER_PTS (buffer)),
2244         GST_TIME_ARGS (GST_BUFFER_PTS (wanted_buf)));
2245
2246     ret = FALSE;
2247   }
2248
2249   if (GST_BUFFER_DTS (wanted_buf) != GST_BUFFER_DTS (buffer)) {
2250     GST_VALIDATE_REPORT (pad_monitor, WRONG_BUFFER,
2251         "buffer %" GST_PTR_FORMAT " DTS %" GST_TIME_FORMAT
2252         " different than expected: %" GST_TIME_FORMAT, buffer,
2253         GST_TIME_ARGS (GST_BUFFER_DTS (buffer)),
2254         GST_TIME_ARGS (GST_BUFFER_DTS (wanted_buf)));
2255     ret = FALSE;
2256   }
2257
2258   if (GST_BUFFER_DURATION (wanted_buf) != GST_BUFFER_DURATION (buffer)) {
2259     GST_VALIDATE_REPORT (pad_monitor, WRONG_BUFFER,
2260         "buffer %" GST_PTR_FORMAT " DURATION %" GST_TIME_FORMAT
2261         " different than expected: %" GST_TIME_FORMAT, buffer,
2262         GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)),
2263         GST_TIME_ARGS (GST_BUFFER_DURATION (wanted_buf)));
2264     ret = FALSE;
2265   }
2266
2267   if (GST_BUFFER_FLAG_IS_SET (wanted_buf, GST_BUFFER_FLAG_DELTA_UNIT) !=
2268       GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT)) {
2269     GST_VALIDATE_REPORT (pad_monitor, WRONG_BUFFER,
2270         "buffer %" GST_PTR_FORMAT "  Delta unit is set to %s but expected %s",
2271         buffer, GST_BUFFER_FLAG_IS_SET (buffer,
2272             GST_BUFFER_FLAG_DELTA_UNIT) ? "True" : "False",
2273         GST_BUFFER_FLAG_IS_SET (wanted_buf,
2274             GST_BUFFER_FLAG_DELTA_UNIT) ? "True" : "False");
2275     ret = FALSE;
2276   }
2277
2278   g_assert (gst_buffer_map (wanted_buf, &wanted_map, GST_MAP_READ));
2279   g_assert (gst_buffer_map (buffer, &map, GST_MAP_READ));
2280
2281   checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
2282       (const guchar *) map.data, map.size);
2283
2284   if (g_strcmp0 ((gchar *) wanted_map.data, checksum)) {
2285     GST_VALIDATE_REPORT (pad_monitor, WRONG_BUFFER,
2286         "buffer %" GST_PTR_FORMAT " checksum %s different from expected: %s",
2287         buffer, checksum, wanted_map.data);
2288     ret = FALSE;
2289   }
2290
2291   gst_buffer_unmap (wanted_buf, &wanted_map);
2292   gst_buffer_unmap (buffer, &map);
2293   g_free (checksum);
2294   gst_object_unref (pad);
2295
2296   pad_monitor->current_buf = pad_monitor->current_buf->next;
2297
2298   return ret;
2299 }
2300
2301 static void
2302 gst_validate_pad_monitor_check_return (GstValidatePadMonitor * pad_monitor,
2303     GstFlowReturn ret)
2304 {
2305   GstValidateMonitor *parent = GST_VALIDATE_MONITOR (pad_monitor);
2306
2307   if (ret != GST_FLOW_ERROR)
2308     return;
2309
2310   while (GST_VALIDATE_MONITOR_GET_PARENT (parent))
2311     parent = GST_VALIDATE_MONITOR_GET_PARENT (parent);
2312
2313   if (GST_IS_VALIDATE_PIPELINE_MONITOR (parent)) {
2314     GstValidatePipelineMonitor *m = GST_VALIDATE_PIPELINE_MONITOR (parent);
2315
2316     GST_VALIDATE_MONITOR_LOCK (m);
2317     if (m->got_error == FALSE) {
2318       GST_VALIDATE_REPORT (pad_monitor, FLOW_ERROR_WITHOUT_ERROR_MESSAGE,
2319           "Pad return GST_FLOW_ERROR but no GST_MESSAGE_ERROR was received on"
2320           " the bus");
2321
2322       /* Only report it the first time */
2323       m->got_error = TRUE;
2324     }
2325     GST_VALIDATE_MONITOR_UNLOCK (m);
2326   }
2327 }
2328
2329 static GstFlowReturn
2330 gst_validate_pad_monitor_chain_func (GstPad * pad, GstObject * parent,
2331     GstBuffer * buffer)
2332 {
2333   GstValidatePadMonitor *pad_monitor = _GET_PAD_MONITOR (pad);
2334   GstFlowReturn ret;
2335
2336   GST_VALIDATE_PAD_MONITOR_PARENT_LOCK (pad_monitor);
2337   GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2338
2339   gst_validate_pad_monitor_check_discont (pad_monitor, buffer);
2340   gst_validate_pad_monitor_check_right_buffer (pad_monitor, buffer);
2341   gst_validate_pad_monitor_check_first_buffer (pad_monitor, buffer);
2342   gst_validate_pad_monitor_update_buffer_data (pad_monitor, buffer);
2343   gst_validate_pad_monitor_check_eos (pad_monitor, buffer);
2344
2345   GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2346   GST_VALIDATE_PAD_MONITOR_PARENT_UNLOCK (pad_monitor);
2347
2348   gst_validate_pad_monitor_buffer_overrides (pad_monitor, buffer);
2349
2350   ret = pad_monitor->chain_func (pad, parent, buffer);
2351
2352   gst_validate_pad_monitor_check_return (pad_monitor, ret);
2353
2354   GST_VALIDATE_PAD_MONITOR_PARENT_LOCK (pad_monitor);
2355   GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2356
2357   pad_monitor->last_flow_return = ret;
2358   if (ret == GST_FLOW_EOS) {
2359     mark_pads_eos (pad_monitor);
2360   }
2361   if (PAD_PARENT_IS_DEMUXER (pad_monitor))
2362     gst_validate_pad_monitor_check_aggregated_return (pad_monitor, parent, ret);
2363
2364   GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2365   GST_VALIDATE_PAD_MONITOR_PARENT_UNLOCK (pad_monitor);
2366
2367   return ret;
2368 }
2369
2370 static gboolean
2371 gst_validate_pad_monitor_event_is_tracked (GstValidatePadMonitor * monitor,
2372     GstEvent * event)
2373 {
2374   if (!GST_EVENT_IS_SERIALIZED (event)) {
2375     return FALSE;
2376   }
2377
2378   /* we don't track Tag events because they mutate too much and it is hard
2379    * to match a tag event pushed on a source pad with the one that was received
2380    * on a sink pad.
2381    * One idea would be to use seqnum, but it seems that it is undefined whether
2382    * seqnums should be maintained in tag events that are created from others
2383    * up to today. (2013-08-29)
2384    */
2385   if (GST_EVENT_TYPE (event) == GST_EVENT_TAG)
2386     return FALSE;
2387
2388   return TRUE;
2389 }
2390
2391 static GstFlowReturn
2392 gst_validate_pad_monitor_sink_event_full_func (GstPad * pad, GstObject * parent,
2393     GstEvent * event)
2394 {
2395   GstValidatePadMonitor *pad_monitor = _GET_PAD_MONITOR (pad);
2396   GstFlowReturn ret;
2397
2398   GST_VALIDATE_PAD_MONITOR_PARENT_LOCK (pad_monitor);
2399   GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2400
2401   GST_DEBUG_OBJECT (pad, "event %p %s", event, GST_EVENT_TYPE_NAME (event));
2402
2403   if (gst_validate_pad_monitor_event_is_tracked (pad_monitor, event)) {
2404     GstClockTime last_ts = GST_CLOCK_TIME_NONE;
2405     if (GST_CLOCK_TIME_IS_VALID (pad_monitor->current_timestamp)) {
2406       last_ts = pad_monitor->current_timestamp;
2407       if (GST_CLOCK_TIME_IS_VALID (pad_monitor->current_duration)) {
2408         last_ts += pad_monitor->current_duration;
2409       }
2410     }
2411     gst_validate_pad_monitor_otherpad_add_pending_serialized_event (pad_monitor,
2412         event, last_ts);
2413   }
2414
2415   ret =
2416       gst_validate_pad_monitor_downstream_event_check (pad_monitor, parent,
2417       event, pad_monitor->event_func);
2418
2419   GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2420   GST_VALIDATE_PAD_MONITOR_PARENT_UNLOCK (pad_monitor);
2421   return ret;
2422 }
2423
2424 static gboolean
2425 gst_validate_pad_monitor_sink_event_func (GstPad * pad, GstObject * parent,
2426     GstEvent * event)
2427 {
2428   if (gst_validate_pad_monitor_sink_event_full_func (pad, parent,
2429           event) == GST_FLOW_OK)
2430     return TRUE;
2431   return FALSE;
2432 }
2433
2434 static gboolean
2435 gst_validate_pad_monitor_src_event_func (GstPad * pad, GstObject * parent,
2436     GstEvent * event)
2437 {
2438   GstValidatePadMonitor *pad_monitor = _GET_PAD_MONITOR (pad);
2439   gboolean ret;
2440
2441   GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2442   ret = gst_validate_pad_monitor_src_event_check (pad_monitor, parent, event,
2443       pad_monitor->event_func);
2444   GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2445   return ret;
2446 }
2447
2448 static gboolean
2449 gst_validate_pad_monitor_query_func (GstPad * pad, GstObject * parent,
2450     GstQuery * query)
2451 {
2452   GstValidatePadMonitor *pad_monitor = _GET_PAD_MONITOR (pad);
2453   gboolean ret;
2454
2455   gst_validate_pad_monitor_query_overrides (pad_monitor, query);
2456   ret = pad_monitor->query_func (pad, parent, query);
2457
2458   if (ret) {
2459     switch (GST_QUERY_TYPE (query)) {
2460       case GST_QUERY_ACCEPT_CAPS:
2461       {
2462         gboolean result;
2463
2464         gst_caps_replace (&pad_monitor->last_refused_caps, NULL);
2465         gst_query_parse_accept_caps_result (query, &result);
2466         if (!result) {
2467           GstCaps *refused_caps;
2468
2469           gst_query_parse_accept_caps (query, &refused_caps);
2470           pad_monitor->last_refused_caps = gst_caps_copy (refused_caps);
2471
2472         }
2473
2474         break;
2475       }
2476       case GST_QUERY_CAPS:{
2477         GstCaps *res;
2478         GstCaps *filter;
2479
2480         /* We shouldn't need to lock the parent as this doesn't modify
2481          * other monitors, just does some peer_pad_caps */
2482         GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2483
2484         gst_query_parse_caps (query, &filter);
2485         gst_query_parse_caps_result (query, &res);
2486
2487         gst_caps_replace (&pad_monitor->last_query_res, NULL);
2488         gst_caps_replace (&pad_monitor->last_query_filter, NULL);
2489         pad_monitor->last_query_res =
2490             res ? gst_caps_copy (res) : gst_caps_ref (GST_CAPS_NONE);
2491         pad_monitor->last_query_filter =
2492             filter ? gst_caps_copy (filter) : gst_caps_ref (GST_CAPS_NONE);
2493
2494         if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK) {
2495           gst_validate_pad_monitor_check_caps_fields_proxied (pad_monitor, res,
2496               filter);
2497         }
2498         GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2499         break;
2500       }
2501       default:
2502         break;
2503     }
2504   }
2505
2506   return ret;
2507 }
2508
2509 static gboolean
2510 gst_validate_pad_monitor_activatemode_func (GstPad * pad, GstObject * parent,
2511     GstPadMode mode, gboolean active)
2512 {
2513   GstValidatePadMonitor *pad_monitor = _GET_PAD_MONITOR (pad);
2514   gboolean ret = TRUE;
2515
2516   /* TODO add overrides for activate func */
2517   GST_DEBUG_OBJECT (pad, "active:%d", active);
2518
2519   if (pad_monitor->activatemode_func)
2520     ret = pad_monitor->activatemode_func (pad, parent, mode, active);
2521   if (ret && active == FALSE) {
2522     GST_VALIDATE_MONITOR_LOCK (pad_monitor);
2523     gst_validate_pad_monitor_reset (pad_monitor);
2524     GST_VALIDATE_MONITOR_UNLOCK (pad_monitor);
2525   }
2526
2527   return ret;
2528 }
2529
2530 static GstFlowReturn
2531 gst_validate_pad_monitor_get_range_func (GstPad * pad, GstObject * parent,
2532     guint64 offset, guint length, GstBuffer ** buffer)
2533 {
2534   GstValidatePadMonitor *pad_monitor = _GET_PAD_MONITOR (pad);
2535
2536   if (pad_monitor->get_range_func) {
2537     GstPad *peer = gst_pad_get_peer (pad);
2538     GstTask *task = NULL;
2539     GThread *thread = NULL;
2540
2541     if (peer) {
2542       GST_OBJECT_LOCK (peer);
2543       task = GST_PAD_TASK (peer);
2544       if (task && GST_TASK_STATE (task) == GST_TASK_STARTED) {
2545         GST_OBJECT_LOCK (task);
2546         /* Only doing pointer comparison, no need to hold a ref */
2547         thread = task->thread;
2548         GST_OBJECT_UNLOCK (task);
2549       }
2550       GST_OBJECT_UNLOCK (peer);
2551
2552       if (thread && thread != g_thread_self ()) {
2553         GST_VALIDATE_REPORT (pad_monitor, PULL_RANGE_FROM_WRONG_THREAD,
2554             "Pulling from wrong thread, expected pad thread: %p, got %p",
2555             task->thread, g_thread_self ());
2556       }
2557
2558       gst_object_unref (peer);
2559     }
2560
2561     return pad_monitor->get_range_func (pad, parent, offset, length, buffer);
2562   }
2563
2564   return GST_FLOW_NOT_SUPPORTED;
2565
2566 }
2567
2568 /* The interval between two buffer frequency checks */
2569 #define BUF_FREQ_CHECK_INTERVAL (GST_SECOND)
2570
2571 static void
2572 gst_validate_pad_monitor_check_buffer_freq (GstValidatePadMonitor * monitor,
2573     GstPad * pad)
2574 {
2575   GstClockTime ts;
2576
2577   if (!GST_PAD_IS_SRC (pad))
2578     return;
2579
2580   if (!monitor->min_buf_freq)
2581     return;
2582
2583   ts = gst_util_get_timestamp ();
2584   monitor->buffers_pushed++;
2585
2586   /* Same logic as in fpsdisplaysink to compute the buffer frequency */
2587   if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID
2588           (monitor->min_buf_freq_first_buffer_ts))) {
2589     monitor->min_buf_freq_first_buffer_ts = ts;
2590     monitor->min_buf_freq_interval_ts = ts;
2591     return;
2592   }
2593
2594   if (GST_CLOCK_DIFF (monitor->min_buf_freq_interval_ts,
2595           ts) > BUF_FREQ_CHECK_INTERVAL) {
2596     guint time_diff;
2597     gdouble fps;
2598
2599     time_diff = (gdouble) (ts - monitor->min_buf_freq_interval_ts) / GST_SECOND;
2600     fps =
2601         (gdouble) (monitor->buffers_pushed -
2602         monitor->last_buffers_pushed) / time_diff;
2603
2604     if (fps < monitor->min_buf_freq) {
2605       if (GST_CLOCK_TIME_IS_VALID (monitor->min_buf_freq_start) &&
2606           GST_CLOCK_DIFF (monitor->min_buf_freq_first_buffer_ts,
2607               ts) < monitor->min_buf_freq_start) {
2608         GST_DEBUG_OBJECT (pad,
2609             "buffer frequency is too low (%.2f) but ignore for now (buffer-frequency-start =%"
2610             GST_TIME_FORMAT ")", fps,
2611             GST_TIME_ARGS (monitor->min_buf_freq_start));
2612       } else {
2613         GST_VALIDATE_REPORT (monitor, CONFIG_BUFFER_FREQUENCY_TOO_LOW,
2614             "Buffers are not pushed fast enough on this pad: %.2f/sec (minimum: %.2f)",
2615             fps, monitor->min_buf_freq);
2616       }
2617     }
2618
2619     monitor->last_buffers_pushed = monitor->buffers_pushed;
2620     monitor->min_buf_freq_interval_ts = ts;
2621   }
2622 }
2623
2624 static gboolean
2625 gst_validate_pad_monitor_buffer_probe (GstPad * pad, GstBuffer * buffer,
2626     gpointer udata, gboolean pull_mode)
2627 {
2628   GstValidatePadMonitor *monitor = udata;
2629
2630   GST_VALIDATE_PAD_MONITOR_PARENT_LOCK (monitor);
2631   GST_VALIDATE_MONITOR_LOCK (monitor);
2632
2633   if (!pull_mode)
2634     gst_validate_pad_monitor_check_discont (monitor, buffer);
2635   gst_validate_pad_monitor_check_first_buffer (monitor, buffer);
2636   gst_validate_pad_monitor_update_buffer_data (monitor, buffer);
2637   gst_validate_pad_monitor_check_eos (monitor, buffer);
2638
2639   if (PAD_PARENT_IS_DECODER (monitor) || PAD_PARENT_IS_ENCODER (monitor)) {
2640     GstClockTime tolerance = 0;
2641
2642     if (monitor->caps_is_audio)
2643       tolerance = AUDIO_TIMESTAMP_TOLERANCE;
2644
2645     gst_validate_pad_monitor_check_buffer_timestamp_in_received_range (monitor,
2646         buffer, tolerance);
2647   }
2648
2649   gst_validate_pad_monitor_check_late_serialized_events (monitor,
2650       GST_BUFFER_TIMESTAMP (buffer));
2651
2652   /* a GstValidatePadMonitor parent must be a GstValidateElementMonitor */
2653   if (PAD_PARENT_IS_DECODER (monitor)) {
2654
2655     /* should not push out of segment data */
2656     if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buffer)) &&
2657         GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DURATION (buffer)) &&
2658         ((!gst_segment_clip (&monitor->segment, monitor->segment.format,
2659                     GST_BUFFER_TIMESTAMP (buffer),
2660                     GST_BUFFER_TIMESTAMP (buffer) +
2661                     GST_BUFFER_DURATION (buffer), NULL, NULL)) ||
2662             /* In the case of raw data, buffers should be strictly contained inside the
2663              * segment */
2664             (monitor->caps_is_raw &&
2665                 GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer) <
2666                 monitor->segment.start))
2667         ) {
2668       /* TODO is this a timestamp issue? */
2669       GST_VALIDATE_REPORT (monitor, BUFFER_IS_OUT_OF_SEGMENT,
2670           "buffer is out of segment and shouldn't be pushed. Timestamp: %"
2671           GST_TIME_FORMAT " - Duration: %" GST_TIME_FORMAT ". Range: %"
2672           GST_TIME_FORMAT " - %" GST_TIME_FORMAT,
2673           GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
2674           GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)),
2675           GST_TIME_ARGS (monitor->segment.start),
2676           GST_TIME_ARGS (monitor->segment.stop));
2677     }
2678   }
2679
2680   gst_validate_pad_monitor_check_buffer_freq (monitor, pad);
2681
2682   GST_VALIDATE_MONITOR_UNLOCK (monitor);
2683   GST_VALIDATE_PAD_MONITOR_PARENT_UNLOCK (monitor);
2684   gst_validate_pad_monitor_buffer_probe_overrides (monitor, buffer);
2685   return TRUE;
2686 }
2687
2688 static void
2689 gst_validate_pad_monitor_event_probe (GstPad * pad, GstEvent * event,
2690     gpointer udata)
2691 {
2692   GstValidatePadMonitor *monitor = GST_VALIDATE_PAD_MONITOR_CAST (udata);
2693   guint32 seqnum = gst_event_get_seqnum (event);
2694
2695   GST_VALIDATE_PAD_MONITOR_PARENT_LOCK (monitor);
2696   GST_VALIDATE_MONITOR_LOCK (monitor);
2697
2698   GST_DEBUG_OBJECT (pad, "event %p %s seqnum:%" G_GUINT32_FORMAT, event,
2699       GST_EVENT_TYPE_NAME (event), seqnum);
2700
2701   if (GST_EVENT_IS_SERIALIZED (event)) {
2702     gint i;
2703
2704     /* Detect if events the element received are being forwarded in the same order
2705      *
2706      * Several scenarios:
2707      * 1) The element pushes the event as-is
2708      * 2) The element consumes the event and does not forward it
2709      * 3) The element consumes the event and creates another one instead
2710      * 4) The element pushes other serialized event before pushing out the
2711      *    one it received
2712      *
2713      * For each pad we have two lists to track serialized events:
2714      *  1) We received on input and expect to see (serialized_events)
2715      *  2) We received on input but don't expect to see (expired_events)
2716      *
2717      * To detect events that are pushed in a different order from the one they were
2718      * received in we check that:
2719      *
2720      * For each event being outputted:
2721      *   If it is in the expired_events list:
2722      *     RAISE WARNING
2723      *   If it is in the serialized_events list:
2724      *     If there are other events that were received before:
2725      *        Put those events on the expired_events list
2726      *     Remove that event and any previous ones from the serialized_events list
2727      *
2728      * Clear expired events list when flushing or on pad deactivation
2729      *
2730      */
2731
2732     if (g_list_find (monitor->expired_events, event)) {
2733       gchar *event_str = _get_event_string (event);
2734       /* If it's the expired events, we've failed */
2735       GST_WARNING_OBJECT (pad, "Did not expect event %p %s", event,
2736           GST_EVENT_TYPE_NAME (event));
2737       GST_VALIDATE_REPORT (monitor, EVENT_SERIALIZED_OUT_OF_ORDER,
2738           "Serialized event was pushed out of order: %s", event_str);
2739
2740       g_free (event_str);
2741       monitor->expired_events = g_list_remove (monitor->expired_events, event);
2742       gst_event_unref (event);  /* remove the ref that was on the list */
2743     } else if (monitor->serialized_events->len) {
2744       for (i = 0; i < monitor->serialized_events->len; i++) {
2745         SerializedEventData *next_event =
2746             g_ptr_array_index (monitor->serialized_events, i);
2747         GST_DEBUG_OBJECT (pad, "Checking against stored event #%d: %p %s", i,
2748             next_event->event, GST_EVENT_TYPE_NAME (next_event->event));
2749
2750         if (event == next_event->event
2751             || GST_EVENT_TYPE (event) == GST_EVENT_TYPE (next_event->event)) {
2752           /* We have found our event */
2753           GST_DEBUG_OBJECT (pad, "Found matching event");
2754
2755           while (monitor->serialized_events->len > i
2756               && GST_EVENT_TYPE (event) == GST_EVENT_TYPE (next_event->event)) {
2757             /* Swallow all expected events of the same type */
2758             g_ptr_array_remove_index (monitor->serialized_events, i);
2759             next_event = g_ptr_array_index (monitor->serialized_events, i);
2760           }
2761
2762           /* Move all previous events to expired events */
2763           if (G_UNLIKELY (i > 0)) {
2764             GST_DEBUG_OBJECT (pad,
2765                 "Moving previous expected events to expired list");
2766             while (i--) {
2767               next_event = g_ptr_array_index (monitor->serialized_events, 0);
2768               monitor->expired_events =
2769                   g_list_append (monitor->expired_events,
2770                   gst_event_ref (next_event->event));
2771               g_ptr_array_remove_index (monitor->serialized_events, 0);
2772             }
2773           }
2774           debug_pending_event (pad, monitor->serialized_events);
2775           break;
2776         }
2777       }
2778     }
2779   }
2780
2781   /* This so far is just like an event that is flowing downstream,
2782    * so we do the same checks as a sinkpad event handler */
2783   gst_validate_pad_monitor_downstream_event_check (monitor, NULL, event, NULL);
2784   GST_VALIDATE_MONITOR_UNLOCK (monitor);
2785   GST_VALIDATE_PAD_MONITOR_PARENT_UNLOCK (monitor);
2786 }
2787
2788 static GstPadProbeReturn
2789 gst_validate_pad_monitor_pad_probe (GstPad * pad, GstPadProbeInfo * info,
2790     gpointer udata)
2791 {
2792   if (info->type & GST_PAD_PROBE_TYPE_BUFFER)
2793     gst_validate_pad_monitor_buffer_probe (pad, info->data, udata,
2794         GST_PAD_PROBE_INFO_TYPE (info) & GST_PAD_PROBE_TYPE_PULL);
2795   else if (info->type & GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM)
2796     gst_validate_pad_monitor_event_probe (pad, info->data, udata);
2797
2798   return GST_PAD_PROBE_OK;
2799 }
2800
2801 static void
2802 gst_validate_pad_monitor_update_caps_info (GstValidatePadMonitor * pad_monitor,
2803     GstCaps * caps)
2804 {
2805   GstStructure *structure;
2806
2807   g_return_if_fail (gst_caps_is_fixed (caps));
2808
2809   pad_monitor->caps_is_audio = FALSE;
2810   pad_monitor->caps_is_video = FALSE;
2811
2812   structure = gst_caps_get_structure (caps, 0);
2813   if (g_str_has_prefix (gst_structure_get_name (structure), "audio/")) {
2814     pad_monitor->caps_is_audio = TRUE;
2815   } else if (g_str_has_prefix (gst_structure_get_name (structure), "video/")) {
2816     pad_monitor->caps_is_video = TRUE;
2817   }
2818
2819   if (g_str_has_prefix (gst_structure_get_name (structure), "audio/x-raw") ||
2820       g_str_has_prefix (gst_structure_get_name (structure), "video/x-raw")) {
2821     pad_monitor->caps_is_raw = TRUE;
2822   } else {
2823     pad_monitor->caps_is_raw = FALSE;
2824   }
2825 }
2826
2827 static void
2828 gst_validate_pad_monitor_setcaps_pre (GstValidatePadMonitor * pad_monitor,
2829     GstCaps * caps)
2830 {
2831   GstStructure *structure;
2832   GstPad *pad =
2833       GST_PAD (gst_validate_monitor_get_target (GST_VALIDATE_MONITOR
2834           (pad_monitor)));
2835
2836   /* Check if caps are identical to last caps and complain if so
2837    * Only checked for sink pads as src pads might push the same caps
2838    * multiple times during unlinked/autoplugging scenarios */
2839   if (GST_PAD_IS_SINK (pad) && pad_monitor->last_caps
2840       && gst_caps_is_equal (caps, pad_monitor->last_caps)) {
2841     gchar *caps_str = gst_caps_to_string (caps);
2842
2843     GST_VALIDATE_REPORT (pad_monitor, EVENT_CAPS_DUPLICATE, "%s", caps_str);
2844     g_free (caps_str);
2845
2846   }
2847
2848   gst_validate_pad_monitor_check_caps_complete (pad_monitor, caps);
2849
2850   if (caps) {
2851     structure = gst_caps_get_structure (caps, 0);
2852     if (gst_structure_n_fields (pad_monitor->pending_setcaps_fields)) {
2853       gint i;
2854       for (i = 0;
2855           i < gst_structure_n_fields (pad_monitor->pending_setcaps_fields);
2856           i++) {
2857         const gchar *name =
2858             gst_structure_nth_field_name (pad_monitor->pending_setcaps_fields,
2859             i);
2860         const GValue *v = gst_structure_get_value (structure, name);
2861         const GValue *otherv =
2862             gst_structure_get_value (pad_monitor->pending_setcaps_fields, name);
2863
2864         if (v == NULL) {
2865           gchar *caps_str = gst_caps_to_string (caps);
2866
2867           GST_VALIDATE_REPORT (pad_monitor, CAPS_EXPECTED_FIELD_NOT_FOUND,
2868               "Field %s is missing from setcaps caps '%s'", name, caps_str);
2869           g_free (caps_str);
2870         } else if (gst_value_compare (v, otherv) != GST_VALUE_EQUAL) {
2871           gchar *caps_str = gst_caps_to_string (caps),
2872               *pending_setcaps_fields_str =
2873               gst_structure_to_string (pad_monitor->pending_setcaps_fields);
2874
2875
2876           GST_VALIDATE_REPORT (pad_monitor, CAPS_FIELD_UNEXPECTED_VALUE,
2877               "Field %s from setcaps caps '%s' is different "
2878               "from expected value in caps '%s'", name, caps_str,
2879               pending_setcaps_fields_str);
2880
2881           g_free (pending_setcaps_fields_str);
2882           g_free (caps_str);
2883         }
2884       }
2885     }
2886
2887     if (GST_PAD_IS_SINK (pad) &&
2888         gst_validate_pad_monitor_pad_should_proxy_othercaps (pad_monitor)) {
2889       if (_structure_is_video (structure)) {
2890         GST_DEBUG_OBJECT (pad,
2891             "Adding video common pending fields to other pad: %" GST_PTR_FORMAT,
2892             structure);
2893         gst_validate_pad_monitor_otherpad_add_pending_field (pad_monitor,
2894             structure, "width");
2895         gst_validate_pad_monitor_otherpad_add_pending_field (pad_monitor,
2896             structure, "height");
2897         gst_validate_pad_monitor_otherpad_add_pending_field (pad_monitor,
2898             structure, "framerate");
2899         gst_validate_pad_monitor_otherpad_add_pending_field (pad_monitor,
2900             structure, "pixel-aspect-ratio");
2901       } else if (_structure_is_audio (structure)) {
2902         GST_DEBUG_OBJECT (pad,
2903             "Adding audio common pending fields to other pad: %" GST_PTR_FORMAT,
2904             structure);
2905         gst_validate_pad_monitor_otherpad_add_pending_field (pad_monitor,
2906             structure, "rate");
2907         gst_validate_pad_monitor_otherpad_add_pending_field (pad_monitor,
2908             structure, "channels");
2909       }
2910     }
2911   }
2912
2913   gst_structure_free (pad_monitor->pending_setcaps_fields);
2914   pad_monitor->pending_setcaps_fields =
2915       gst_structure_new_empty (PENDING_FIELDS);
2916   gst_object_unref (pad);
2917
2918   gst_validate_pad_monitor_setcaps_overrides (pad_monitor, caps);
2919 }
2920
2921 static void
2922 gst_validate_pad_monitor_setcaps_post (GstValidatePadMonitor * pad_monitor,
2923     GstCaps * caps, gboolean ret)
2924 {
2925   if (!ret)
2926     gst_validate_pad_monitor_otherpad_clear_pending_fields (pad_monitor);
2927   else {
2928     if (pad_monitor->last_caps) {
2929       gst_caps_unref (pad_monitor->last_caps);
2930     }
2931     pad_monitor->last_caps = gst_caps_ref (caps);
2932     gst_validate_pad_monitor_update_caps_info (pad_monitor, caps);
2933   }
2934 }
2935
2936 static void
2937 gst_validate_pad_monitor_get_min_buffer_frequency (GstValidatePadMonitor *
2938     monitor, GstPad * pad)
2939 {
2940   GList *config, *l;
2941
2942   if (!GST_PAD_IS_SRC (pad))
2943     return;
2944
2945   config = gst_validate_plugin_get_config (NULL);
2946   for (l = config; l != NULL; l = g_list_next (l)) {
2947     GstStructure *s = l->data;
2948     gdouble min_buf_freq;
2949     const gchar *pad_name;
2950     GstElement *element = NULL;
2951
2952     if (!gst_structure_get_double (s, "min-buffer-frequency", &min_buf_freq)) {
2953       gint max_int;
2954
2955       if (!gst_structure_get_int (s, "min-buffer-frequency", &max_int))
2956         goto next;
2957
2958       min_buf_freq = max_int;
2959     }
2960
2961     pad_name = gst_structure_get_string (s, "name");
2962     if (!pad_name)
2963       pad_name = "src";
2964
2965     if (g_strcmp0 (GST_PAD_NAME (pad), pad_name))
2966       goto next;
2967
2968     element = gst_pad_get_parent_element (pad);
2969
2970     if (!gst_validate_element_matches_target (element, s))
2971       goto next;
2972
2973     monitor->min_buf_freq = min_buf_freq;
2974
2975     gst_validate_utils_get_clocktime (s, "buffer-frequency-start",
2976         &monitor->min_buf_freq_start);
2977
2978     GST_DEBUG_OBJECT (pad, "pad has a minimum buffer frequency of %f",
2979         min_buf_freq);
2980   next:
2981     g_clear_object (&element);
2982   }
2983 }
2984
2985 static gboolean
2986 gst_validate_pad_monitor_do_setup (GstValidateMonitor * monitor)
2987 {
2988   GstValidatePadMonitor *pad_monitor = GST_VALIDATE_PAD_MONITOR_CAST (monitor);
2989   GstPad *pad = (gpointer) gst_validate_monitor_get_target (monitor);
2990
2991   if (!GST_IS_PAD (pad)) {
2992     GST_WARNING_OBJECT (monitor, "Trying to create pad monitor with other "
2993         "type of object");
2994     gst_object_unref (pad);
2995     return FALSE;
2996   }
2997
2998   if (_GET_PAD_MONITOR (pad)) {
2999     GST_WARNING_OBJECT (pad_monitor,
3000         "Pad already has a validate-monitor associated");
3001     gst_object_unref (pad);
3002     return FALSE;
3003   }
3004
3005   _SET_PAD_MONITOR (pad, pad_monitor);
3006
3007   pad_monitor->event_func = GST_PAD_EVENTFUNC (pad);
3008   pad_monitor->event_full_func = GST_PAD_EVENTFULLFUNC (pad);
3009   pad_monitor->query_func = GST_PAD_QUERYFUNC (pad);
3010   pad_monitor->activatemode_func = GST_PAD_ACTIVATEMODEFUNC (pad);
3011   pad_monitor->get_range_func = GST_PAD_GETRANGEFUNC (pad);
3012   if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK) {
3013
3014     pad_monitor->chain_func = GST_PAD_CHAINFUNC (pad);
3015     if (pad_monitor->chain_func)
3016       gst_pad_set_chain_function (pad, gst_validate_pad_monitor_chain_func);
3017
3018     if (pad_monitor->event_full_func)
3019       gst_pad_set_event_full_function (pad,
3020           gst_validate_pad_monitor_sink_event_full_func);
3021     else
3022       gst_pad_set_event_function (pad,
3023           gst_validate_pad_monitor_sink_event_func);
3024   } else {
3025     gst_pad_set_event_function (pad, gst_validate_pad_monitor_src_event_func);
3026
3027     /* add buffer/event probes */
3028     pad_monitor->pad_probe_id =
3029         gst_pad_add_probe (pad,
3030         GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM |
3031         GST_PAD_PROBE_TYPE_EVENT_FLUSH,
3032         (GstPadProbeCallback) gst_validate_pad_monitor_pad_probe, pad_monitor,
3033         NULL);
3034   }
3035   gst_pad_set_query_function (pad, gst_validate_pad_monitor_query_func);
3036   gst_pad_set_activatemode_function (pad,
3037       gst_validate_pad_monitor_activatemode_func);
3038
3039   if (GST_PAD_IS_SRC (pad)) {
3040     gst_pad_set_getrange_function (pad,
3041         gst_validate_pad_monitor_get_range_func);
3042   }
3043
3044   gst_validate_reporter_set_name (GST_VALIDATE_REPORTER (monitor),
3045       g_strdup_printf ("%s:%s", GST_DEBUG_PAD_NAME (pad)));
3046
3047   if (G_UNLIKELY (GST_PAD_PARENT (pad) == NULL))
3048     GST_FIXME ("Saw a pad not belonging to any object");
3049
3050   gst_validate_pad_monitor_get_min_buffer_frequency (pad_monitor, pad);
3051
3052   gst_object_unref (pad);
3053   return TRUE;
3054 }