pad: rework pad blocking, first part

[platform/upstream/gstreamer.git] / tests / check / gst / gstpad.c

diff --git a/tests/check/gst/gstpad.c b/tests/check/gst/gstpad.c
index e07c18e..53ab81f 100644 (file)
--- a/tests/check/gst/gstpad.c
+++ b/tests/check/gst/gstpad.c
@@ -89,8 +89,9 @@ GST_START_TEST (test_link_unlink_threaded)
 
   caps = gst_caps_from_string ("foo/bar");
   gst_pad_set_caps (src, caps);
+  gst_pad_set_active (sink, TRUE);
   gst_pad_set_caps (sink, caps);
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
 
   MAIN_START_THREADS (5, thread_link_unlink, NULL);
   for (i = 0; i < 1000; ++i) {
@@ -100,10 +101,10 @@ GST_START_TEST (test_link_unlink_threaded)
   }
   MAIN_STOP_THREADS ();
 
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
   gst_caps_unref (caps);
 
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
   gst_object_unref (src);
   gst_object_unref (sink);
 }
@@ -126,13 +127,28 @@ GST_START_TEST (test_refcount)
   /* one for me */
   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
 
-  gst_pad_set_caps (src, caps);
-  gst_pad_set_caps (sink, caps);
-  /* one for me and one for each set_caps */
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  /* can't set caps on flushing pads */
+  fail_if (gst_pad_set_caps (src, caps) == TRUE);
+  fail_if (gst_pad_set_caps (sink, caps) == TRUE);
+
+  /* one for me and one for the pending caps on the sinkpad */
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+
+  gst_pad_set_active (sink, TRUE);
+  fail_unless (gst_pad_set_caps (sink, caps) == TRUE);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+
+  /* can't link with incompatible caps */
+  plr = gst_pad_link (src, sink);
+  fail_if (GST_PAD_LINK_SUCCESSFUL (plr));
+
+  gst_pad_set_active (src, TRUE);
+  fail_unless (gst_pad_set_caps (src, caps) == TRUE);
 
   plr = gst_pad_link (src, sink);
   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
+
+  /* src caps added to pending caps on sink */
   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
 
   gst_pad_unlink (src, sink);
@@ -169,8 +185,16 @@ GST_START_TEST (test_get_allowed_caps)
   caps = gst_caps_from_string ("foo/bar");
 
   sink = gst_pad_new ("sink", GST_PAD_SINK);
-  gst_pad_set_caps (src, caps);
-  gst_pad_set_caps (sink, caps);
+  fail_if (gst_pad_set_caps (src, caps) == TRUE);
+  fail_if (gst_pad_set_caps (sink, caps) == TRUE);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+
+  gst_pad_set_active (sink, TRUE);
+  fail_unless (gst_pad_set_caps (sink, caps) == TRUE);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+
+  gst_pad_set_active (src, TRUE);
+  fail_unless (gst_pad_set_caps (src, caps) == TRUE);
   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
 
   plr = gst_pad_link (src, sink);
@@ -178,6 +202,8 @@ GST_START_TEST (test_get_allowed_caps)
 
   gotcaps = gst_pad_get_allowed_caps (src);
   fail_if (gotcaps == NULL);
+  /* FIXME, does not work, caps events are different so the sinkpad loses caps
+   * when linking */
   fail_unless (gst_caps_is_equal (gotcaps, caps));
 
   ASSERT_CAPS_REFCOUNT (gotcaps, "gotcaps", 1);
@@ -259,7 +285,16 @@ GST_START_TEST (test_push_unlinked)
   caps = gst_caps_from_string ("foo/bar");
 
   gst_pad_set_caps (src, caps);
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
+
+  /* pushing on an inactive pad will drop the buffer */
+  buffer = gst_buffer_new ();
+  gst_buffer_ref (buffer);
+  fail_unless (gst_pad_push (src, buffer) == GST_FLOW_WRONG_STATE);
+  ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
+  gst_buffer_unref (buffer);
+
+  gst_pad_set_active (src, TRUE);
 
   /* pushing on an unlinked pad will drop the buffer */
   buffer = gst_buffer_new ();
