From patchwork Sun Aug 29 11:31:04 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Vedant Paranjape X-Patchwork-Id: 13564 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 7EF86BDC71 for ; Sun, 29 Aug 2021 11:31:19 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 32CC16916A; Sun, 29 Aug 2021 13:31:19 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="tc4AvzJ7"; dkim-atps=neutral Received: from mail-pg1-x531.google.com (mail-pg1-x531.google.com [IPv6:2607:f8b0:4864:20::531]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 4203968891 for ; Sun, 29 Aug 2021 13:31:18 +0200 (CEST) Received: by mail-pg1-x531.google.com with SMTP id g184so10542882pgc.6 for ; Sun, 29 Aug 2021 04:31:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=Am55ocytg6tbTJGHmSHELvf7ENqP/6U0oK2Wi1yFFwI=; b=tc4AvzJ72NvDpIU0TI5kYWdL8VJ92mNKQZfJYGCsjUMWxONEYvZSyZp7IZbt68FS29 IA3SAqI1tYp6E3NYsNsmmrzE2/G6kGxoK+P/Kwveo7syB/V/rF0+oCbYUAx6ow5v2LDQ 21+7jSnG1H5mEJJg9Gi6or7qgHdQOHNp04AwnbKO+BclTyDx2Mfm/numt0o1O9B8pOI6 SnYkmU9IeYmDOOCeSrVc5l4s586S8uIKFwUlKwcfwtmE3rjwCNdTOIlfJkHICznAFvot ol2GOTq1VhBmY7//oQkdUkmOJPTCSDFEdCG8e8hBX82dnjsmB1+OCLRN+Qsy2HDecNaI FhMg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=Am55ocytg6tbTJGHmSHELvf7ENqP/6U0oK2Wi1yFFwI=; b=N0PtrJn6AGrkRWIeeSMn4L58R6JX7W+BmoX1eIUgkHKWgolzufof7sUh175i1rqgzR pNpjLvJp7d9vva5qXGKgu4V8jZ0ve9vcEr8ioEM81wkCdtdL7+eimTDSJq6UJIP/dLwx a13lalHbHGs9uj6FR7+r0fOQAUCcc8hnn6KbyTpVeItArLyd5j4ql01TPYagdassIITh j92gi+CN7Bipv88G75nLYHglCeKe0UyZREnOnHGpp4hUmI9FyLlxosR/6kaUp7ipjOrv OWIMPlIKdoOrF/7ukd7h0YhHVCygHZ/VohVQxHC7LUTNSq47u+IyeUJwFEgUGzIxj5Ib sc3w== X-Gm-Message-State: AOAM533dvu2XyHtsh/Pfa132GnxX7+NxJqS+qA2+/grpkKufNw/tHNVA er2a8LQ3NRTw6g51vcVjycJr2YnJx8pSlw== X-Google-Smtp-Source: ABdhPJzT5mrgWD2J4fFcP+0c1nf9JL8hDl93bDpZrULLTSsQ583zzZIUjRv/cvIdMYaddpDMXAKhsA== X-Received: by 2002:a63:4b5a:: with SMTP id k26mr16497216pgl.241.1630236676495; Sun, 29 Aug 2021 04:31:16 -0700 (PDT) Received: from localhost.localdomain ([1.186.166.201]) by smtp.googlemail.com with ESMTPSA id p11sm1515617pfw.203.2021.08.29.04.31.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 29 Aug 2021 04:31:15 -0700 (PDT) From: Vedant Paranjape To: libcamera-devel@lists.libcamera.org Date: Sun, 29 Aug 2021 17:01:04 +0530 Message-Id: <20210829113104.526991-1-vedantparanjape160201@gmail.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v2] test: gstreamer: Add a test for gstreamer multi stream X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Vedant Paranjape Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" This patch adds a test to test if multi stream using libcamera's gstreamer element works. We need to work around one issue with ASan when enabled in the build: - glib has a known leak at initialization time. This is covered by the suppression file shipped with glib, but it's not clear how to use it automatically. For now, disable leak detection to avoid test failures. Signed-off-by: Vedant Paranjape --- .../gstreamer/gstreamer_multi_stream_test.cpp | 238 ++++++++++++++++++ test/gstreamer/meson.build | 1 + 2 files changed, 239 insertions(+) create mode 100644 test/gstreamer/gstreamer_multi_stream_test.cpp diff --git a/test/gstreamer/gstreamer_multi_stream_test.cpp b/test/gstreamer/gstreamer_multi_stream_test.cpp new file mode 100644 index 00000000..4f54b385 --- /dev/null +++ b/test/gstreamer/gstreamer_multi_stream_test.cpp @@ -0,0 +1,238 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2021, Vedant Paranjape + * + * gstreamer_single_stream_test.cpp - GStreamer single stream capture test + */ + +#include +#include + +#include + +#include + +#include "libcamera/internal/source_paths.h" + +#include + +#include "test.h" + +using namespace std; + +extern "C" { +const char *__asan_default_options() +{ + /* + * Disable leak detection due to a known global variable initialization + * leak in glib's g_quark_init(). This should ideally be handled by + * using a suppression file instead of disabling leak detection. + */ + return "detect_leaks=false"; +} +} + +class GstreamerSingleStreamTest : public Test +{ +protected: + int init() override + { + /* + * GStreamer by default spawns a process to run the + * gst-plugin-scanner helper. If libcamera is compiled with ASan + * enabled, and as GStreamer is most likely not, this causes the + * ASan link order check to fail when gst-plugin-scanner + * dlopen()s the plugin as many libraries will have already been + * loaded by then. Fix this issue by disabling spawning of a + * child helper process when scanning the build directory for + * plugins. + */ + gst_registry_fork_set_enabled(false); + + /* Initialize GStreamer */ + g_autoptr(GError) errInit = NULL; + if (!gst_init_check(nullptr, nullptr, &errInit)) { + g_printerr("Could not initialize GStreamer: %s\n", + errInit ? errInit->message : "unknown error"); + + return TestFail; + } + + /* + * Remove the system libcamera plugin, if any, and add the + * plugin from the build directory. + */ + GstRegistry *registry = gst_registry_get(); + GstPlugin *plugin = gst_registry_lookup(registry, "libgstlibcamera.so"); + if (plugin) { + gst_registry_remove_plugin(registry, plugin); + gst_object_unref(plugin); + } + + std::string path = libcamera::utils::libcameraBuildPath() + + "src/gstreamer"; + if (!gst_registry_scan_path(registry, path.c_str())) { + g_printerr("Failed to add plugin to registry\n"); + gst_deinit(); + return TestFail; + } + + /* Check if platform support multistream output */ + libcamera::CameraManager cm; + cm.start(); + bool cameraFound = false; + for (auto &i : cm.cameras()) { + if (i->streams().size() > 1) { + cameraName = i->id(); + cameraFound = true; + cm.stop(); + break; + } + } + + if (!cameraFound) { + cm.stop(); + return TestSkip; + } + + /* Create the elements */ + libcameraSrc_ = gst_element_factory_make("libcamerasrc", "libcamera"); + convert0_ = gst_element_factory_make("videoconvert", "convert0"); + convert1_ = gst_element_factory_make("videoconvert", "convert1"); + sink0_ = gst_element_factory_make("fakesink", "sink0"); + sink1_ = gst_element_factory_make("fakesink", "sink1"); + queue0_ = gst_element_factory_make("queue", "camera_queue0"); + queue1_ = gst_element_factory_make("queue", "camera_queue1"); + + /* Create the empty pipeline_ */ + pipeline_ = gst_pipeline_new("test-pipeline"); + + if (!pipeline_ || !convert0_ || !convert1_ || !sink0_ || + !sink1_ || !queue0_ || !queue1_ || !libcameraSrc_) { + g_printerr("Not all elements could be created. %p.%p.%p.%p.%p.%p.%p.%p\n", + pipeline_, convert0_, convert1_, sink0_, + sink1_, queue0_, queue1_, libcameraSrc_); + if (pipeline_) + gst_object_unref(pipeline_); + if (convert0_) + gst_object_unref(convert0_); + if (convert1_) + gst_object_unref(convert1_); + if (sink0_) + gst_object_unref(sink0_); + if (sink1_) + gst_object_unref(sink1_); + if (queue0_) + gst_object_unref(queue0_); + if (queue1_) + gst_object_unref(queue1_); + if (libcameraSrc_) + gst_object_unref(libcameraSrc_); + gst_deinit(); + + return TestFail; + } + + return TestPass; + } + + void cleanup() override + { + gst_object_unref(pipeline_); + gst_deinit(); + } + + int run() override + { + GstStateChangeReturn ret; + + g_object_set(libcameraSrc_, "camera-name", cameraName.c_str(), NULL); + + /* Build the pipeline */ + gst_bin_add_many(GST_BIN(pipeline_), libcameraSrc_, queue0_, queue1_, + convert0_, convert1_, sink0_, sink1_, NULL); + if (gst_element_link_many(queue0_, convert0_, sink0_, NULL) != TRUE + || gst_element_link_many(queue1_, convert1_, sink1_, NULL) != TRUE) { + g_printerr("Elements could not be linked.\n"); + return TestFail; + } + + g_autoptr(GstPad) src_pad = gst_element_get_static_pad(libcameraSrc_, "src"); + g_autoptr(GstPad) request_pad = gst_element_get_request_pad(libcameraSrc_, "src_%u"); + GstPad *queue0_sink_pad = gst_element_get_static_pad(queue0_, "sink"); + GstPad *queue1_sink_pad = gst_element_get_static_pad(queue1_, "sink"); + + if (gst_pad_link(src_pad, queue0_sink_pad) != GST_PAD_LINK_OK + || gst_pad_link(request_pad, queue1_sink_pad) != GST_PAD_LINK_OK) { + if (queue0_sink_pad) + gst_object_unref(queue0_sink_pad); + if (queue1_sink_pad) + gst_object_unref(queue1_sink_pad); + g_printerr("Pads could not be linked.\n"); + return TestFail; + } + gst_object_unref(queue0_sink_pad); + gst_object_unref(queue1_sink_pad); + + /* Start playing */ + ret = gst_element_set_state(pipeline_, GST_STATE_PLAYING); + if (ret == GST_STATE_CHANGE_FAILURE) { + g_printerr("Unable to set the pipeline to the playing state.\n"); + return TestFail; + } + + /* Wait until error or EOS or timeout after 2 seconds */ + constexpr GstMessageType msgType = + static_cast(GST_MESSAGE_ERROR | GST_MESSAGE_EOS); + constexpr GstClockTime timeout = 2 * GST_SECOND; + + g_autoptr(GstBus) bus = gst_element_get_bus(pipeline_); + g_autoptr(GstMessage) msg = gst_bus_timed_pop_filtered(bus, timeout, msgType); + + gst_element_set_state(pipeline_, GST_STATE_NULL); + + /* Parse error message */ + if (msg == NULL) + return TestPass; + + switch (GST_MESSAGE_TYPE(msg)) { + case GST_MESSAGE_ERROR: + gstreamer_print_error(msg); + break; + case GST_MESSAGE_EOS: + g_print("End-Of-Stream reached.\n"); + break; + default: + g_printerr("Unexpected message received.\n"); + break; + } + + return TestFail; + } + +private: + void gstreamer_print_error(GstMessage *msg) + { + g_autoptr(GError) err = NULL; + g_autofree gchar *debug_info = NULL; + + gst_message_parse_error(msg, &err, &debug_info); + g_printerr("Error received from element %s: %s\n", + GST_OBJECT_NAME(msg->src), err->message); + g_printerr("Debugging information: %s\n", + debug_info ? debug_info : "none"); + } + + std::string cameraName; + GstElement *pipeline_; + GstElement *libcameraSrc_; + GstElement *queue0_; + GstElement *queue1_; + GstElement *convert0_; + GstElement *convert1_; + GstElement *sink0_; + GstElement *sink1_; + +}; + +TEST_REGISTER(GstreamerSingleStreamTest) diff --git a/test/gstreamer/meson.build b/test/gstreamer/meson.build index b99aa0da..e28225b2 100644 --- a/test/gstreamer/meson.build +++ b/test/gstreamer/meson.build @@ -6,6 +6,7 @@ endif gstreamer_tests = [ ['single_stream_test', 'gstreamer_single_stream_test.cpp'], + ['multi_stream_test', 'gstreamer_multi_stream_test.cpp'], ] gstreamer_dep = dependency('gstreamer-1.0', required: true)