This is simple video sink that use libdrm/libkms API to render frames.
The element uses planes to render through drmModeSetPlane().
It has been tested in an Exynos4412 board and in a Freescale I.MX6 board.
https://bugzilla.gnome.org/show_bug.cgi?id=761059
AC_SUBST(TIGER_LIBS)
],,,[AM_CONDITIONAL(USE_TIGER, false)])
+dnl *** kms ***
+translit(dnm, m, l) AM_CONDITIONAL(USE_KMS, true)
+AG_GST_CHECK_FEATURE(KMS, [drm/kms libraries], kms, [
+ AG_GST_PKG_CHECK_MODULES(GST_VIDEO, gstreamer-video-1.0)
+ PKG_CHECK_MODULES([DRM], [libdrm libkms], HAVE_KMS=yes, HAVE_KMS=no)
+])
+
dnl *** ladspa ***
translit(dnm, m, l) AM_CONDITIONAL(USE_LADSPA, true)
AG_GST_CHECK_FEATURE(LADSPA, [ladspa], ladspa, [
AM_CONDITIONAL(USE_GTK3_GL, false)
AM_CONDITIONAL(USE_HLS, false)
AM_CONDITIONAL(USE_KATE, false)
+AM_CONDITIONAL(USE_KMS, false)
AM_CONDITIONAL(USE_TIGER, false)
AM_CONDITIONAL(USE_LADSPA, false)
AM_CONDITIONAL(USE_LV2, false)
sys/dshowvideosink/Makefile
sys/dvb/Makefile
sys/fbdev/Makefile
+sys/kms/Makefile
sys/linsys/Makefile
sys/nvenc/Makefile
sys/opensles/Makefile
FBDEV_DIR=
endif
+if USE_KMS
+KMS_DIR=kms
+else
+KMS_DIR=
+endif
+
if USE_DVB
DVB_DIR=dvb
else
TINYALSA_DIR=
endif
-SUBDIRS = $(ACM_DIR) $(ANDROID_MEDIA_DIR) $(APPLE_MEDIA_DIR) $(AVC_DIR) $(BLUEZ_DIR) $(D3DVIDEOSINK_DIR) $(DECKLINK_DIR) $(DIRECTSOUND_DIR) $(WINKS_DIR) $(DVB_DIR) $(FBDEV_DIR) $(LINSYS_DIR) $(OPENSLES_DIR) $(PVR_DIR) $(SHM_DIR) $(UVCH264_DIR) $(VCD_DIR) $(VDPAU_DIR) $(WININET_DIR) $(WINSCREENCAP_DIR) $(WASAPI_DIR) $(NVENC_DIR) $(TINYALSA_DIR)
+SUBDIRS = $(ACM_DIR) $(ANDROID_MEDIA_DIR) $(APPLE_MEDIA_DIR) $(AVC_DIR) $(BLUEZ_DIR) $(D3DVIDEOSINK_DIR) $(DECKLINK_DIR) $(DIRECTSOUND_DIR) $(WINKS_DIR) $(DVB_DIR) $(FBDEV_DIR) $(KMS_DIR) $(LINSYS_DIR) $(OPENSLES_DIR) $(PVR_DIR) $(SHM_DIR) $(UVCH264_DIR) $(VCD_DIR) $(VDPAU_DIR) $(WININET_DIR) $(WINSCREENCAP_DIR) $(WASAPI_DIR) $(NVENC_DIR) $(TINYALSA_DIR)
-DIST_SUBDIRS = acmenc acmmp3dec androidmedia applemedia applemedia-nonpublic avc bluez d3dvideosink decklink directsound dvb linsys fbdev dshowdecwrapper dshowsrcwrapper dshowvideosink \
+DIST_SUBDIRS = acmenc acmmp3dec androidmedia applemedia applemedia-nonpublic avc bluez d3dvideosink decklink directsound dvb linsys fbdev kms dshowdecwrapper dshowsrcwrapper dshowvideosink \
opensles pvr2d shm uvch264 vcd vdpau wasapi wininet winks winscreencap \
nvenc tinyalsa
--- /dev/null
+plugin_LTLIBRARIES = libgstkmssink.la
+
+libgstkmssink_la_SOURCES = \
+ gstkmssink.c \
+ gstkmsutils.c \
+ gstkmsallocator.c \
+ gstkmsbufferpool.c \
+ $(NUL)
+
+libgstkmssink_la_CFLAGS = \
+ $(GST_PLUGINS_BASE_CFLAGS) \
+ $(GST_BASE_CFLAGS) \
+ $(GST_VIDEO_CFLAGS) \
+ $(GST_CFLAGS) \
+ $(DRM_CFLAGS) \
+ $(NULL)
+
+libgstkmssink_la_LIBADD = \
+ $(GST_PLUGINS_BASE_LIBS) \
+ $(GST_BASE_LIBS) \
+ $(GST_VIDEO_LIBS) \
+ $(GST_LIBS) \
+ $(DRM_LIBS) \
+ $(NULL)
+
+libgstkmssink_la_LDFLAGS = \
+ $(GST_PLUGIN_LDFLAGS) \
+ $(NULL)
+
+libgstkmssink_la_LIBTOOLFLAGS = \
+ $(GST_PLUGIN_LIBTOOLFLAGS) \
+ $(NULL)
+
+noinst_HEADERS = \
+ gstkmssink.h \
+ gstkmsutils.h \
+ gstkmsallocator.h \
+ gstkmsbufferpool.h \
+ $(NULL)
--- /dev/null
+/* GStreamer
+ *
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "gstkmsallocator.h"
+#include "gstkmsutils.h"
+
+#define GST_CAT_DEFAULT kmsallocator_debug
+GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
+
+#define GST_KMS_MEMORY_TYPE "KMSMemory"
+
+struct _GstKMSAllocatorPrivate
+{
+ int fd;
+ struct kms_driver *driver;
+};
+
+#define parent_class gst_kms_allocator_parent_class
+G_DEFINE_TYPE_WITH_CODE (GstKMSAllocator, gst_kms_allocator, GST_TYPE_ALLOCATOR,
+ G_ADD_PRIVATE (GstKMSAllocator);
+ GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "kmsallocator", 0,
+ "KMS allocator"));
+
+enum
+{
+ PROP_DRM_FD = 1,
+ PROP_N,
+};
+
+static GParamSpec *g_props[PROP_N] = { NULL, };
+
+gboolean
+gst_is_kms_memory (GstMemory * mem)
+{
+ return gst_memory_is_type (mem, GST_KMS_MEMORY_TYPE);
+}
+
+guint32
+gst_kms_memory_get_fb_id (GstMemory * mem)
+{
+ if (!gst_is_kms_memory (mem))
+ return 0;
+ return ((GstKMSMemory *) mem)->fb_id;
+}
+
+static gboolean
+ensure_kms_driver (GstKMSAllocator * alloc)
+{
+ GstKMSAllocatorPrivate *priv;
+ int err;
+
+ priv = alloc->priv;
+
+ if (priv->driver)
+ return TRUE;
+
+ if (priv->fd < 0)
+ return FALSE;
+
+ err = kms_create (priv->fd, &priv->driver);
+ if (err) {
+ GST_ERROR_OBJECT (alloc, "Could not create KMS driver: %s",
+ strerror (-err));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void
+gst_kms_allocator_free (GstAllocator * allocator, GstMemory * mem)
+{
+ GstKMSAllocator *alloc;
+ GstKMSMemory *kmsmem;
+
+ alloc = GST_KMS_ALLOCATOR (allocator);
+ kmsmem = (GstKMSMemory *) mem;
+
+ if (kmsmem->fb_id)
+ drmModeRmFB (alloc->priv->fd, kmsmem->fb_id);
+
+ if (ensure_kms_driver (alloc) && kmsmem->bo)
+ kms_bo_destroy (&kmsmem->bo);
+
+ g_slice_free (GstKMSMemory, kmsmem);
+}
+
+static void
+gst_kms_allocator_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstKMSAllocator *alloc;
+
+ alloc = GST_KMS_ALLOCATOR (object);
+
+ switch (prop_id) {
+ case PROP_DRM_FD:{
+ int fd = g_value_get_int (value);
+ if (fd > -1)
+ alloc->priv->fd = dup (fd);
+ break;
+ }
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_kms_allocator_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GstKMSAllocator *alloc;
+
+ alloc = GST_KMS_ALLOCATOR (object);
+
+ switch (prop_id) {
+ case PROP_DRM_FD:
+ g_value_set_int (value, alloc->priv->fd);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_kms_allocator_finalize (GObject * obj)
+{
+ GstKMSAllocator *alloc;
+
+ alloc = GST_KMS_ALLOCATOR (obj);
+
+ if (alloc->priv->driver)
+ kms_destroy (&alloc->priv->driver);
+
+ if (alloc->priv->fd > -1)
+ close (alloc->priv->fd);
+
+ G_OBJECT_CLASS (parent_class)->finalize (obj);
+}
+
+static void
+gst_kms_allocator_class_init (GstKMSAllocatorClass * klass)
+{
+ GObjectClass *gobject_class;
+ GstAllocatorClass *allocator_class;
+
+ allocator_class = GST_ALLOCATOR_CLASS (klass);
+ gobject_class = G_OBJECT_CLASS (klass);
+
+ allocator_class->free = gst_kms_allocator_free;
+
+ gobject_class->set_property = gst_kms_allocator_set_property;
+ gobject_class->get_property = gst_kms_allocator_get_property;
+ gobject_class->finalize = gst_kms_allocator_finalize;
+
+ g_props[PROP_DRM_FD] = g_param_spec_int ("drm-fd", "DRM fd",
+ "DRM file descriptor", -1, G_MAXINT, -1,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+
+ g_object_class_install_properties (gobject_class, PROP_N, g_props);
+}
+
+static gpointer
+gst_kms_memory_map (GstMemory * mem, gsize maxsize, GstMapFlags flags)
+{
+ GstKMSMemory *kmsmem;
+ int err;
+ gpointer out;
+
+ if (!ensure_kms_driver ((GstKMSAllocator *) mem->allocator))
+ return NULL;
+
+ kmsmem = (GstKMSMemory *) mem;
+ if (!kmsmem->bo)
+ return NULL;
+
+ out = NULL;
+ err = kms_bo_map (kmsmem->bo, &out);
+ if (err) {
+ GST_ERROR ("could not map memory: %s %d", strerror (-err), err);
+ return NULL;
+ }
+
+ return out;
+}
+
+static void
+gst_kms_memory_unmap (GstMemory * mem)
+{
+ GstKMSMemory *kmsmem;
+
+ if (!ensure_kms_driver ((GstKMSAllocator *) mem->allocator))
+ return;
+
+ kmsmem = (GstKMSMemory *) mem;
+ if (kmsmem->bo)
+ kms_bo_unmap (kmsmem->bo);
+}
+
+static void
+gst_kms_allocator_init (GstKMSAllocator * allocator)
+{
+ GstAllocator *alloc;
+
+ alloc = GST_ALLOCATOR_CAST (allocator);
+
+ allocator->priv = gst_kms_allocator_get_instance_private (allocator);
+ allocator->priv->fd = -1;
+
+ alloc->mem_type = GST_KMS_MEMORY_TYPE;
+ alloc->mem_map = gst_kms_memory_map;
+ alloc->mem_unmap = gst_kms_memory_unmap;
+ /* Use the default, fallback copy function */
+
+ GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);
+}
+
+GstAllocator *
+gst_kms_allocator_new (int fd)
+{
+ return g_object_new (GST_TYPE_KMS_ALLOCATOR, "name",
+ "KMSMemory::allocator", "drm-fd", fd, NULL);
+}
+
+static gboolean
+gst_kms_allocator_add_fb (GstKMSAllocator * alloc, GstKMSMemory * kmsmem,
+ GstVideoInfo * vinfo)
+{
+ int i, ret;
+ guint32 w, h, fmt, bo_handles[4] = { 0, };
+ guint32 offsets[4], pitches[4];
+
+ if (kmsmem->fb_id)
+ return TRUE;
+
+ w = GST_VIDEO_INFO_WIDTH (vinfo);
+ h = GST_VIDEO_INFO_HEIGHT (vinfo);
+ fmt = gst_drm_format_from_video (GST_VIDEO_INFO_FORMAT (vinfo));
+
+ if (kmsmem->bo) {
+ kms_bo_get_prop (kmsmem->bo, KMS_HANDLE, &bo_handles[0]);
+ } else {
+ return FALSE;
+ }
+
+ /* @FIXME: fill the other handles */
+ bo_handles[1] = bo_handles[0];
+ bo_handles[2] = bo_handles[0];
+
+ for (i = 0; i < 4; i++) {
+ offsets[i] = GST_VIDEO_INFO_PLANE_OFFSET (vinfo, i);
+ pitches[i] = GST_VIDEO_INFO_PLANE_STRIDE (vinfo, i);
+ }
+
+ ret = drmModeAddFB2 (alloc->priv->fd, w, h, fmt, bo_handles, pitches,
+ offsets, &kmsmem->fb_id, 0);
+ if (ret) {
+ GST_ERROR_OBJECT (alloc, "Failed to bind to framebuffer: %s (%d)",
+ strerror (-ret), ret);
+ return FALSE;
+ }
+ return TRUE;
+}
+
+GstMemory *
+gst_kms_allocator_bo_alloc (GstAllocator * allocator, GstVideoInfo * vinfo)
+{
+ GstKMSAllocator *alloc;
+ GstKMSMemory *kmsmem;
+ GstMemory *mem;
+ int ret;
+ guint attrs[] = {
+ KMS_WIDTH, GST_VIDEO_INFO_WIDTH (vinfo),
+ KMS_HEIGHT, GST_VIDEO_INFO_HEIGHT (vinfo),
+ KMS_TERMINATE_PROP_LIST,
+ };
+
+ kmsmem = g_slice_new0 (GstKMSMemory);
+ if (!kmsmem)
+ return NULL;
+
+ mem = GST_MEMORY_CAST (kmsmem);
+ gst_memory_init (mem, GST_MEMORY_FLAG_NO_SHARE, allocator, NULL,
+ GST_VIDEO_INFO_SIZE (vinfo), 0, 0, GST_VIDEO_INFO_SIZE (vinfo));
+
+ alloc = GST_KMS_ALLOCATOR (allocator);
+ if (!ensure_kms_driver (alloc))
+ goto fail;
+
+ kmsmem = (GstKMSMemory *) mem;
+ ret = kms_bo_create (alloc->priv->driver, attrs, &kmsmem->bo);
+ if (ret) {
+ GST_ERROR_OBJECT (alloc, "Failed to create buffer object: %s (%d)",
+ strerror (-ret), ret);
+ goto fail;
+ }
+ if (!gst_kms_allocator_add_fb (alloc, kmsmem, vinfo))
+ goto fail;
+
+ return mem;
+
+ /* ERRORS */
+fail:
+ gst_memory_unref (mem);
+ return NULL;
+}
--- /dev/null
+/* GStreamer
+ *
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef __GST_KMS_ALLOCATOR_H__
+#define __GST_KMS_ALLOCATOR_H__
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+#include <libkms.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_KMS_ALLOCATOR \
+ (gst_kms_allocator_get_type())
+#define GST_IS_KMS_ALLOCATOR(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_KMS_ALLOCATOR))
+#define GST_IS_KMS_ALLOCATOR_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_KMS_ALLOCATOR))
+#define GST_KMS_ALLOCATOR_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_KMS_ALLOCATOR, GstKMSAllocatorClass))
+#define GST_KMS_ALLOCATOR(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_KMS_ALLOCATOR, GstKMSAllocator))
+#define GST_KMS_ALLOCATOR_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_KMS_ALLOCATOR, GstKMSAllocatorClass))
+
+typedef struct _GstKMSAllocator GstKMSAllocator;
+typedef struct _GstKMSAllocatorClass GstKMSAllocatorClass;
+typedef struct _GstKMSAllocatorPrivate GstKMSAllocatorPrivate;
+typedef struct _GstKMSMemory GstKMSMemory;
+
+struct _GstKMSMemory
+{
+ GstMemory parent;
+
+ guint32 fb_id;
+ struct kms_bo *bo;
+};
+
+struct _GstKMSAllocator
+{
+ GstAllocator parent;
+ GstKMSAllocatorPrivate *priv;
+};
+
+struct _GstKMSAllocatorClass {
+ GstAllocatorClass parent_class;
+};
+
+GType gst_kms_allocator_get_type (void) G_GNUC_CONST;
+
+gboolean gst_is_kms_memory (GstMemory *mem);
+guint32 gst_kms_memory_get_fb_id (GstMemory *mem);
+
+GstAllocator* gst_kms_allocator_new (gint fd);
+
+GstMemory* gst_kms_allocator_bo_alloc (GstAllocator *allocator,
+ GstVideoInfo *vinfo);
+
+G_END_DECLS
+
+
+#endif /* __GST_KMS_ALLOCATOR_H__ */
--- /dev/null
+/*
+ * GStreamer
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/video/gstvideometa.h>
+
+#include "gstkmsbufferpool.h"
+#include "gstkmsallocator.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_kms_buffer_pool_debug);
+#define GST_CAT_DEFAULT gst_kms_buffer_pool_debug
+
+struct _GstKMSBufferPoolPrivate
+{
+ gint fd;
+ GstVideoInfo vinfo;
+ GstAllocator *allocator;
+ gboolean add_videometa;
+};
+
+#define parent_class gst_kms_buffer_pool_parent_class
+G_DEFINE_TYPE_WITH_CODE (GstKMSBufferPool, gst_kms_buffer_pool,
+ GST_TYPE_VIDEO_BUFFER_POOL, G_ADD_PRIVATE (GstKMSBufferPool);
+ GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "kmsbufferpool", 0,
+ "KMS buffer pool"));
+
+static const gchar **
+gst_kms_buffer_pool_get_options (GstBufferPool * pool)
+{
+ static const gchar *options[] = { GST_BUFFER_POOL_OPTION_VIDEO_META,
+ GST_BUFFER_POOL_OPTION_KMS_BUFFER, NULL
+ };
+ return options;
+}
+
+static gboolean
+gst_kms_buffer_pool_set_config (GstBufferPool * pool, GstStructure * config)
+{
+ GstKMSBufferPool *vpool;
+ GstKMSBufferPoolPrivate *priv;
+ GstCaps *caps;
+ GstVideoInfo vinfo;
+ GstAllocator *allocator;
+ GstAllocationParams params;
+
+ vpool = GST_KMS_BUFFER_POOL_CAST (pool);
+ priv = vpool->priv;
+
+ if (!gst_buffer_pool_config_get_params (config, &caps, NULL, NULL, NULL))
+ goto wrong_config;
+
+ if (!caps)
+ goto no_caps;
+
+ /* now parse the caps from the config */
+ if (!gst_video_info_from_caps (&vinfo, caps))
+ goto wrong_caps;
+
+ allocator = NULL;
+ gst_buffer_pool_config_get_allocator (config, &allocator, ¶ms);
+
+ /* not our allocator, not our buffers */
+ if (!allocator || !GST_IS_KMS_ALLOCATOR (allocator))
+ goto wrong_allocator;
+
+ if (priv->allocator)
+ gst_object_unref (priv->allocator);
+ if ((priv->allocator = allocator))
+ gst_object_ref (allocator);
+
+ priv->vinfo = vinfo;
+
+ /* enable metadata based on config of the pool */
+ priv->add_videometa = gst_buffer_pool_config_has_option (config,
+ GST_BUFFER_POOL_OPTION_VIDEO_META);
+
+ return GST_BUFFER_POOL_CLASS (parent_class)->set_config (pool, config);
+
+ /* ERRORS */
+wrong_config:
+ {
+ GST_WARNING_OBJECT (pool, "invalid config");
+ return FALSE;
+ }
+no_caps:
+ {
+ GST_WARNING_OBJECT (pool, "no caps in config");
+ return FALSE;
+ }
+wrong_caps:
+ {
+ GST_WARNING_OBJECT (pool,
+ "failed getting geometry from caps %" GST_PTR_FORMAT, caps);
+ return FALSE;
+ }
+wrong_allocator:
+ {
+ GST_WARNING_OBJECT (pool, "invalid allocator: %" GST_PTR_FORMAT, allocator);
+ return FALSE;
+ }
+}
+
+static GstFlowReturn
+gst_kms_buffer_pool_alloc_buffer (GstBufferPool * pool, GstBuffer ** buffer,
+ GstBufferPoolAcquireParams * params)
+{
+ GstKMSBufferPool *vpool;
+ GstKMSBufferPoolPrivate *priv;
+ GstVideoInfo *info;
+ GstMemory *mem;
+
+ vpool = GST_KMS_BUFFER_POOL_CAST (pool);
+ priv = vpool->priv;
+ info = &priv->vinfo;
+
+ *buffer = gst_buffer_new ();
+ if (*buffer == NULL)
+ goto no_memory;
+ mem = gst_kms_allocator_bo_alloc (priv->allocator, info);
+ if (!mem) {
+ gst_buffer_unref (*buffer);
+ goto no_memory;
+ }
+ gst_buffer_append_memory (*buffer, mem);
+
+ if (priv->add_videometa) {
+ GST_DEBUG_OBJECT (pool, "adding GstVideoMeta");
+
+ gst_buffer_add_video_meta_full (*buffer, GST_VIDEO_FRAME_FLAG_NONE,
+ GST_VIDEO_INFO_FORMAT (info),
+ GST_VIDEO_INFO_WIDTH (info), GST_VIDEO_INFO_HEIGHT (info),
+ GST_VIDEO_INFO_N_PLANES (info), info->offset, info->stride);
+ }
+
+ return GST_FLOW_OK;
+
+ /* ERROR */
+no_memory:
+ {
+ GST_WARNING_OBJECT (pool, "can't create memory");
+ return GST_FLOW_ERROR;
+ }
+}
+
+static void
+gst_kms_buffer_pool_finalize (GObject * object)
+{
+ GstKMSBufferPool *pool;
+ GstKMSBufferPoolPrivate *priv;
+
+ pool = GST_KMS_BUFFER_POOL (object);
+ priv = pool->priv;
+
+ if (priv->allocator)
+ gst_object_unref (priv->allocator);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gst_kms_buffer_pool_init (GstKMSBufferPool * pool)
+{
+ pool->priv = gst_kms_buffer_pool_get_instance_private (pool);
+ pool->priv->fd = -1;
+}
+
+static void
+gst_kms_buffer_pool_class_init (GstKMSBufferPoolClass * klass)
+{
+ GObjectClass *gobject_class;
+ GstBufferPoolClass *gstbufferpool_class;
+
+ gobject_class = (GObjectClass *) klass;
+ gstbufferpool_class = (GstBufferPoolClass *) klass;
+
+ gobject_class->finalize = gst_kms_buffer_pool_finalize;
+
+ gstbufferpool_class->get_options = gst_kms_buffer_pool_get_options;
+ gstbufferpool_class->set_config = gst_kms_buffer_pool_set_config;
+ gstbufferpool_class->alloc_buffer = gst_kms_buffer_pool_alloc_buffer;
+}
+
+GstBufferPool *
+gst_kms_buffer_pool_new (void)
+{
+ return g_object_new (GST_TYPE_KMS_BUFFER_POOL, NULL);
+}
--- /dev/null
+/*
+ * GStreamer
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef __GST_KMS_BUFFER_POOL_H__
+#define __GST_KMS_BUFFER_POOL_H__
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+
+#include "gstkmssink.h"
+
+G_BEGIN_DECLS
+
+/**
+ * GST_BUFFER_POOL_OPTION_KMS_BUFFER:
+ *
+ * An option that can be activated on buffer pool to request KMS
+ * buffers.
+ */
+#define GST_BUFFER_POOL_OPTION_KMS_BUFFER "GstBufferPoolOptionKMSBuffer"
+
+/* video bufferpool */
+typedef struct _GstKMSBufferPool GstKMSBufferPool;
+typedef struct _GstKMSBufferPoolClass GstKMSBufferPoolClass;
+typedef struct _GstKMSBufferPoolPrivate GstKMSBufferPoolPrivate;
+
+#define GST_TYPE_KMS_BUFFER_POOL \
+ (gst_kms_buffer_pool_get_type())
+#define GST_IS_KMS_BUFFER_POOL(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_KMS_BUFFER_POOL))
+#define GST_KMS_BUFFER_POOL(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_KMS_BUFFER_POOL, GstKMSBufferPool))
+#define GST_KMS_BUFFER_POOL_CAST(obj) \
+ ((GstKMSBufferPool*)(obj))
+
+struct _GstKMSBufferPool
+{
+ GstVideoBufferPool parent;
+ GstKMSBufferPoolPrivate *priv;
+};
+
+struct _GstKMSBufferPoolClass
+{
+ GstVideoBufferPoolClass parent_class;
+};
+
+GType gst_kms_buffer_pool_get_type (void) G_GNUC_CONST;
+
+GstBufferPool *gst_kms_buffer_pool_new (void);
+
+G_END_DECLS
+
+#endif /* __GST_KMS_BUFFER_POOL_H__ */
--- /dev/null
+/* GStreamer
+ *
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+/**
+ * SECTION:element-kmssink
+ * @short_description: A KMS/DRM based video sink
+ *
+ * kmssink is a simple video sink that renders video frames directly
+ * in a plane of a DRM device.
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * |[
+ * gst-launch-1.0 videotestsrc ! kmssink
+ * ]|
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/video/video.h>
+
+#include <drm.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <string.h>
+
+#include "gstkmssink.h"
+#include "gstkmsutils.h"
+#include "gstkmsbufferpool.h"
+#include "gstkmsallocator.h"
+
+#define GST_PLUGIN_NAME "kmssink"
+#define GST_PLUGIN_DESC "Video sink using the Linux kernel mode setting API"
+
+GST_DEBUG_CATEGORY_STATIC (gst_kms_sink_debug);
+#define GST_CAT_DEFAULT gst_kms_sink_debug
+
+G_DEFINE_TYPE_WITH_CODE (GstKMSSink, gst_kms_sink, GST_TYPE_VIDEO_SINK,
+ GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, GST_PLUGIN_NAME, 0,
+ GST_PLUGIN_DESC));
+
+enum
+{
+ PROP_DRIVER_NAME = 1,
+ PROP_CONNECTOR_ID,
+ PROP_N
+};
+
+static GParamSpec *g_properties[PROP_N] = { NULL, };
+
+static int
+kms_open (gchar ** driver)
+{
+ static const char *drivers[] = { "i915", "radeon", "nouveau", "vmwgfx",
+ "exynos", "amdgpu", "imx-drm", "rockchip", "atmel-hlcdc"
+ };
+ int i, fd = -1;
+
+ for (i = 0; i < G_N_ELEMENTS (drivers); i++) {
+ fd = drmOpen (drivers[i], NULL);
+ if (fd >= 0) {
+ if (driver)
+ *driver = g_strdup (drivers[i]);
+ break;
+ }
+ }
+
+ return fd;
+}
+
+static drmModePlane *
+find_plane_for_crtc (int fd, drmModeRes * res, drmModePlaneRes * pres,
+ int crtc_id)
+{
+ drmModePlane *plane;
+ int i, pipe;
+
+ plane = NULL;
+ pipe = -1;
+ for (i = 0; i < res->count_crtcs; i++) {
+ if (crtc_id == res->crtcs[i]) {
+ pipe = i;
+ break;
+ }
+ }
+
+ if (pipe == -1)
+ return NULL;
+
+ for (i = 0; i < pres->count_planes; i++) {
+ plane = drmModeGetPlane (fd, pres->planes[i]);
+ if (plane->possible_crtcs & (1 << pipe))
+ return plane;
+ drmModeFreePlane (plane);
+ }
+
+ return NULL;
+}
+
+static drmModeCrtc *
+find_crtc_for_connector (int fd, drmModeRes * res, drmModeConnector * conn)
+{
+ int i;
+ int crtc_id;
+ drmModeEncoder *enc;
+ drmModeCrtc *crtc;
+
+ crtc_id = -1;
+ for (i = 0; i < res->count_encoders; i++) {
+ enc = drmModeGetEncoder (fd, res->encoders[i]);
+ if (enc) {
+ if (enc->encoder_id == conn->encoder_id) {
+ crtc_id = enc->crtc_id;
+ drmModeFreeEncoder (enc);
+ break;
+ }
+ drmModeFreeEncoder (enc);
+ }
+ }
+
+ if (crtc_id == -1)
+ return NULL;
+
+ for (i = 0; i < res->count_crtcs; i++) {
+ crtc = drmModeGetCrtc (fd, res->crtcs[i]);
+ if (crtc) {
+ if (crtc_id == crtc->crtc_id)
+ return crtc;
+ drmModeFreeCrtc (crtc);
+ }
+ }
+
+ return NULL;
+}
+
+static gboolean
+connector_is_used (int fd, drmModeRes * res, drmModeConnector * conn)
+{
+ gboolean result;
+ drmModeCrtc *crtc;
+
+ result = FALSE;
+ crtc = find_crtc_for_connector (fd, res, conn);
+ if (crtc) {
+ result = crtc->buffer_id != 0;
+ drmModeFreeCrtc (crtc);
+ }
+
+ return result;
+}
+
+static drmModeConnector *
+find_used_connector_by_type (int fd, drmModeRes * res, int type)
+{
+ int i;
+ drmModeConnector *conn;
+
+ conn = NULL;
+ for (i = 0; i < res->count_connectors; i++) {
+ conn = drmModeGetConnector (fd, res->connectors[i]);
+ if (conn) {
+ if ((conn->connector_type == type) && connector_is_used (fd, res, conn))
+ return conn;
+ drmModeFreeConnector (conn);
+ }
+ }
+
+ return NULL;
+}
+
+static drmModeConnector *
+find_first_used_connector (int fd, drmModeRes * res)
+{
+ int i;
+ drmModeConnector *conn;
+
+ conn = NULL;
+ for (i = 0; i < res->count_connectors; i++) {
+ conn = drmModeGetConnector (fd, res->connectors[i]);
+ if (conn) {
+ if (connector_is_used (fd, res, conn))
+ return conn;
+ drmModeFreeConnector (conn);
+ }
+ }
+
+ return NULL;
+}
+
+static drmModeConnector *
+find_main_monitor (int fd, drmModeRes * res)
+{
+ /* Find the LVDS and eDP connectors: those are the main screens. */
+ static const int priority[] = { DRM_MODE_CONNECTOR_LVDS,
+ DRM_MODE_CONNECTOR_eDP
+ };
+ int i;
+ drmModeConnector *conn;
+
+ conn = NULL;
+ for (i = 0; !conn && i < G_N_ELEMENTS (priority); i++)
+ conn = find_used_connector_by_type (fd, res, priority[i]);
+
+ /* if we didn't find a connector, grab the first one in use */
+ if (!conn)
+ conn = find_first_used_connector (fd, res);
+
+ return conn;
+}
+
+static void
+log_drm_version (GstKMSSink * self)
+{
+#ifndef GST_DISABLE_GST_DEBUG
+ drmVersion *v;
+
+ v = drmGetVersion (self->fd);
+ if (v) {
+ GST_INFO_OBJECT (self, "DRM v%d.%d.%d [%s — %s — %s]", v->version_major,
+ v->version_minor, v->version_patchlevel, GST_STR_NULL (v->name),
+ GST_STR_NULL (v->desc), GST_STR_NULL (v->date));
+ drmFreeVersion (v);
+ } else {
+ GST_WARNING_OBJECT (self, "could not get driver information: %s",
+ GST_STR_NULL (self->devname));
+ }
+#endif
+ return;
+}
+
+static gboolean
+get_drm_caps (GstKMSSink * self)
+{
+ gint ret;
+ guint64 has_dumb_buffer;
+
+ has_dumb_buffer = 0;
+ ret = drmGetCap (self->fd, DRM_CAP_DUMB_BUFFER, &has_dumb_buffer);
+ if (ret)
+ GST_WARNING_OBJECT (self, "could not get dumb buffer capability");
+ if (has_dumb_buffer == 0) {
+ GST_ERROR_OBJECT (self, "driver cannot handle dumb buffers");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+ensure_allowed_caps (GstKMSSink * self, drmModePlane * plane, drmModeRes * res)
+{
+ GstCaps *out_caps, *caps;
+ int i;
+ GstVideoFormat fmt;
+ const gchar *format;
+
+ if (self->allowed_caps)
+ return TRUE;
+
+ out_caps = gst_caps_new_empty ();
+ if (!out_caps)
+ return FALSE;
+
+ for (i = 0; i < plane->count_formats; i++) {
+ fmt = gst_video_format_from_drm (plane->formats[i]);
+ if (fmt == GST_VIDEO_FORMAT_UNKNOWN) {
+ GST_INFO_OBJECT (self, "ignoring format %" GST_FOURCC_FORMAT,
+ GST_FOURCC_ARGS (plane->formats[i]));
+ continue;
+ }
+
+ format = gst_video_format_to_string (fmt);
+ caps = gst_caps_new_simple ("video/x-raw", "format", G_TYPE_STRING, format,
+ "width", GST_TYPE_INT_RANGE, res->min_width, res->max_width,
+ "height", GST_TYPE_INT_RANGE, res->min_height, res->max_height,
+ "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
+ if (!caps)
+ continue;
+
+ out_caps = gst_caps_merge (out_caps, caps);
+ }
+
+ self->allowed_caps = gst_caps_simplify (out_caps);
+
+ GST_DEBUG_OBJECT (self, "allowed caps = %" GST_PTR_FORMAT,
+ self->allowed_caps);
+
+ return TRUE;
+}
+
+static gboolean
+gst_kms_sink_start (GstBaseSink * bsink)
+{
+ GstKMSSink *self;
+ drmModeRes *res;
+ drmModeConnector *conn;
+ drmModeCrtc *crtc;
+ drmModePlaneRes *pres;
+ drmModePlane *plane;
+ gboolean ret;
+
+ self = GST_KMS_SINK (bsink);
+ ret = FALSE;
+ res = NULL;
+ conn = NULL;
+ crtc = NULL;
+ pres = NULL;
+ plane = NULL;
+
+ if (self->devname)
+ self->fd = drmOpen (self->devname, NULL);
+ else
+ self->fd = kms_open (&self->devname);
+ if (self->fd < 0)
+ goto open_failed;
+
+ log_drm_version (self);
+ if (!get_drm_caps (self))
+ goto bail;
+
+ res = drmModeGetResources (self->fd);
+ if (!res)
+ goto resources_failed;
+
+ if (self->conn_id == -1)
+ conn = find_main_monitor (self->fd, res);
+ else
+ conn = drmModeGetConnector (self->fd, self->conn_id);
+ if (!conn)
+ goto connector_failed;
+
+ crtc = find_crtc_for_connector (self->fd, res, conn);
+ if (!crtc)
+ goto crtc_failed;
+
+ pres = drmModeGetPlaneResources (self->fd);
+ if (!pres)
+ goto plane_resources_failed;
+
+ plane = find_plane_for_crtc (self->fd, res, pres, crtc->crtc_id);
+ if (!plane)
+ goto plane_failed;
+
+ /* let's get the available color formats in plane */
+ if (!ensure_allowed_caps (self, plane, res))
+ goto bail;
+
+ self->conn_id = conn->connector_id;
+ self->crtc_id = crtc->crtc_id;
+ self->plane_id = plane->plane_id;
+
+ GST_INFO_OBJECT (self, "connector id = %d / crtc id = %d / plane id = %d",
+ self->conn_id, self->crtc_id, self->plane_id);
+
+ self->hdisplay = crtc->mode.hdisplay;
+ self->vdisplay = crtc->mode.vdisplay;
+
+ ret = TRUE;
+
+bail:
+ if (plane)
+ drmModeFreePlane (plane);
+ if (pres)
+ drmModeFreePlaneResources (pres);
+ if (crtc)
+ drmModeFreeCrtc (crtc);
+ if (conn)
+ drmModeFreeConnector (conn);
+ if (res)
+ drmModeFreeResources (res);
+
+ if (!ret && self->fd >= 0) {
+ drmClose (self->fd);
+ self->fd = -1;
+ }
+
+ return ret;
+
+ /* ERRORS */
+open_failed:
+ {
+ GST_ERROR_OBJECT (self, "Could not open DRM module %s: %s",
+ GST_STR_NULL (self->devname), strerror (errno));
+ return FALSE;
+ }
+
+resources_failed:
+ {
+ GST_ERROR_OBJECT (self, "drmModeGetResources failed: %s (%d)",
+ strerror (errno), errno);
+ goto bail;
+ }
+
+connector_failed:
+ {
+ GST_ERROR_OBJECT (self, "Could not find a valid monitor connector");
+ goto bail;
+ }
+
+crtc_failed:
+ {
+ GST_ERROR_OBJECT (self, "Could not find a crtc for connector");
+ goto bail;
+ }
+
+plane_resources_failed:
+ {
+ GST_ERROR_OBJECT (self, "drmModeGetPlaneResources failed: %s (%d)",
+ strerror (errno), errno);
+ goto bail;
+ }
+
+plane_failed:
+ {
+ GST_ERROR_OBJECT (self, "Could not find a plane for crtc");
+ goto bail;
+ }
+}
+
+static gboolean
+gst_kms_sink_stop (GstBaseSink * bsink)
+{
+ GstKMSSink *self;
+
+ self = GST_KMS_SINK (bsink);
+
+ gst_caps_replace (&self->allowed_caps, NULL);
+ gst_object_replace ((GstObject **) & self->pool, NULL);
+ gst_object_replace ((GstObject **) & self->allocator, NULL);
+
+ if (self->fd >= 0) {
+ drmClose (self->fd);
+ self->fd = -1;
+ }
+
+ return TRUE;
+}
+
+static GstCaps *
+gst_kms_sink_get_allowed_caps (GstKMSSink * self)
+{
+ if (!self->allowed_caps)
+ return NULL; /* base class will return the template caps */
+ return gst_caps_ref (self->allowed_caps);
+}
+
+static GstCaps *
+gst_kms_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
+{
+ GstKMSSink *self;
+ GstCaps *caps, *out_caps;
+
+ self = GST_KMS_SINK (bsink);
+
+ caps = gst_kms_sink_get_allowed_caps (self);
+ if (caps && filter) {
+ out_caps = gst_caps_intersect_full (caps, filter, GST_CAPS_INTERSECT_FIRST);
+ gst_caps_unref (caps);
+ } else {
+ out_caps = caps;
+ }
+
+ return out_caps;
+}
+
+static void
+ensure_kms_allocator (GstKMSSink * self)
+{
+ if (self->allocator)
+ return;
+ self->allocator = gst_kms_allocator_new (self->fd);
+}
+
+static GstBufferPool *
+gst_kms_sink_create_pool (GstKMSSink * self, GstCaps * caps, gsize size,
+ gint min)
+{
+ GstBufferPool *pool;
+ GstStructure *config;
+
+ pool = gst_kms_buffer_pool_new ();
+ if (!pool)
+ goto pool_failed;
+
+ config = gst_buffer_pool_get_config (pool);
+ gst_buffer_pool_config_set_params (config, caps, size, min, 0);
+ gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
+
+ ensure_kms_allocator (self);
+ gst_buffer_pool_config_set_allocator (config, self->allocator, NULL);
+
+ if (!gst_buffer_pool_set_config (pool, config))
+ goto config_failed;
+
+ return pool;
+
+ /* ERRORS */
+pool_failed:
+ {
+ GST_ERROR_OBJECT (self, "failed to create buffer pool");
+ return NULL;
+ }
+config_failed:
+ {
+ GST_ERROR_OBJECT (self, "failed to set config");
+ gst_object_unref (pool);
+ return NULL;
+ }
+}
+
+static gboolean
+gst_kms_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
+{
+ GstKMSSink *self;
+ GstVideoInfo vinfo;
+ GstBufferPool *newpool, *oldpool;
+
+ self = GST_KMS_SINK (bsink);
+
+ if (!gst_video_info_from_caps (&vinfo, caps))
+ goto invalid_format;
+
+ GST_VIDEO_SINK_WIDTH (self) = GST_VIDEO_INFO_WIDTH (&vinfo);
+ GST_VIDEO_SINK_HEIGHT (self) = GST_VIDEO_INFO_HEIGHT (&vinfo);
+
+ if (GST_VIDEO_SINK_WIDTH (self) <= 0 || GST_VIDEO_SINK_HEIGHT (self) <= 0)
+ goto invalid_size;
+
+ /* create a new pool for the new configuration */
+ newpool = gst_kms_sink_create_pool (self, caps, GST_VIDEO_INFO_SIZE (&vinfo),
+ 2);
+ if (!newpool)
+ goto no_pool;
+
+ /* we don't activate the internal pool yet as it may not be needed */
+ oldpool = self->pool;
+ self->pool = newpool;
+
+ if (oldpool) {
+ gst_buffer_pool_set_active (oldpool, FALSE);
+ gst_object_unref (oldpool);
+ }
+
+ self->vinfo = vinfo;
+
+ GST_DEBUG_OBJECT (self, "negotiated caps = %" GST_PTR_FORMAT, caps);
+
+ return TRUE;
+
+ /* ERRORS */
+invalid_format:
+ {
+ GST_ERROR_OBJECT (self, "caps invalid");
+ return FALSE;
+ }
+
+invalid_size:
+ {
+ GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (NULL),
+ ("Invalid image size."));
+ return FALSE;
+ }
+no_pool:
+ {
+ /* Already warned in create_pool */
+ return FALSE;
+ }
+}
+
+static gboolean
+gst_kms_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
+{
+ GstKMSSink *self;
+ GstCaps *caps;
+ gboolean need_pool;
+ GstVideoInfo vinfo;
+ GstBufferPool *pool;
+ gsize size;
+
+ self = GST_KMS_SINK (bsink);
+
+ gst_query_parse_allocation (query, &caps, &need_pool);
+ if (!caps)
+ goto no_caps;
+ if (!gst_video_info_from_caps (&vinfo, caps))
+ goto invalid_caps;
+
+ size = GST_VIDEO_INFO_SIZE (&vinfo);
+
+ pool = NULL;
+ if (need_pool) {
+ pool = gst_kms_sink_create_pool (self, caps, size, 0);
+ if (!pool)
+ goto no_pool;
+ }
+
+ if (pool) {
+ /* we need at least 2 buffer because we hold on to the last one */
+ gst_query_add_allocation_pool (query, pool, size, 2, 0);
+ gst_object_unref (pool);
+ }
+
+ gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
+ gst_query_add_allocation_meta (query, GST_VIDEO_CROP_META_API_TYPE, NULL);
+
+ return TRUE;
+
+ /* ERRORS */
+no_caps:
+ {
+ GST_DEBUG_OBJECT (bsink, "no caps specified");
+ return FALSE;
+ }
+invalid_caps:
+ {
+ GST_DEBUG_OBJECT (bsink, "invalid caps specified");
+ return FALSE;
+ }
+no_pool:
+ {
+ /* Already warned in create_pool */
+ return FALSE;
+ }
+}
+
+static void
+gst_kms_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
+ GstClockTime * start, GstClockTime * end)
+{
+ GstKMSSink *self;
+
+ self = GST_KMS_SINK (bsink);
+
+ if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
+ *start = GST_BUFFER_TIMESTAMP (buf);
+ if (GST_BUFFER_DURATION_IS_VALID (buf))
+ *end = *start + GST_BUFFER_DURATION (buf);
+ else {
+ if (GST_VIDEO_INFO_FPS_N (&self->vinfo) > 0) {
+ *end = *start +
+ gst_util_uint64_scale_int (GST_SECOND,
+ GST_VIDEO_INFO_FPS_D (&self->vinfo),
+ GST_VIDEO_INFO_FPS_N (&self->vinfo));
+ }
+ }
+ }
+}
+
+static GstBuffer *
+gst_kms_sink_get_input_buffer (GstKMSSink * self, GstBuffer * inbuf)
+{
+ GstMemory *mem;
+ GstBuffer *buf;
+ GstFlowReturn ret;
+ GstVideoFrame inframe, outframe;
+ gboolean success;
+
+ mem = gst_buffer_peek_memory (inbuf, 0);
+ if (!mem)
+ return NULL;
+
+ if (gst_is_kms_memory (mem))
+ return gst_buffer_ref (inbuf);
+
+ if (!gst_buffer_pool_set_active (self->pool, TRUE))
+ goto activate_pool_failed;
+
+ buf = NULL;
+ ret = gst_buffer_pool_acquire_buffer (self->pool, &buf, NULL);
+ if (ret != GST_FLOW_OK)
+ goto create_buffer_failed;
+
+ if (!gst_video_frame_map (&inframe, &self->vinfo, inbuf, GST_MAP_READ))
+ goto error_map_src_buffer;
+
+ if (!gst_video_frame_map (&outframe, &self->vinfo, buf, GST_MAP_WRITE))
+ goto error_map_dst_buffer;
+
+ success = gst_video_frame_copy (&outframe, &inframe);
+ gst_video_frame_unmap (&outframe);
+ gst_video_frame_unmap (&inframe);
+ if (!success)
+ goto error_copy_buffer;
+
+ return buf;
+
+bail:
+ {
+ if (buf)
+ gst_buffer_unref (buf);
+ return NULL;
+ }
+
+ /* ERRORS */
+activate_pool_failed:
+ {
+ GST_ELEMENT_ERROR (self, STREAM, FAILED, ("failed to activate buffer pool"),
+ ("failed to activate buffer pool"));
+ goto bail;
+ }
+create_buffer_failed:
+ {
+ GST_ELEMENT_ERROR (self, STREAM, FAILED, ("allocation failed"),
+ ("failed to create buffer"));
+ goto bail;
+ }
+error_copy_buffer:
+ {
+ GST_WARNING_OBJECT (self, "failed to upload buffer");
+ goto bail;
+ }
+error_map_dst_buffer:
+ {
+ gst_video_frame_unmap (&inframe);
+ /* fall-through */
+ }
+error_map_src_buffer:
+ {
+ GST_WARNING_OBJECT (self, "failed to map buffer");
+ goto bail;
+ }
+}
+
+static GstFlowReturn
+gst_kms_sink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
+{
+ gint ret;
+ GstBuffer *buffer;
+ guint32 fb_id;
+ GstKMSSink *self;
+ GstVideoCropMeta *crop;
+ GstVideoRectangle src = { 0, };
+ GstVideoRectangle dst = { 0, };
+ GstVideoRectangle result;
+
+ self = GST_KMS_SINK (vsink);
+
+ buffer = gst_kms_sink_get_input_buffer (self, buf);
+ if (!buffer)
+ return GST_FLOW_ERROR;
+ fb_id = gst_kms_memory_get_fb_id (gst_buffer_peek_memory (buffer, 0));
+ if (fb_id == 0)
+ goto buffer_invalid;
+
+ GST_DEBUG_OBJECT (self, "displaying fb %d", fb_id);
+
+ {
+ if ((crop = gst_buffer_get_video_crop_meta (buffer))) {
+ src.x = crop->x;
+ src.y = crop->y;
+ src.w = crop->width;
+ src.h = crop->height;
+ } else {
+ src.w = GST_VIDEO_SINK_WIDTH (self);
+ src.h = GST_VIDEO_SINK_HEIGHT (self);
+ }
+ }
+
+ dst.w = self->hdisplay;
+ dst.h = self->vdisplay;
+
+ gst_video_sink_center_rect (src, dst, &result, FALSE);
+
+ /* if the frame size is bigger than the display size, the source
+ * must be the display size */
+ src.w = MIN (src.w, self->hdisplay);
+ src.h = MIN (src.h, self->vdisplay);
+
+ ret = drmModeSetPlane (self->fd, self->plane_id, self->crtc_id, fb_id, 0,
+ result.x, result.y, result.w, result.h,
+ /* source/cropping coordinates are given in Q16 */
+ src.x << 16, src.y << 16, src.w << 16, src.h << 16);
+
+ gst_buffer_unref (buffer);
+
+ if (ret)
+ goto set_plane_failed;
+
+ return GST_FLOW_OK;
+
+ /* ERRORS */
+buffer_invalid:
+ {
+ GST_ERROR_OBJECT (self, "invalid buffer: it doesn't have a fb id");
+ return GST_FLOW_ERROR;
+ }
+set_plane_failed:
+ {
+ GST_DEBUG_OBJECT (self, "result = { %d, %d, %d, %d} / "
+ "src = { %d, %d, %d %d } / dst = { %d, %d, %d %d }", result.x, result.y,
+ result.w, result.h, src.x, src.y, src.w, src.h, dst.x, dst.y, dst.w,
+ dst.h);
+ GST_ELEMENT_ERROR (self, RESOURCE, FAILED,
+ (NULL), ("drmModeSetPlane failed: %s (%d)", strerror (-ret), ret));
+ return GST_FLOW_ERROR;
+ }
+}
+
+static void
+gst_kms_sink_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstKMSSink *sink;
+
+ sink = GST_KMS_SINK (object);
+
+ switch (prop_id) {
+ case PROP_DRIVER_NAME:
+ sink->devname = g_value_dup_string (value);
+ break;
+ case PROP_CONNECTOR_ID:
+ sink->conn_id = g_value_get_int (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_kms_sink_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GstKMSSink *sink;
+
+ sink = GST_KMS_SINK (object);
+
+ switch (prop_id) {
+ case PROP_DRIVER_NAME:
+ g_value_take_string (value, sink->devname);
+ break;
+ case PROP_CONNECTOR_ID:
+ g_value_set_int (value, sink->conn_id);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_kms_sink_finalize (GObject * object)
+{
+ GstKMSSink *sink;
+
+ sink = GST_KMS_SINK (object);
+ g_clear_pointer (&sink->devname, g_free);
+}
+
+static void
+gst_kms_sink_init (GstKMSSink * sink)
+{
+ sink->fd = -1;
+ sink->conn_id = -1;
+ gst_video_info_init (&sink->vinfo);
+}
+
+static void
+gst_kms_sink_class_init (GstKMSSinkClass * klass)
+{
+ GObjectClass *gobject_class;
+ GstElementClass *element_class;
+ GstBaseSinkClass *basesink_class;
+ GstVideoSinkClass *videosink_class;
+ GstCaps *caps;
+
+ gobject_class = G_OBJECT_CLASS (klass);
+ element_class = GST_ELEMENT_CLASS (klass);
+ basesink_class = GST_BASE_SINK_CLASS (klass);
+ videosink_class = GST_VIDEO_SINK_CLASS (klass);
+
+ gst_element_class_set_static_metadata (element_class, "KMS video sink",
+ "Sink/Video", GST_PLUGIN_DESC, "Víctor Jáquez <vjaquez@igalia.com>");
+
+ caps = gst_kms_sink_caps_template_fill ();
+ gst_element_class_add_pad_template (element_class,
+ gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps));
+ gst_caps_unref (caps);
+
+ basesink_class->start = GST_DEBUG_FUNCPTR (gst_kms_sink_start);
+ basesink_class->stop = GST_DEBUG_FUNCPTR (gst_kms_sink_stop);
+ basesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_kms_sink_set_caps);
+ basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_kms_sink_get_caps);
+ basesink_class->propose_allocation = gst_kms_sink_propose_allocation;
+ basesink_class->get_times = gst_kms_sink_get_times;
+
+ videosink_class->show_frame = gst_kms_sink_show_frame;
+
+ gobject_class->finalize = gst_kms_sink_finalize;
+ gobject_class->set_property = gst_kms_sink_set_property;
+ gobject_class->get_property = gst_kms_sink_get_property;
+
+ /**
+ * kmssink:driver-name:
+ *
+ * If you have a system with multiple GPUs, you can choose which GPU
+ * to use setting the DRM device driver name. Otherwise, the first
+ * one from an internal list is used.
+ */
+ g_properties[PROP_DRIVER_NAME] = g_param_spec_string ("driver-name",
+ "device name", "DRM device driver name", NULL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT);
+
+ /**
+ * kmssink:connector-id:
+ *
+ * A GPU has several output connectors, for example: LVDS, VGA,
+ * HDMI, etc. By default the first LVDS is tried, then the first
+ * eDP, and at the end, the first connected one.
+ */
+ g_properties[PROP_CONNECTOR_ID] = g_param_spec_int ("connector-id",
+ "Connector ID", "DRM connector id", -1, G_MAXINT32, -1,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT);
+
+ g_object_class_install_properties (gobject_class, PROP_N, g_properties);
+}
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+ if (!gst_element_register (plugin, GST_PLUGIN_NAME, GST_RANK_SECONDARY,
+ GST_TYPE_KMS_SINK))
+ return FALSE;
+
+ return TRUE;
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, kms,
+ GST_PLUGIN_DESC, plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME,
+ GST_PACKAGE_ORIGIN)
--- /dev/null
+/* GStreamer
+ *
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef __GST_KMS_SINK_H__
+#define __GST_KMS_SINK_H__
+
+#include <gst/video/gstvideosink.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_KMS_SINK \
+ (gst_kms_sink_get_type())
+#define GST_KMS_SINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_KMS_SINK, GstKMSSink))
+#define GST_KMS_SINK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_KMS_SINK, GstKMSSinkClass))
+#define GST_IS_KMS_SINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_KMS_SINK))
+#define GST_IS_KMS_SINK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_KMS_SINK))
+
+typedef struct _GstKMSSink GstKMSSink;
+typedef struct _GstKMSSinkClass GstKMSSinkClass;
+
+struct _GstKMSSink {
+ GstVideoSink videosink;
+
+ /*< private >*/
+ gint fd;
+ gint conn_id;
+ gint crtc_id;
+ gint plane_id;
+
+ guint16 hdisplay, vdisplay;
+
+ GstVideoInfo vinfo;
+ GstCaps *allowed_caps;
+ GstBufferPool *pool;
+ GstAllocator *allocator;
+
+ gchar *devname;
+
+ guint32 mm_width, mm_height;
+};
+
+struct _GstKMSSinkClass {
+ GstVideoSinkClass parent_class;
+};
+
+GType gst_kms_sink_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __GST_KMS_SINK_H__ */
--- /dev/null
+/* GStreamer
+ *
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <drm_fourcc.h>
+
+#include "gstkmsutils.h"
+
+/* *INDENT-OFF* */
+static const struct
+{
+ guint32 fourcc;
+ GstVideoFormat format;
+} format_map[] = {
+#define DEF_FMT(fourcc, fmt) \
+ { DRM_FORMAT_##fourcc,GST_VIDEO_FORMAT_##fmt }
+
+ /* DEF_FMT (XRGB1555, ???), */
+ /* DEF_FMT (XBGR1555, ???), */
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+ DEF_FMT (ARGB8888, BGRA),
+ DEF_FMT (XRGB8888, BGRx),
+ DEF_FMT (ABGR8888, RGBA),
+ DEF_FMT (XBGR8888, RGBx),
+#else
+ DEF_FMT (ARGB8888, ARGB),
+ DEF_FMT (XRGB8888, xRGB),
+ DEF_FMT (ABGR8888, ABGR),
+ DEF_FMT (XBGR8888, xBGR),
+#endif
+ /* DEF_FMT (YUYV, ???), */
+ /* DEF_FMT (YVYU, ???), */
+ DEF_FMT (YUV420, I420),
+ DEF_FMT (YVU420, YV12),
+ DEF_FMT (NV12, NV12),
+ DEF_FMT (NV21, NV21),
+
+#undef DEF_FMT
+};
+/* *INDENT-ON* */
+
+GstVideoFormat
+gst_video_format_from_drm (guint32 drmfmt)
+{
+ gint i;
+
+ for (i = 0; i < G_N_ELEMENTS (format_map); i++) {
+ if (format_map[i].fourcc == drmfmt)
+ return format_map[i].format;
+ }
+
+ return GST_VIDEO_FORMAT_UNKNOWN;
+}
+
+guint32
+gst_drm_format_from_video (GstVideoFormat fmt)
+{
+ gint i;
+
+ for (i = 0; i < G_N_ELEMENTS (format_map); i++) {
+ if (format_map[i].format == fmt)
+ return format_map[i].fourcc;
+ }
+
+ return 0;
+}
+
+static GstStructure *
+gst_video_format_to_structure (GstVideoFormat format)
+{
+ GstStructure *structure;
+
+ structure = NULL;
+ if (format != GST_VIDEO_FORMAT_UNKNOWN)
+ structure = gst_structure_new ("video/x-raw", "format", G_TYPE_STRING,
+ gst_video_format_to_string (format), NULL);
+
+ return structure;
+}
+
+GstCaps *
+gst_kms_sink_caps_template_fill (void)
+{
+ gint i;
+ GstCaps *caps;
+ GstStructure *template;
+
+ caps = gst_caps_new_empty ();
+ for (i = 0; i < G_N_ELEMENTS (format_map); i++) {
+ template = gst_video_format_to_structure (format_map[i].format);
+ gst_structure_set (template,
+ "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+ "height", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+ "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
+ gst_caps_append_structure (caps, template);
+ }
+ return gst_caps_simplify (caps);
+}
--- /dev/null
+/* GStreamer
+ *
+ * Copyright (C) 2016 Igalia
+ *
+ * Authors:
+ * Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
+ * Javier Martin <javiermartin@by.com.es>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef __GST_KMS_UTILS_H__
+#define __GST_KMS_UTILS_H__
+
+#include <gst/video/video.h>
+
+G_BEGIN_DECLS
+
+GstVideoFormat gst_video_format_from_drm (guint32 drmfmt);
+guint32 gst_drm_format_from_video (GstVideoFormat fmt);
+GstCaps * gst_kms_sink_caps_template_fill (void);
+
+G_END_DECLS
+
+#endif
projects / platform / upstream / gstreamer.git / commitdiff