@@ -292,7 +327,7 @@ GST_START_TEST (test_push_unlinked)
 
 
   /* cleanup */
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
   ASSERT_OBJECT_REFCOUNT (src, "src", 1);
 
   gst_object_unref (src);
@@ -319,6 +354,13 @@ GST_START_TEST (test_push_linked)
   src = gst_pad_new ("src", GST_PAD_SRC);
   fail_if (src == NULL);
 
+  buffer = gst_buffer_new ();
+  /* new pad should be flushing */
+  gst_buffer_ref (buffer);
+  fail_unless (gst_pad_push (src, buffer) == GST_FLOW_WRONG_STATE);
+  gst_buffer_ref (buffer);
+  fail_unless (gst_pad_chain (sink, buffer) == GST_FLOW_WRONG_STATE);
+
   caps = gst_caps_from_string ("foo/bar");
   /* one for me */
   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
@@ -326,25 +368,25 @@ GST_START_TEST (test_push_linked)
   gst_pad_set_caps (src, caps);
   gst_pad_set_caps (sink, caps);
   /* one for me and one for each set_caps */
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
 
   plr = gst_pad_link (src, sink);
-  fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
-
-  buffer = gst_buffer_new ();
-#if 0
-  /* FIXME, new pad should be flushing */
-  gst_buffer_ref (buffer);
-  fail_unless (gst_pad_push (src, buffer) == GST_FLOW_WRONG_STATE);
-  gst_buffer_ref (buffer);
-  fail_unless (gst_pad_chain (sink, buffer) == GST_FLOW_WRONG_STATE);
-#endif
+  fail_if (GST_PAD_LINK_SUCCESSFUL (plr));
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
 
   /* activate pads */
   gst_pad_set_active (src, TRUE);
   gst_pad_set_active (sink, TRUE);
 
+  gst_pad_set_caps (src, caps);
+  gst_pad_set_caps (sink, caps);
+  /* one for me and one for each set_caps */
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+
+  plr = gst_pad_link (src, sink);
+  fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+
   /* test */
   /* pushing on a linked pad will drop the ref to the buffer */
   gst_buffer_ref (buffer);
@@ -389,7 +431,7 @@ GST_START_TEST (test_push_linked)
 
   /* teardown */
   gst_pad_unlink (src, sink);
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
   gst_object_unref (src);
   gst_object_unref (sink);
   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
@@ -404,22 +446,38 @@ buffer_from_string (const gchar * str)
 {
   guint size;
   GstBuffer *buf;
+  gpointer data;
 
   size = strlen (str);
   buf = gst_buffer_new_and_alloc (size);
-  memcpy (GST_BUFFER_DATA (buf), str, size);
-  GST_BUFFER_SIZE (buf) = size;
+
+  data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
+  memcpy (data, str, size);
+  gst_buffer_unmap (buf, data, size);
 
   return buf;
 }
 
