| /* 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 |
| * @title: 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. |
| * |
| * ## Example launch line |
| * |[ |
| * gst-launch-1.0 videotestsrc ! kmssink |
| * ]| |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <gst/video/video.h> |
| #include <gst/video/videooverlay.h> |
| #include <gst/allocators/gstdmabuf.h> |
| #include <gst/allocators/gstdmabufmeta.h> |
| #include <gst/allocators/gstphymemmeta.h> |
| |
| #include <drm.h> |
| #include <xf86drm.h> |
| #include <xf86drmMode.h> |
| #include <drm_fourcc.h> |
| |
| #include <string.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| |
| #include "gstkmssink.h" |
| #include "gstkmsutils.h" |
| #include "gstkmsbufferpool.h" |
| #include "gstkmsallocator.h" |
| |
| #include <gst/video/gstvideohdr10meta.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); |
| GST_DEBUG_CATEGORY_STATIC (CAT_PERFORMANCE); |
| #define GST_CAT_DEFAULT gst_kms_sink_debug |
| |
| static GstFlowReturn gst_kms_sink_show_frame (GstVideoSink * vsink, |
| GstBuffer * buf); |
| static void gst_kms_sink_video_overlay_init (GstVideoOverlayInterface * iface); |
| static void ensure_kms_allocator (GstKMSSink * self); |
| |
| #define parent_class gst_kms_sink_parent_class |
| 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); |
| GST_DEBUG_CATEGORY_GET (CAT_PERFORMANCE, "GST_PERFORMANCE"); |
| G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY, |
| gst_kms_sink_video_overlay_init)); |
| |
| enum |
| { |
| PROP_DRIVER_NAME = 1, |
| PROP_CONNECTOR_ID, |
| PROP_PLANE_ID, |
| PROP_FORCE_MODESETTING, |
| PROP_GLOBAL_ALPHA, |
| PROP_N |
| }; |
| |
| static GParamSpec *g_properties[PROP_N] = { NULL, }; |
| |
| #define SCALE_RATIO_NO_LIMITATION 100000 |
| |
| static void |
| gst_kms_sink_set_render_rectangle (GstVideoOverlay * overlay, |
| gint x, gint y, gint width, gint height) |
| { |
| GstKMSSink *self = GST_KMS_SINK (overlay); |
| |
| if (width <= 0 || height <= 0) { |
| if (width == -1 && height == -1) { |
| x = 0; |
| y = 0; |
| width = self->hdisplay; |
| height = self->vdisplay; |
| goto commit; |
| } |
| return; |
| } |
| |
| commit: |
| GST_OBJECT_LOCK (self); |
| if (self->can_scale) { |
| self->preferred_rect.x = x; |
| self->preferred_rect.y = y; |
| self->preferred_rect.w = width; |
| self->preferred_rect.h = height; |
| } else { |
| GstVideoRectangle src = { 0, }; |
| GstVideoRectangle dst = { 0, }; |
| GstVideoRectangle result; |
| |
| src.w = self->original_width; |
| src.h = self->original_heigth; |
| |
| dst.w = width; |
| dst.h = height; |
| |
| gst_video_sink_center_rect (src, dst, &result, TRUE); |
| |
| self->pending_rect.x = x + result.x; |
| self->pending_rect.y = y + result.y; |
| self->pending_rect.w = result.w; |
| self->pending_rect.h = result.h; |
| |
| GST_DEBUG_OBJECT (self, "pending resize to (%d,%d)-(%dx%d)", |
| self->pending_rect.x, self->pending_rect.y, |
| self->pending_rect.w, self->pending_rect.h); |
| } |
| GST_OBJECT_UNLOCK (self); |
| } |
| |
| static void |
| gst_kms_sink_expose (GstVideoOverlay * overlay) |
| { |
| GstKMSSink *self = GST_KMS_SINK (overlay); |
| |
| if (self->can_scale) { |
| gst_kms_sink_show_frame (GST_VIDEO_SINK (self), NULL); |
| } else { |
| GST_OBJECT_LOCK (self); |
| self->reconfigure = TRUE; |
| GST_OBJECT_UNLOCK (self); |
| |
| gst_pad_push_event (GST_BASE_SINK (self)->sinkpad, |
| gst_event_new_reconfigure ()); |
| } |
| } |
| |
| static void |
| gst_kms_sink_video_overlay_init (GstVideoOverlayInterface * iface) |
| { |
| iface->expose = gst_kms_sink_expose; |
| iface->set_render_rectangle = gst_kms_sink_set_render_rectangle; |
| } |
| |
| static int |
| kms_open (gchar ** driver) |
| { |
| static const char *drivers[] = { "i915", "radeon", "nouveau", "vmwgfx", |
| "exynos", "amdgpu", "imx-drm", "rockchip", "atmel-hlcdc", "msm" |
| }; |
| 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, |
| guint * pipe) |
| { |
| int i; |
| int crtc_id; |
| drmModeEncoder *enc; |
| drmModeCrtc *crtc; |
| guint32 crtcs_for_connector = 0; |
| |
| 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 no active crtc was found, pick the first possible crtc */ |
| if (crtc_id == -1) { |
| for (i = 0; i < conn->count_encoders; i++) { |
| enc = drmModeGetEncoder (fd, conn->encoders[i]); |
| crtcs_for_connector |= enc->possible_crtcs; |
| drmModeFreeEncoder (enc); |
| } |
| |
| if (crtcs_for_connector != 0) |
| crtc_id = res->crtcs[ffs (crtcs_for_connector) - 1]; |
| } |
| |
| 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) { |
| if (pipe) |
| *pipe = i; |
| 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, NULL); |
| 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); |
| |
| /* if no connector is used, grab the first one */ |
| if (!conn) |
| conn = drmModeGetConnector (fd, res->connectors[0]); |
| |
| 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; |
| guint64 has_prime; |
| guint64 has_async_page_flip; |
| |
| 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; |
| } |
| |
| has_prime = 0; |
| ret = drmGetCap (self->fd, DRM_CAP_PRIME, &has_prime); |
| if (ret) |
| GST_WARNING_OBJECT (self, "could not get prime capability"); |
| else |
| self->has_prime_import = (gboolean) (has_prime & DRM_PRIME_CAP_IMPORT); |
| |
| has_async_page_flip = 0; |
| ret = drmGetCap (self->fd, DRM_CAP_ASYNC_PAGE_FLIP, &has_async_page_flip); |
| if (ret) |
| GST_WARNING_OBJECT (self, "could not get async page flip capability"); |
| else |
| self->has_async_page_flip = (gboolean) has_async_page_flip; |
| |
| GST_INFO_OBJECT (self, "prime import (%s) / async page flip (%s)", |
| self->has_prime_import ? "✓" : "✗", |
| self->has_async_page_flip ? "✓" : "✗"); |
| |
| return TRUE; |
| } |
| |
| static guint |
| check_upscale (GstKMSSink * self, guint32 fb_id) { |
| guint32 src_w = self->hdisplay / 10; |
| guint32 src_h = self->vdisplay / 10; |
| guint ratio; |
| |
| for (ratio = 10; ratio > 0; ratio--) { |
| if (!drmModeSetPlane (self->ctrl_fd, self->plane_id, self->crtc_id, fb_id, 0, |
| 0, 0, src_w * ratio, src_h * ratio, |
| 0, 0, src_w << 16, src_h << 16)) |
| break; |
| } |
| |
| return ratio; |
| } |
| |
| static guint |
| check_downscale (GstKMSSink * self, guint32 fb_id) { |
| guint32 src_w = self->hdisplay / 10; |
| guint32 src_h = self->vdisplay / 10; |
| guint ratio; |
| |
| for (ratio = 10; ratio > 0; ratio--) { |
| if (!drmModeSetPlane (self->ctrl_fd, self->plane_id, self->crtc_id, fb_id, 0, |
| 0, 0, src_w, src_h, |
| 0, 0, (src_w * ratio) << 16, (src_h * ratio) << 16)) |
| break; |
| } |
| |
| return ratio; |
| } |
| |
| static void |
| check_scaleable (GstKMSSink * self) |
| { |
| guint32 fb_id; |
| GstKMSMemory *kmsmem = NULL; |
| GstVideoInfo vinfo; |
| |
| /* we assume driver can scale at initialize, |
| * if scale is checked or can not scale, we |
| * don't need check again */ |
| if (self->scale_checked || !self->can_scale) |
| return; |
| |
| if (self->conn_id < 0 || !self->display_connected) |
| return; |
| |
| /* FIXME: for dpu, we can only hard code the scale ratio, |
| * dpu has no limitation when do upscale but can not support |
| * downscale */ |
| if (strcmp (get_imx_drm_device_name(), "DPU") == 0) { |
| self->downscale_ratio = 1; |
| self->upscale_ratio = SCALE_RATIO_NO_LIMITATION; |
| return; |
| } |
| |
| gst_video_info_init (&vinfo); |
| gst_video_info_set_format (&vinfo, GST_VIDEO_FORMAT_NV12, self->hdisplay, self->vdisplay); |
| |
| ensure_kms_allocator (self); |
| |
| kmsmem = (GstKMSMemory *) gst_kms_allocator_bo_alloc (self->allocator, &vinfo); |
| if (!kmsmem) |
| return; |
| |
| fb_id = kmsmem->fb_id; |
| |
| GST_INFO_OBJECT (self, "checking scaleable"); |
| self->downscale_ratio = check_downscale (self, fb_id); |
| self->upscale_ratio = check_upscale (self, fb_id); |
| |
| GST_INFO_OBJECT (self, "got scale ratio: up (%d) down (%d)", |
| self->upscale_ratio, self->downscale_ratio); |
| |
| self->scale_checked = TRUE; |
| g_clear_pointer (&kmsmem, gst_memory_unref); |
| } |
| |
| static gboolean |
| configure_mode_setting (GstKMSSink * self, GstVideoInfo * vinfo) |
| { |
| gboolean ret; |
| drmModeConnector *conn; |
| int err; |
| drmModeFB *fb; |
| gint i; |
| drmModeModeInfo *mode; |
| guint32 fb_id; |
| GstKMSMemory *kmsmem; |
| |
| ret = FALSE; |
| conn = NULL; |
| fb = NULL; |
| mode = NULL; |
| kmsmem = NULL; |
| |
| if (self->conn_id < 0) |
| goto bail; |
| |
| GST_INFO_OBJECT (self, "configuring mode setting"); |
| |
| kmsmem = (GstKMSMemory *) gst_kms_allocator_bo_alloc (self->allocator, vinfo); |
| if (!kmsmem) |
| goto bo_failed; |
| fb_id = kmsmem->fb_id; |
| |
| conn = drmModeGetConnector (self->fd, self->conn_id); |
| if (!conn) |
| goto connector_failed; |
| |
| fb = drmModeGetFB (self->fd, fb_id); |
| if (!fb) |
| goto framebuffer_failed; |
| |
| for (i = 0; i < conn->count_modes; i++) { |
| if (conn->modes[i].vdisplay == fb->height && |
| conn->modes[i].hdisplay == fb->width) { |
| mode = &conn->modes[i]; |
| break; |
| } |
| } |
| if (!mode) |
| goto mode_failed; |
| |
| err = drmModeSetCrtc (self->fd, self->crtc_id, fb_id, 0, 0, |
| (uint32_t *) & self->conn_id, 1, mode); |
| if (err) |
| goto modesetting_failed; |
| |
| self->tmp_kmsmem = (GstMemory *) kmsmem; |
| |
| ret = TRUE; |
| |
| bail: |
| if (fb) |
| drmModeFreeFB (fb); |
| if (conn) |
| drmModeFreeConnector (conn); |
| |
| return ret; |
| |
| /* ERRORS */ |
| bo_failed: |
| { |
| GST_ERROR_OBJECT (self, |
| "failed to allocate buffer object for mode setting"); |
| goto bail; |
| } |
| connector_failed: |
| { |
| GST_ERROR_OBJECT (self, "Could not find a valid monitor connector"); |
| goto bail; |
| } |
| framebuffer_failed: |
| { |
| GST_ERROR_OBJECT (self, "drmModeGetFB failed: %s (%d)", |
| strerror (errno), errno); |
| goto bail; |
| } |
| mode_failed: |
| { |
| GST_ERROR_OBJECT (self, "cannot find appropriate mode"); |
| goto bail; |
| } |
| modesetting_failed: |
| { |
| GST_ERROR_OBJECT (self, "Failed to set mode: %s", strerror (errno)); |
| goto bail; |
| } |
| } |
| |
| static gboolean |
| ensure_allowed_caps (GstKMSSink * self, drmModeConnector * conn, |
| drmModePlane * plane, drmModeRes * res) |
| { |
| GstCaps *out_caps, *tmp_caps, *caps; |
| int i, j; |
| GstVideoFormat fmt; |
| const gchar *format; |
| drmModeModeInfo *mode; |
| gint count_modes; |
| |
| if (self->allowed_caps) |
| return TRUE; |
| |
| out_caps = gst_caps_new_empty (); |
| if (!out_caps) |
| return FALSE; |
| |
| if (conn && self->modesetting_enabled && self->display_connected) |
| count_modes = conn->count_modes; |
| else |
| count_modes = 1; |
| |
| for (i = 0; i < count_modes; i++) { |
| tmp_caps = gst_caps_new_empty (); |
| if (!tmp_caps) |
| return FALSE; |
| |
| mode = NULL; |
| if (conn && self->modesetting_enabled) |
| mode = &conn->modes[i]; |
| |
| for (j = 0; j < plane->count_formats; j++) { |
| fmt = gst_video_format_from_drm (plane->formats[j]); |
| if (fmt == GST_VIDEO_FORMAT_UNKNOWN) { |
| GST_INFO_OBJECT (self, "ignoring format %" GST_FOURCC_FORMAT, |
| GST_FOURCC_ARGS (plane->formats[j])); |
| continue; |
| } |
| |
| format = gst_video_format_to_string (fmt); |
| |
| if (mode) { |
| caps = gst_caps_new_simple ("video/x-raw", |
| "format", G_TYPE_STRING, format, |
| "width", G_TYPE_INT, mode->hdisplay, |
| "height", G_TYPE_INT, mode->vdisplay, |
| "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL); |
| } else { |
| 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; |
| |
| tmp_caps = gst_caps_merge (tmp_caps, caps); |
| } |
| /* FIXME: Add NV12_10LE caps here, no need this code |
| * when new drm fourcc added*/ |
| caps = gst_caps_new_simple ("video/x-raw", |
| "format", G_TYPE_STRING, "NV12_10LE", |
| "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); |
| |
| tmp_caps = gst_caps_merge (tmp_caps, caps); |
| |
| out_caps = gst_caps_merge (out_caps, gst_caps_simplify (tmp_caps)); |
| } |
| |
| self->allowed_caps = gst_caps_simplify (out_caps); |
| |
| GST_DEBUG_OBJECT (self, "allowed caps = %" GST_PTR_FORMAT, |
| self->allowed_caps); |
| |
| return (self->allowed_caps && !gst_caps_is_empty (self->allowed_caps)); |
| } |
| |
| static gint |
| get_drm_minor_base (gint type) |
| { |
| switch (type) { |
| case DRM_NODE_PRIMARY: |
| return 0; |
| case DRM_NODE_CONTROL: |
| return 64; |
| case DRM_NODE_RENDER: |
| return 128; |
| default: |
| return -1; |
| } |
| } |
| |
| static gboolean |
| gst_kms_sink_start (GstBaseSink * bsink) |
| { |
| GstKMSSink *self; |
| drmModeRes *res; |
| drmModeConnector *conn; |
| drmModeCrtc *crtc; |
| drmModePlaneRes *pres; |
| drmModePlane *plane; |
| gboolean universal_planes; |
| gboolean ret; |
| gint minor; |
| |
| self = GST_KMS_SINK (bsink); |
| universal_planes = FALSE; |
| 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); |
| |
| minor = get_drm_minor_base (DRM_NODE_CONTROL); |
| self->ctrl_fd = drmOpenControl(minor); |
| |
| if (self->fd < 0 || self->ctrl_fd < 0) |
| goto open_failed; |
| |
| log_drm_version (self); |
| if (!get_drm_caps (self)) |
| goto bail; |
| |
| //self->can_scale = TRUE; |
| |
| 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; |
| |
| if (conn->connection == DRM_MODE_CONNECTED) |
| self->display_connected = TRUE; |
| else |
| self->display_connected = FALSE; |
| |
| GST_DEBUG_OBJECT (self, "display connection status: %s", |
| self->display_connected ? "Connected" : "disconnected"); |
| |
| crtc = find_crtc_for_connector (self->fd, res, conn, &self->pipe); |
| if (!crtc) |
| goto crtc_failed; |
| |
| if ((!crtc->mode_valid || self->modesetting_enabled) && self->display_connected) { |
| GST_DEBUG_OBJECT (self, "enabling modesetting"); |
| self->modesetting_enabled = TRUE; |
| universal_planes = TRUE; |
| } |
| |
| retry_find_plane: |
| if (universal_planes && |
| drmSetClientCap (self->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1)) |
| goto set_cap_failed; |
| |
| pres = drmModeGetPlaneResources (self->fd); |
| if (!pres) |
| goto plane_resources_failed; |
| |
| if (self->plane_id == -1) |
| plane = find_plane_for_crtc (self->fd, res, pres, crtc->crtc_id); |
| else |
| plane = drmModeGetPlane (self->fd, self->plane_id); |
| if (!plane) |
| goto plane_failed; |
| |
| if (!ensure_allowed_caps (self, conn, plane, res)) |
| goto allowed_caps_failed; |
| |
| 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->preferred_rect.x = 0; |
| self->preferred_rect.y = 0; |
| self->hdisplay = self->preferred_rect.w = crtc->mode.hdisplay; |
| self->vdisplay = self->preferred_rect.h = crtc->mode.vdisplay; |
| self->buffer_id = crtc->buffer_id; |
| |
| self->mm_width = conn->mmWidth; |
| self->mm_height = conn->mmHeight; |
| |
| GST_INFO_OBJECT (self, "display size: pixels = %dx%d / millimeters = %dx%d", |
| self->hdisplay, self->vdisplay, self->mm_width, self->mm_height); |
| |
| check_scaleable (self); |
| |
| self->pollfd.fd = self->fd; |
| gst_poll_add_fd (self->poll, &self->pollfd); |
| gst_poll_fd_ctl_read (self->poll, &self->pollfd, TRUE); |
| |
| self->original_width = -1; |
| self->original_heigth = -1; |
| |
| 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_ELEMENT_ERROR (self, RESOURCE, OPEN_READ_WRITE, |
| ("Could not open DRM module %s", GST_STR_NULL (self->devname)), |
| ("reason: %s (%d)", strerror (errno), errno)); |
| return FALSE; |
| } |
| |
| resources_failed: |
| { |
| GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, |
| ("drmModeGetResources failed"), |
| ("reason: %s (%d)", strerror (errno), errno)); |
| goto bail; |
| } |
| |
| connector_failed: |
| { |
| GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, |
| ("Could not find a valid monitor connector"), (NULL)); |
| goto bail; |
| } |
| |
| crtc_failed: |
| { |
| GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, |
| ("Could not find a crtc for connector"), (NULL)); |
| goto bail; |
| } |
| |
| set_cap_failed: |
| { |
| GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, |
| ("Could not set universal planes capability bit"), (NULL)); |
| goto bail; |
| } |
| |
| plane_resources_failed: |
| { |
| GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, |
| ("drmModeGetPlaneResources failed"), |
| ("reason: %s (%d)", strerror (errno), errno)); |
| goto bail; |
| } |
| |
| plane_failed: |
| { |
| if (universal_planes) { |
| GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, |
| ("Could not find a plane for crtc"), (NULL)); |
| goto bail; |
| } else { |
| universal_planes = TRUE; |
| goto retry_find_plane; |
| } |
| } |
| |
| allowed_caps_failed: |
| { |
| GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS, |
| ("Could not get allowed GstCaps of device"), |
| ("driver does not provide mode settings configuration")); |
| goto bail; |
| } |
| } |
| |
| static gboolean |
| gst_kms_sink_stop (GstBaseSink * bsink) |
| { |
| GstKMSSink *self; |
| |
| self = GST_KMS_SINK (bsink); |
| |
| gst_buffer_replace (&self->last_buffer, NULL); |
| gst_caps_replace (&self->allowed_caps, NULL); |
| gst_object_replace ((GstObject **) & self->pool, NULL); |
| gst_object_replace ((GstObject **) & self->allocator, NULL); |
| |
| gst_poll_remove_fd (self->poll, &self->pollfd); |
| gst_poll_restart (self->poll); |
| gst_poll_fd_init (&self->pollfd); |
| |
| if (self->fd >= 0) { |
| drmClose (self->fd); |
| self->fd = -1; |
| } |
| |
| if (self->ctrl_fd >= 0) { |
| drmClose (self->ctrl_fd); |
| self->ctrl_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, *tmp; |
| |
| self = GST_KMS_SINK (bsink); |
| |
| caps = gst_kms_sink_get_allowed_caps (self); |
| |
| GST_OBJECT_LOCK (self); |
| if (caps && self->reconfigure) { |
| tmp = gst_caps_copy (caps); |
| gst_caps_set_simple (tmp, "width", G_TYPE_INT, self->pending_rect.w, |
| "height", G_TYPE_INT, self->pending_rect.h, NULL); |
| gst_caps_append (tmp, caps); |
| caps = tmp; |
| } |
| GST_OBJECT_UNLOCK (self); |
| |
| if (caps && filter) { |
| out_caps = gst_caps_intersect_full (caps, filter, GST_CAPS_INTERSECT_FIRST); |
| gst_caps_unref (caps); |
| } else { |
| out_caps = caps; |
| } |
| GST_DEBUG_OBJECT (self, "out caps %" GST_PTR_FORMAT, out_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_calculate_display_ratio (GstKMSSink * self, GstVideoInfo * vinfo) |
| { |
| guint dar_n, dar_d; |
| guint video_width, video_height; |
| guint video_par_n, video_par_d; |
| guint dpy_par_n, dpy_par_d; |
| |
| video_width = GST_VIDEO_INFO_WIDTH (vinfo); |
| video_height = GST_VIDEO_INFO_HEIGHT (vinfo); |
| video_par_n = GST_VIDEO_INFO_PAR_N (vinfo); |
| video_par_d = GST_VIDEO_INFO_PAR_D (vinfo); |
| |
| gst_video_calculate_device_ratio (self->hdisplay, self->vdisplay, |
| self->mm_width, self->mm_height, &dpy_par_n, &dpy_par_d); |
| |
| if (!gst_video_calculate_display_ratio (&dar_n, &dar_d, video_width, |
| video_height, video_par_n, video_par_d, dpy_par_n, dpy_par_d)) |
| return FALSE; |
| |
| GST_DEBUG_OBJECT (self, "video calculated display ratio: %d/%d", dar_n, |
| dar_d); |
| |
| /* now find a width x height that respects this display ratio. |
| * prefer those that have one of w/h the same as the incoming video |
| * using wd / hd = dar_n / dar_d */ |
| |
| /* start with same height, because of interlaced video */ |
| /* check hd / dar_d is an integer scale factor, and scale wd with the PAR */ |
| if (video_height % dar_d == 0) { |
| GST_DEBUG_OBJECT (self, "keeping video height"); |
| GST_VIDEO_SINK_WIDTH (self) = (guint) |
| gst_util_uint64_scale_int (video_height, dar_n, dar_d); |
| GST_VIDEO_SINK_HEIGHT (self) = video_height; |
| } else if (video_width % dar_n == 0) { |
| GST_DEBUG_OBJECT (self, "keeping video width"); |
| GST_VIDEO_SINK_WIDTH (self) = video_width; |
| GST_VIDEO_SINK_HEIGHT (self) = (guint) |
| gst_util_uint64_scale_int (video_width, dar_d, dar_n); |
| } else { |
| GST_DEBUG_OBJECT (self, "approximating while keeping video height"); |
| GST_VIDEO_SINK_WIDTH (self) = (guint) |
| gst_util_uint64_scale_int (video_height, dar_n, dar_d); |
| GST_VIDEO_SINK_HEIGHT (self) = video_height; |
| } |
| GST_DEBUG_OBJECT (self, "scaling to %dx%d", GST_VIDEO_SINK_WIDTH (self), |
| GST_VIDEO_SINK_HEIGHT (self)); |
| |
| return TRUE; |
| } |
| |
| 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; |
| |
| if (!gst_kms_sink_calculate_display_ratio (self, &vinfo)) |
| goto no_disp_ratio; |
| |
| 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); |
| } |
| |
| if (self->modesetting_enabled && !configure_mode_setting (self, &vinfo)) |
| goto modesetting_failed; |
| |
| self->vinfo = vinfo; |
| |
| GST_OBJECT_LOCK (self); |
| if (self->reconfigure) { |
| self->reconfigure = FALSE; |
| self->preferred_rect = self->pending_rect; |
| } |
| GST_OBJECT_UNLOCK (self); |
| |
| /* initialize original video size */ |
| if (self->original_width < 0) { |
| self->original_width = GST_VIDEO_INFO_WIDTH (&self->vinfo); |
| self->original_heigth = GST_VIDEO_INFO_HEIGHT (&self->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_disp_ratio: |
| { |
| GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (NULL), |
| ("Error calculating the output display ratio of the video.")); |
| return FALSE; |
| } |
| no_pool: |
| { |
| /* Already warned in create_pool */ |
| return FALSE; |
| } |
| |
| modesetting_failed: |
| { |
| GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (NULL), |
| ("failed to configure video mode")); |
| return FALSE; |
| } |
| |
| } |
| |
| static gboolean |
| gst_kms_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query) |
| { |
| GstKMSSink *self; |
| GstCaps *caps; |
| gboolean need_pool; |
| GstVideoInfo vinfo; |
| GstBufferPool *pool; |
| guint64 drm_modifier; |
| drmModeObjectPropertiesPtr props = NULL; |
| drmModePropertyPtr prop = NULL; |
| guint i; |
| 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); |
| |
| drm_modifier = DRM_FORMAT_MOD_AMPHION_TILED; |
| gst_query_add_allocation_dmabuf_meta (query, drm_modifier); |
| |
| props = drmModeObjectGetProperties (self->fd, self->plane_id, DRM_MODE_OBJECT_PLANE); |
| for (i = 0; i < props->count_props; ++i) { |
| prop = drmModeGetProperty(self->fd, props->props[i]); |
| if (!strcmp(prop->name, "dtrc_table_ofs")) { |
| GST_DEBUG ("has dtrc_table_ofs property, can support VSI tile format"); |
| drm_modifier = DRM_FORMAT_MOD_VSI_G1_TILED; |
| gst_query_add_allocation_dmabuf_meta (query, drm_modifier); |
| drm_modifier = DRM_FORMAT_MOD_VSI_G2_TILED; |
| gst_query_add_allocation_dmabuf_meta (query, drm_modifier); |
| drm_modifier = DRM_FORMAT_MOD_VSI_G2_TILED_COMPRESSED; |
| gst_query_add_allocation_dmabuf_meta (query, drm_modifier); |
| } |
| drmModeFreeProperty (prop); |
| prop = 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 |
| sync_handler (gint fd, guint frame, guint sec, guint usec, gpointer data) |
| { |
| gboolean *waiting; |
| |
| waiting = data; |
| *waiting = FALSE; |
| } |
| |
| static gboolean |
| gst_kms_sink_sync (GstKMSSink * self) |
| { |
| gint ret; |
| gboolean waiting; |
| drmEventContext evctxt = { |
| .version = DRM_EVENT_CONTEXT_VERSION, |
| .page_flip_handler = sync_handler, |
| .vblank_handler = sync_handler, |
| }; |
| drmVBlank vbl = { |
| .request = { |
| .type = DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT, |
| .sequence = 1, |
| .signal = (gulong) & waiting, |
| }, |
| }; |
| |
| if (self->pipe == 1) |
| vbl.request.type |= DRM_VBLANK_SECONDARY; |
| else if (self->pipe > 1) |
| vbl.request.type |= self->pipe << DRM_VBLANK_HIGH_CRTC_SHIFT; |
| |
| waiting = TRUE; |
| if (!self->has_async_page_flip && !self->modesetting_enabled) { |
| ret = drmWaitVBlank (self->fd, &vbl); |
| if (ret) |
| goto vblank_failed; |
| } else { |
| ret = drmModePageFlip (self->fd, self->crtc_id, self->buffer_id, |
| DRM_MODE_PAGE_FLIP_EVENT, &waiting); |
| if (ret) |
| goto pageflip_failed; |
| } |
| |
| while (waiting) { |
| do { |
| ret = gst_poll_wait (self->poll, 3 * GST_SECOND); |
| } while (ret == -1 && (errno == EAGAIN || errno == EINTR)); |
| |
| ret = drmHandleEvent (self->fd, &evctxt); |
| if (ret) |
| goto event_failed; |
| } |
| |
| return TRUE; |
| |
| /* ERRORS */ |
| vblank_failed: |
| { |
| GST_WARNING_OBJECT (self, "drmWaitVBlank failed: %s (%d)", strerror (-ret), |
| ret); |
| return FALSE; |
| } |
| pageflip_failed: |
| { |
| GST_WARNING_OBJECT (self, "drmModePageFlip failed: %s (%d)", |
| strerror (-ret), ret); |
| return FALSE; |
| } |
| event_failed: |
| { |
| GST_ERROR_OBJECT (self, "drmHandleEvent failed: %s (%d)", strerror (-ret), |
| ret); |
| return FALSE; |
| } |
| } |
| |
| static GstMemory * |
| get_cached_kmsmem (GstMemory * mem) |
| { |
| return gst_mini_object_get_qdata (GST_MINI_OBJECT (mem), |
| g_quark_from_static_string ("kmsmem")); |
| } |
| |
| static void |
| set_cached_kmsmem (GstMemory * mem, GstMemory * kmsmem) |
| { |
| return gst_mini_object_set_qdata (GST_MINI_OBJECT (mem), |
| g_quark_from_static_string ("kmsmem"), kmsmem, |
| (GDestroyNotify) gst_memory_unref); |
| } |
| |
| static gboolean |
| gst_kms_sink_import_dmabuf (GstKMSSink * self, GstBuffer * inbuf, |
| GstBuffer ** outbuf) |
| { |
| gint prime_fds[GST_VIDEO_MAX_PLANES] = { 0, }; |
| GstVideoMeta *meta; |
| GstDmabufMeta *dmabuf_meta; |
| gint64 drm_modifier = 0; |
| guint i, n_mem, n_planes; |
| GstKMSMemory *kmsmem; |
| guint mems_idx[GST_VIDEO_MAX_PLANES]; |
| gsize mems_skip[GST_VIDEO_MAX_PLANES]; |
| GstMemory *mems[GST_VIDEO_MAX_PLANES]; |
| |
| if (!self->has_prime_import) |
| return FALSE; |
| |
| /* This will eliminate most non-dmabuf out there */ |
| if (!gst_is_dmabuf_memory (gst_buffer_peek_memory (inbuf, 0))) |
| return FALSE; |
| |
| n_planes = GST_VIDEO_INFO_N_PLANES (&self->vinfo); |
| n_mem = gst_buffer_n_memory (inbuf); |
| meta = gst_buffer_get_video_meta (inbuf); |
| dmabuf_meta = gst_buffer_get_dmabuf_meta (inbuf); |
| if (dmabuf_meta) |
| drm_modifier = dmabuf_meta->drm_modifier; |
| |
| GST_TRACE_OBJECT (self, "Found a dmabuf with %u planes and %u memories", |
| n_planes, n_mem); |
| |
| /* We cannot have multiple dmabuf per plane */ |
| if (n_mem > n_planes) |
| return FALSE; |
| g_assert (n_planes != 0); |
| |
| /* Update video info based on video meta */ |
| if (meta) { |
| GST_VIDEO_INFO_WIDTH (&self->vinfo) = meta->width; |
| GST_VIDEO_INFO_HEIGHT (&self->vinfo) = meta->height; |
| |
| for (i = 0; i < meta->n_planes; i++) { |
| GST_VIDEO_INFO_PLANE_OFFSET (&self->vinfo, i) = meta->offset[i]; |
| GST_VIDEO_INFO_PLANE_STRIDE (&self->vinfo, i) = meta->stride[i]; |
| } |
| } |
| |
| /* Find and validate all memories */ |
| for (i = 0; i < n_planes; i++) { |
| guint length; |
| |
| if (!gst_buffer_find_memory (inbuf, |
| GST_VIDEO_INFO_PLANE_OFFSET (&self->vinfo, i), 1, |
| &mems_idx[i], &length, &mems_skip[i])) |
| return FALSE; |
| |
| mems[i] = gst_buffer_peek_memory (inbuf, mems_idx[i]); |
| |
| /* adjust for memory offset, in case data does not |
| * start from byte 0 in the dmabuf fd */ |
| mems_skip[i] += mems[i]->offset; |
| |
| /* And all memory found must be dmabuf */ |
| if (!gst_is_dmabuf_memory (mems[i])) |
| return FALSE; |
| } |
| |
| kmsmem = (GstKMSMemory *) get_cached_kmsmem (mems[0]); |
| if (kmsmem) { |
| GST_LOG_OBJECT (self, "found KMS mem %p in DMABuf mem %p with fb id = %d", |
| kmsmem, mems[0], kmsmem->fb_id); |
| goto wrap_mem; |
| } |
| |
| for (i = 0; i < n_planes; i++) |
| prime_fds[i] = gst_dmabuf_memory_get_fd (mems[i]); |
| |
| GST_LOG_OBJECT (self, "found these prime ids: %d, %d, %d, %d", prime_fds[0], |
| prime_fds[1], prime_fds[2], prime_fds[3]); |
| |
| kmsmem = gst_kms_allocator_dmabuf_import (self->allocator, prime_fds, |
| n_planes, drm_modifier, mems_skip, &self->vinfo); |
| if (!kmsmem) |
| return FALSE; |
| |
| GST_LOG_OBJECT (self, "setting KMS mem %p to DMABuf mem %p with fb id = %d", |
| kmsmem, mems[0], kmsmem->fb_id); |
| set_cached_kmsmem (mems[0], GST_MEMORY_CAST (kmsmem)); |
| |
| wrap_mem: |
| *outbuf = gst_buffer_new (); |
| if (!*outbuf) |
| return FALSE; |
| gst_buffer_append_memory (*outbuf, gst_memory_ref (GST_MEMORY_CAST (kmsmem))); |
| gst_buffer_copy_into (*outbuf, inbuf, GST_BUFFER_COPY_METADATA, 0, -1); |
| gst_buffer_add_parent_buffer_meta (*outbuf, inbuf); |
| |
| return TRUE; |
| } |
| |
| static void |
| gst_kms_sink_set_kmsproperty (GstKMSSink * self, guint alpha, guint64 dtrc_table_ofs) |
| { |
| drmModeRes *res = NULL; |
| drmModePlaneRes *pres = NULL; |
| drmModePlane *plane = NULL; |
| drmModeObjectPropertiesPtr props = NULL; |
| drmModePropertyPtr prop = NULL; |
| guint i; |
| |
| props = drmModeObjectGetProperties (self->fd, self->plane_id, DRM_MODE_OBJECT_PLANE); |
| for (i = 0; i < props->count_props; ++i) { |
| prop = drmModeGetProperty(self->fd, props->props[i]); |
| if (!strcmp(prop->name, "dtrc_table_ofs") && dtrc_table_ofs) { |
| GST_DEBUG ("set DTRC table offset %lld to primary plane %d property %d", |
| dtrc_table_ofs, self->plane_id, prop->prop_id); |
| drmModeObjectSetProperty (self->ctrl_fd, self->plane_id, DRM_MODE_OBJECT_PLANE, prop->prop_id, dtrc_table_ofs); |
| } |
| drmModeFreeProperty (prop); |
| prop = NULL; |
| } |
| |
| res = drmModeGetResources (self->fd); |
| if (!res) |
| goto out; |
| |
| drmSetClientCap (self->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1); |
| |
| pres = drmModeGetPlaneResources (self->fd); |
| if (!pres) |
| goto out; |
| |
| plane = find_plane_for_crtc (self->fd, res, pres, self->crtc_id); |
| if (!plane) |
| goto out; |
| |
| props = drmModeObjectGetProperties (self->fd, plane->plane_id, DRM_MODE_OBJECT_PLANE); |
| for (i = 0; i < props->count_props; ++i) { |
| prop = drmModeGetProperty(self->fd, props->props[i]); |
| if (!strcmp(prop->name, "alpha")) { |
| GST_DEBUG ("set global alpha %d to primary plane %d property %d", |
| alpha, plane->plane_id, prop->prop_id); |
| drmModeObjectSetProperty (self->ctrl_fd, plane->plane_id, DRM_MODE_OBJECT_PLANE, prop->prop_id, alpha); |
| } |
| drmModeFreeProperty (prop); |
| prop = NULL; |
| } |
| |
| out: |
| if (res) |
| drmModeFreeResources (res); |
| if (pres) |
| drmModeFreePlaneResources (pres); |
| if (plane) |
| drmModeFreePlane (plane); |
| if (props) |
| drmModeFreeObjectProperties (props); |
| drmSetClientCap (self->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 0); |
| } |
| |
| static GstStateChangeReturn |
| gst_kms_sink_change_state (GstElement * element, GstStateChange transition) |
| { |
| GstKMSSink *self; |
| GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; |
| |
| GST_DEBUG ("changing state: %s => %s", |
| gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)), |
| gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition))); |
| |
| self = GST_KMS_SINK (element); |
| |
| switch (transition) { |
| case GST_STATE_CHANGE_NULL_TO_READY: |
| self->is_kmsproperty_set = FALSE; |
| break; |
| case GST_STATE_CHANGE_READY_TO_PAUSED: |
| { |
| guint i; |
| for (i = 0; i < DEFAULT_HOLD_BUFFER_NUM; i++) |
| self->hold_buf[i] = NULL; |
| break; |
| } |
| case GST_STATE_CHANGE_PAUSED_TO_PLAYING: |
| break; |
| default: |
| break; |
| } |
| |
| ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); |
| if (ret == GST_STATE_CHANGE_FAILURE) |
| return ret; |
| |
| switch (transition) { |
| case GST_STATE_CHANGE_PLAYING_TO_PAUSED: |
| { |
| self->run_time = gst_element_get_start_time (element); |
| break; |
| } |
| case GST_STATE_CHANGE_PAUSED_TO_READY: |
| { |
| guint i; |
| gst_kms_sink_set_kmsproperty (self, 255, 0); |
| for (i = 0; i < DEFAULT_HOLD_BUFFER_NUM; i++) { |
| if (self->hold_buf[i]) |
| gst_buffer_unref (self->hold_buf[i]); |
| } |
| break; |
| } |
| case GST_STATE_CHANGE_READY_TO_NULL: |
| if (self->run_time > 0) { |
| g_print ("Total showed frames (%lld), playing for (%"GST_TIME_FORMAT"), fps (%.3f).\n", |
| self->frame_showed, GST_TIME_ARGS (self->run_time), |
| (gfloat)GST_SECOND * self->frame_showed / self->run_time); |
| } |
| |
| self->frame_showed = 0; |
| self->run_time = 0; |
| break; |
| default: |
| break; |
| } |
| |
| return ret; |
| } |
| |
| 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); |
| |
| buf = NULL; |
| if (gst_kms_sink_import_dmabuf (self, inbuf, &buf)) |
| return buf; |
| |
| GST_CAT_INFO_OBJECT (CAT_PERFORMANCE, self, "frame copy"); |
| |
| if (!gst_buffer_pool_set_active (self->pool, TRUE)) |
| goto activate_pool_failed; |
| |
| 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; |
| |
| gst_buffer_copy_into (buf, inbuf, GST_BUFFER_COPY_METADATA, 0, -1); |
| |
| 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; |
| } |
| } |
| |
| void |
| dump_hdr10meta (GstKMSSink *self, GstBuffer * buf) |
| { |
| |
| GstVideoHdr10Meta *meta = NULL; |
| |
| /* buf could be NULL when resize */ |
| if (buf) |
| meta = gst_buffer_get_video_hdr10_meta (buf); |
| |
| if (meta){ |
| /* TODO: just dump temporarily, to do configure to drm driver for hdr10 in future */ |
| GST_INFO_OBJECT (self, "redPrimary x=%d y=%d", meta->hdr10meta.redPrimary[0], meta->hdr10meta.redPrimary[1]); |
| GST_INFO_OBJECT (self, "greenPrimary x=%d y=%d", meta->hdr10meta.greenPrimary[0], meta->hdr10meta.greenPrimary[1]); |
| GST_INFO_OBJECT (self, "bluePrimary x=%d y=%d", meta->hdr10meta.bluePrimary[0], meta->hdr10meta.bluePrimary[1]); |
| GST_INFO_OBJECT (self, "whitePoint x=%d y=%d", meta->hdr10meta.whitePoint[0], meta->hdr10meta.whitePoint[1]); |
| GST_INFO_OBJECT (self, "maxMasteringLuminance %d", meta->hdr10meta.maxMasteringLuminance); |
| GST_INFO_OBJECT (self, "minMasteringLuminance %d", meta->hdr10meta.minMasteringLuminance); |
| GST_INFO_OBJECT (self, "maxContentLightLevel %d", meta->hdr10meta.maxContentLightLevel); |
| GST_INFO_OBJECT (self, "maxFrameAverageLightLevel %d", meta->hdr10meta.maxFrameAverageLightLevel); |
| GST_INFO_OBJECT (self, "transferCharacteristics %d", meta->hdr10meta.transferCharacteristics); |
| GST_INFO_OBJECT (self, "colourPrimaries %d", meta->hdr10meta.colourPrimaries); |
| GST_INFO_OBJECT (self, "matrixCoeffs %d", meta->hdr10meta.matrixCoeffs); |
| GST_INFO_OBJECT (self, "fullRange %d", meta->hdr10meta.fullRange); |
| GST_INFO_OBJECT (self, "chromaSampleLocTypeTopField %d", meta->hdr10meta.chromaSampleLocTypeTopField); |
| GST_INFO_OBJECT (self, "chromaSampleLocTypeBottomField %d", meta->hdr10meta.chromaSampleLocTypeBottomField); |
| } |
| } |
| |
| static gboolean |
| gst_kms_sink_check_scale_ratio (GstKMSSink * self, GstVideoRectangle dst, GstVideoRectangle src) |
| { |
| gboolean can_scale = TRUE; |
| GST_INFO_OBJECT (self, "dst rectangle (%d, %d)-(%d x %d)", dst.x, dst.y, dst.w, dst.h); |
| GST_INFO_OBJECT (self, "src rectangle (%d, %d)-(%d x %d)", src.x, src.y, src.w, src.h); |
| |
| can_scale = (dst.w * self->downscale_ratio >= src.w |
| && dst.w <= src.w * self->upscale_ratio |
| && dst.h * self->downscale_ratio >= src.h |
| && dst.h <= src.h * self->upscale_ratio); |
| |
| GST_INFO_OBJECT (self, "can use hardware scale: %s", can_scale ? "TRUE" : "FALSE"); |
| return can_scale; |
| } |
| |
| 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; |
| GstPhyMemMeta *phymemmeta = NULL; |
| guint64 dtrc_table_ofs; |
| GstFlowReturn res; |
| gboolean can_scale = TRUE; |
| guint32 fmt, alignment; |
| |
| dump_hdr10meta (GST_KMS_SINK (vsink), buf); |
| |
| self = GST_KMS_SINK (vsink); |
| |
| res = GST_FLOW_ERROR; |
| |
| buffer = NULL; |
| |
| if (!self->display_connected) { |
| GST_WARNING_OBJECT (self, "display not connected, drop this buffer"); |
| return GST_FLOW_OK; |
| } |
| |
| if (strcmp (get_imx_drm_device_name(), "DPU") == 0) { |
| fmt = gst_drm_format_from_video (GST_VIDEO_INFO_FORMAT (&self->vinfo)); |
| alignment = gst_drm_alignment_from_drm_format (fmt); |
| } else { |
| alignment = 1; |
| } |
| |
| if (buf) |
| buffer = gst_kms_sink_get_input_buffer (self, buf); |
| else if (self->last_buffer) |
| buffer = gst_buffer_ref (self->last_buffer); |
| |
| 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_TRACE_OBJECT (self, "displaying fb %d", fb_id); |
| |
| if (!self->is_kmsproperty_set) { |
| phymemmeta = GST_PHY_MEM_META_GET (buffer); |
| if (phymemmeta) { |
| GST_DEBUG_OBJECT (self, "physical memory meta x_padding: %d y_padding: %d \ |
| RFC luma offset: %d chroma offset: %d", |
| phymemmeta->x_padding, phymemmeta->y_padding, phymemmeta->rfc_luma_offset, phymemmeta->rfc_chroma_offset); |
| dtrc_table_ofs = phymemmeta->rfc_luma_offset | ((guint64)phymemmeta->rfc_chroma_offset << 32); |
| gst_kms_sink_set_kmsproperty (self, self->global_alpha, dtrc_table_ofs); |
| } else |
| gst_kms_sink_set_kmsproperty (self, self->global_alpha, 0); |
| |
| self->is_kmsproperty_set = TRUE; |
| } |
| |
| GST_OBJECT_LOCK (self); |
| if (self->modesetting_enabled) { |
| self->buffer_id = fb_id; |
| goto sync_frame; |
| } |
| |
| if ((crop = gst_buffer_get_video_crop_meta (buffer))) { |
| GstVideoInfo vinfo = self->vinfo; |
| vinfo.width = crop->width; |
| vinfo.height = crop->height; |
| |
| if (!gst_kms_sink_calculate_display_ratio (self, &vinfo)) |
| goto no_disp_ratio; |
| |
| src.x = crop->x; |
| src.y = crop->y; |
| } |
| |
| src.w = GST_VIDEO_SINK_WIDTH (self); |
| src.h = GST_VIDEO_SINK_HEIGHT (self); |
| |
| dst.w = self->preferred_rect.w; |
| dst.h = self->preferred_rect.h; |
| |
| retry_set_plane: |
| gst_video_sink_center_rect (src, dst, &result, can_scale); |
| |
| result.x = GST_ROUND_DOWN_N (result.x + self->preferred_rect.x, alignment); |
| result.y = GST_ROUND_DOWN_N (result.y + self->preferred_rect.y, alignment);; |
| |
| if (crop) { |
| src.w = crop->width; |
| src.h = crop->height; |
| } else { |
| src.w = GST_ROUND_DOWN_N (GST_VIDEO_INFO_WIDTH (&self->vinfo), alignment); |
| src.h = GST_ROUND_DOWN_N (GST_VIDEO_INFO_HEIGHT (&self->vinfo), alignment); |
| } |
| |
| if (!gst_kms_sink_check_scale_ratio (self, result, src)) { |
| if (can_scale) { |
| can_scale = FALSE; |
| dst.w = MAX (self->hdisplay, src.w); |
| dst.h = MAX (self->vdisplay, src.h); |
| GST_WARNING_OBJECT (self, "try not scale"); |
| goto retry_set_plane; |
| } else |
| goto check_ratio_fail; |
| } |
| |
| GST_TRACE_OBJECT (self, |
| "scaling result at (%i,%i) %ix%i sourcing at (%i,%i) %ix%i", |
| result.x, result.y, result.w, result.h, src.x, src.y, src.w, src.h); |
| |
| /* handle out of screen case */ |
| if ((result.x + result.w) > self->hdisplay) { |
| gint crop_width = self->hdisplay - result.x; |
| if (crop_width > 0) |
| src.w = GST_ROUND_UP_2 (crop_width * src.w / result.w); |
| result.w = crop_width; |
| } |
| |
| if ((result.y + result.h) > self->vdisplay) { |
| gint crop_height = self->vdisplay - result.y; |
| if (crop_height > 0) |
| src.h = GST_ROUND_UP_2 (crop_height * src.h / result.h); |
| result.h = crop_height; |
| } |
| |
| if (result.w <= 0 || result.h <= 0 || src.h <= 0 || src.w <= 0) { |
| GST_WARNING_OBJECT (self, "video is out of display range, use previous area"); |
| self->preferred_rect = self->last_rect; |
| goto done; |
| } |
| |
| GST_TRACE_OBJECT (self, |
| "drmModeSetPlane at (%i,%i) %ix%i sourcing at (%i,%i) %ix%i", |
| result.x, result.y, result.w, result.h, src.x, src.y, src.w, src.h); |
| |
| ret = drmModeSetPlane (self->ctrl_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); |
| if (ret) { |
| goto set_plane_failed; |
| } else |
| goto done; |
| |
| sync_frame: |
| /* Wait for the previous frame to complete redraw */ |
| if (!gst_kms_sink_sync (self)) |
| goto bail; |
| |
| done: |
| if (buffer != self->last_buffer) |
| gst_buffer_replace (&self->last_buffer, buffer); |
| g_clear_pointer (&self->tmp_kmsmem, gst_memory_unref); |
| |
| GST_OBJECT_UNLOCK (self); |
| res = GST_FLOW_OK; |
| |
| self->frame_showed++; |
| self->last_rect = self->preferred_rect; |
| |
| bail: |
| if (buf) { |
| guint i; |
| |
| if (self->hold_buf[DEFAULT_HOLD_BUFFER_NUM-1]) |
| gst_buffer_unref (self->hold_buf[DEFAULT_HOLD_BUFFER_NUM-1]); |
| |
| for (i = DEFAULT_HOLD_BUFFER_NUM - 1; i > 0; i--) |
| self->hold_buf[i] = self->hold_buf[i-1]; |
| |
| self->hold_buf[0] = gst_buffer_ref (buf); |
| } |
| |
| gst_buffer_unref (buffer); |
| return res; |
| |
| /* ERRORS */ |
| buffer_invalid: |
| { |
| GST_ERROR_OBJECT (self, "invalid buffer: it doesn't have a fb id"); |
| goto bail; |
| } |
| set_plane_failed: |
| { |
| GST_OBJECT_UNLOCK (self); |
| 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)); |
| goto bail; |
| } |
| no_disp_ratio: |
| { |
| GST_OBJECT_UNLOCK (self); |
| GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (NULL), |
| ("Error calculating the output display ratio of the video.")); |
| goto bail; |
| } |
| check_ratio_fail: |
| { |
| GST_OBJECT_UNLOCK (self); |
| GST_ELEMENT_ERROR (self, RESOURCE, FAILED, (NULL), |
| ("Checking scale ratio fail.")); |
| goto bail; |
| } |
| } |
| |
| 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; |
| case PROP_PLANE_ID: |
| sink->plane_id = g_value_get_int (value); |
| break; |
| case PROP_FORCE_MODESETTING: |
| sink->modesetting_enabled = g_value_get_boolean (value); |
| break; |
| case PROP_GLOBAL_ALPHA: |
| sink->global_alpha = 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; |
| case PROP_PLANE_ID: |
| g_value_set_int (value, sink->plane_id); |
| break; |
| case PROP_FORCE_MODESETTING: |
| g_value_set_boolean (value, sink->modesetting_enabled); |
| break; |
| case PROP_GLOBAL_ALPHA: |
| g_value_set_int (value, sink->global_alpha); |
| 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); |
| gst_poll_free (sink->poll); |
| |
| G_OBJECT_CLASS (parent_class)->finalize (object); |
| } |
| |
| static void |
| gst_kms_sink_init (GstKMSSink * sink) |
| { |
| sink->fd = -1; |
| sink->conn_id = -1; |
| sink->plane_id = -1; |
| sink->can_scale = TRUE; |
| sink->scale_checked = FALSE; |
| sink->upscale_ratio = 1; |
| sink->downscale_ratio = 1; |
| gst_poll_fd_init (&sink->pollfd); |
| sink->poll = gst_poll_new (TRUE); |
| gst_video_info_init (&sink->vinfo); |
| sink->frame_showed = 0; |
| sink->run_time = 0; |
| sink->global_alpha = 0; |
| } |
| |
| 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); |
| |
| element_class->change_state = GST_DEBUG_FUNCPTR (gst_kms_sink_change_state); |
| 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; |
| |
| 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); |
| |
| /** |
| * kmssink:plane-id: |
| * |
| * There could be several planes associated with a CRTC. |
| * By default the first plane that's possible to use with a given |
| * CRTC is tried. |
| */ |
| g_properties[PROP_PLANE_ID] = g_param_spec_int ("plane-id", |
| "Plane ID", "DRM plane id", -1, G_MAXINT32, -1, |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT); |
| |
| /** |
| * kmssink:force-modesetting: |
| * |
| * If the output connector is already active, the sink automatically uses an |
| * overlay plane. Enforce mode setting in the kms sink and output to the |
| * base plane to override the automatic behavior. |
| */ |
| g_properties[PROP_FORCE_MODESETTING] = |
| g_param_spec_boolean ("force-modesetting", "Force modesetting", |
| "When enabled, the sink try to configure the display mode", FALSE, |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT); |
| |
| /** |
| * kmssink:global-alpha: |
| * |
| * configure global alpha on mscale |
| */ |
| g_properties[PROP_GLOBAL_ALPHA] = g_param_spec_int ("global-alpha", |
| "global alpha", "global alpha", 0, 255, 0, |
| 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) |