+static gboolean
+buffer_compare (GstBuffer * buf, const gchar * str, gsize size)
+{
+  gboolean res;
+  gpointer data;
+
+  data = gst_buffer_map (buf, NULL, NULL, GST_MAP_READ);
+  res = memcmp (data, str, size) == 0;
+  GST_DEBUG ("%s <-> %s: %d", (gchar *) data, str, res);
+  gst_buffer_unmap (buf, data, size);
+
+  return res;
+}
+
 GST_START_TEST (test_push_buffer_list_compat)
 {
   GstPad *src, *sink;
   GstPadLinkReturn plr;
   GstCaps *caps;
   GstBufferList *list;
-  GstBufferListIterator *it;
   GstBuffer *buffer;
 
   /* setup */
@@ -433,7 +491,9 @@ GST_START_TEST (test_push_buffer_list_compat)
 
   caps = gst_caps_from_string ("foo/bar");
 
+  gst_pad_set_active (src, TRUE);
   gst_pad_set_caps (src, caps);
+  gst_pad_set_active (sink, TRUE);
   gst_pad_set_caps (sink, caps);
 
   plr = gst_pad_link (src, sink);
@@ -447,25 +507,19 @@ GST_START_TEST (test_push_buffer_list_compat)
 
   /* test */
   /* adding to a buffer list will drop the ref to the buffer */
-  it = gst_buffer_list_iterate (list);
-  gst_buffer_list_iterator_add_group (it);
-  gst_buffer_list_iterator_add (it, buffer_from_string ("List"));
-  gst_buffer_list_iterator_add (it, buffer_from_string ("Group"));
-  gst_buffer_list_iterator_add_group (it);
-  gst_buffer_list_iterator_add (it, buffer_from_string ("Another"));
-  gst_buffer_list_iterator_add (it, buffer_from_string ("List"));
-  gst_buffer_list_iterator_add (it, buffer_from_string ("Group"));
-  gst_buffer_list_iterator_free (it);
+  gst_buffer_list_add (list, buffer_from_string ("ListGroup"));
+  gst_buffer_list_add (list, buffer_from_string ("AnotherListGroup"));
+
   fail_unless (gst_pad_push_list (src, list) == GST_FLOW_OK);
   fail_unless_equals_int (g_list_length (buffers), 2);
   buffer = GST_BUFFER (buffers->data);
   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
-  fail_unless (memcmp (GST_BUFFER_DATA (buffer), "ListGroup", 9) == 0);
+  fail_unless (buffer_compare (buffer, "ListGroup", 9));
   gst_buffer_unref (buffer);
   buffers = g_list_delete_link (buffers, buffers);
   buffer = GST_BUFFER (buffers->data);
   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
-  fail_unless (memcmp (GST_BUFFER_DATA (buffer), "AnotherListGroup", 16) == 0);
+  fail_unless (buffer_compare (buffer, "AnotherListGroup", 16));
   gst_buffer_unref (buffer);
   buffers = g_list_delete_link (buffers, buffers);
   fail_unless (buffers == NULL);
@@ -545,6 +599,8 @@ GST_START_TEST (test_push_negotiation)
       GST_PAD_ALWAYS, srccaps);
   sink_template = gst_pad_template_new ("sink", GST_PAD_SINK,
       GST_PAD_ALWAYS, sinkcaps);
+  gst_caps_unref (srccaps);
+  gst_caps_unref (sinkcaps);
 
   sink = gst_pad_new_from_template (sink_template, "sink");
   fail_if (sink == NULL);
@@ -566,11 +622,7 @@ GST_START_TEST (test_push_negotiation)
 
   /* Should fail if src pad caps are incompatible with sink pad caps */
   gst_pad_set_caps (src, caps);
-  gst_buffer_set_caps (buffer, caps);
-  gst_buffer_ref (buffer);
-  fail_unless (gst_pad_push (src, buffer) == GST_FLOW_NOT_NEGOTIATED);
-  ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
-  gst_buffer_unref (buffer);
+  fail_unless (gst_pad_set_caps (sink, caps) == FALSE);
 
   /* teardown */
   gst_pad_unlink (src, sink);
@@ -598,7 +650,9 @@ GST_START_TEST (test_src_unref_unlink)
 
   caps = gst_caps_from_string ("foo/bar");
 
+  gst_pad_set_active (src, TRUE);
   gst_pad_set_caps (src, caps);
+  gst_pad_set_active (sink, TRUE);
   gst_pad_set_caps (sink, caps);
 
   plr = gst_pad_link (src, sink);
@@ -632,7 +686,9 @@ GST_START_TEST (test_sink_unref_unlink)
 
   caps = gst_caps_from_string ("foo/bar");
 
+  gst_pad_set_active (src, TRUE);
   gst_pad_set_caps (src, caps);
+  gst_pad_set_active (sink, TRUE);
   gst_pad_set_caps (sink, caps);
 
   plr = gst_pad_link (src, sink);
@@ -674,7 +730,7 @@ block_async_cb (GstPad * pad, gboolean blocked, gpointer user_data)
 
   bool_user_data[0] = blocked;
 
-  gst_pad_set_blocked_async (pad, FALSE, unblock_async_cb, user_data);
+  gst_pad_set_blocked (pad, FALSE, unblock_async_cb, user_data, NULL);
 }
 
 GST_START_TEST (test_block_async)
@@ -688,10 +744,10 @@ GST_START_TEST (test_block_async)
   fail_unless (pad != NULL);
 
   gst_pad_set_active (pad, TRUE);
-  gst_pad_set_blocked_async (pad, TRUE, block_async_cb, &data);
+  gst_pad_set_blocked (pad, TRUE, block_async_cb, &data, NULL);
 
-  fail_unless (data[0] == FALSE);
-  fail_unless (data[1] == FALSE);
+  fail_unless (data[0] == TRUE);
+  fail_unless (data[1] == TRUE);
   gst_pad_push (pad, gst_buffer_new ());
 
   gst_object_unref (pad);
@@ -703,7 +759,7 @@ GST_END_TEST;
 static void
 block_async_second (GstPad * pad, gboolean blocked, gpointer user_data)
 {
-  gst_pad_set_blocked_async (pad, FALSE, unblock_async_cb, NULL);
+  gst_pad_set_blocked (pad, FALSE, unblock_async_cb, NULL, NULL);
 }
 
 static void
@@ -720,7 +776,7 @@ block_async_first (GstPad * pad, gboolean blocked, gpointer user_data)
 
   /* replace block_async_first with block_async_second so next time the pad is
    * blocked the latter should be called */
-  gst_pad_set_blocked_async (pad, TRUE, block_async_second, NULL);
+  gst_pad_set_blocked (pad, TRUE, block_async_second, NULL, NULL);
 
   /* unblock temporarily, in the next push block_async_second should be called
    */
@@ -736,7 +792,7 @@ GST_START_TEST (test_block_async_replace_callback)
   fail_unless (pad != NULL);
   gst_pad_set_active (pad, TRUE);
 
-  gst_pad_set_blocked_async (pad, TRUE, block_async_first, &blocked);
+  gst_pad_set_blocked (pad, TRUE, block_async_first, &blocked, NULL);
   blocked = FALSE;
 
   gst_pad_push (pad, gst_buffer_new ());
@@ -784,38 +840,41 @@ GST_START_TEST (test_block_async_full_destroy)
   fail_unless (pad != NULL);
   gst_pad_set_active (pad, TRUE);
 
-  gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
+  gst_pad_set_blocked (pad, TRUE, block_async_full_cb,
       &state, block_async_full_destroy);
-  fail_unless (state == 0);
+  fail_unless (state == 2);
 
   gst_pad_push (pad, gst_buffer_new ());
   /* block_async_full_cb sets state to 1 and then flushes to unblock temporarily
    */
-  fail_unless (state == 1);
+  fail_unless (state == 2);
   gst_pad_push_event (pad, gst_event_new_flush_stop ());
 
   /* pad was already blocked so nothing happens */
-  gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
+  state = 0;
+  gst_pad_set_blocked (pad, TRUE, block_async_full_cb,
       &state, block_async_full_destroy);
-  fail_unless (state == 1);
+  fail_unless (state == 2);
 
   /* unblock with the same data, callback is called */
-  gst_pad_set_blocked_async_full (pad, FALSE, block_async_full_cb,
+  gst_pad_set_blocked (pad, FALSE, block_async_full_cb,
       &state, block_async_full_destroy);
   fail_unless (state == 2);
 
   /* block with the same data, callback is called */
   state = 1;
-  gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
+  gst_pad_set_blocked (pad, TRUE, block_async_full_cb,
       &state, block_async_full_destroy);
   fail_unless (state == 2);
 
   /* now change user_data (to NULL in this case) so destroy_notify should be
    * called */
+#if 0
   state = 1;
-  gst_pad_set_blocked_async_full (pad, FALSE, block_async_full_cb,
+  gst_pad_set_blocked (pad, FALSE, block_async_full_cb,
       NULL, block_async_full_destroy);
   fail_unless (state == 2);
+#endif
 
   gst_object_unref (pad);
 }
@@ -832,13 +891,13 @@ GST_START_TEST (test_block_async_full_destroy_dispose)
   fail_unless (pad != NULL);
   gst_pad_set_active (pad, TRUE);
 
-  gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
+  gst_pad_set_blocked (pad, TRUE, block_async_full_cb,
       &state, block_async_full_destroy);
 
   gst_pad_push (pad, gst_buffer_new ());
   /* block_async_full_cb sets state to 1 and then flushes to unblock temporarily
    */
-  fail_unless_equals_int (state, 1);
+  fail_unless_equals_int (state, 2);
   gst_pad_push_event (pad, gst_event_new_flush_stop ());
 
   /* gst_pad_dispose calls the destroy_notify function if necessary */
@@ -868,12 +927,6 @@ unblock_async_no_flush_cb (GstPad * pad, gboolean blocked, gpointer user_data)
 
 
 static void
-unblock_async_not_called (GstPad * pad, gboolean blocked, gpointer user_data)
-{
-  g_warn_if_reached ();
-}
-
-static void
 block_async_second_no_flush (GstPad * pad, gboolean blocked, gpointer user_data)
 {
   gboolean *bool_user_data = (gboolean *) user_data;
@@ -886,8 +939,8 @@ block_async_second_no_flush (GstPad * pad, gboolean blocked, gpointer user_data)
 
   bool_user_data[1] = TRUE;
 
-  fail_unless (gst_pad_set_blocked_async (pad, FALSE, unblock_async_no_flush_cb,
-          user_data));
+  fail_unless (gst_pad_set_blocked (pad, FALSE, unblock_async_no_flush_cb,
+          user_data, NULL));
 }
 
 static void
@@ -908,13 +961,12 @@ block_async_first_no_flush (GstPad * pad, gboolean blocked, gpointer user_data)
   fail_unless (bool_user_data[1] == FALSE);
   fail_unless (bool_user_data[2] == FALSE);
 
-  fail_unless (gst_pad_set_blocked_async (pad, FALSE, unblock_async_not_called,
-          NULL));
+  fail_unless (gst_pad_set_blocked (pad, FALSE, NULL, NULL, NULL));
 
   /* replace block_async_first with block_async_second so next time the pad is
    * blocked the latter should be called */
-  fail_unless (gst_pad_set_blocked_async (pad, TRUE,
-          block_async_second_no_flush, user_data));
+  fail_unless (gst_pad_set_blocked (pad, TRUE,
+          block_async_second_no_flush, user_data, NULL));
 }
 
 GST_START_TEST (test_block_async_replace_callback_no_flush)
@@ -926,8 +978,8 @@ GST_START_TEST (test_block_async_replace_callback_no_flush)
   fail_unless (pad != NULL);
   gst_pad_set_active (pad, TRUE);
 
-  fail_unless (gst_pad_set_blocked_async (pad, TRUE, block_async_first_no_flush,
-          bool_user_data));
+  fail_unless (gst_pad_set_blocked (pad, TRUE, block_async_first_no_flush,
+          bool_user_data, NULL));
 
   gst_pad_push (pad, gst_buffer_new ());
   fail_unless (bool_user_data[0] == TRUE);