ext/vulkan/vksink.c

   1 /*
   2  * GStreamer
   3  * Copyright (C) 2015 Matthew Waters <matthew@centricular.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-vulkansink
  23  * @title: vulkansink
  24  *
  25  * vulkansink renders video frames to a drawable on a local or remote
  26  * display using Vulkan.
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 //#include <gst/video/videooverlay.h>
  34
  35 #include "vksink.h"
  36 #include "vkdevice.h"
  37
  38 GST_DEBUG_CATEGORY (gst_debug_vulkan_sink);
  39 #define GST_CAT_DEFAULT gst_debug_vulkan_sink
  40
  41 #define DEFAULT_FORCE_ASPECT_RATIO TRUE
  42 #define DEFAULT_PIXEL_ASPECT_RATIO_N 0
  43 #define DEFAULT_PIXEL_ASPECT_RATIO_D 1
  44
  45 static void gst_vulkan_sink_finalize (GObject * object);
  46 static void gst_vulkan_sink_set_property (GObject * object, guint prop_id,
  47     const GValue * value, GParamSpec * param_spec);
  48 static void gst_vulkan_sink_get_property (GObject * object, guint prop_id,
  49     GValue * value, GParamSpec * param_spec);
  50
  51 static gboolean gst_vulkan_sink_query (GstBaseSink * bsink, GstQuery * query);
  52 static void gst_vulkan_sink_set_context (GstElement * element,
  53     GstContext * context);
  54
  55 static GstStateChangeReturn
  56 gst_vulkan_sink_change_state (GstElement * element, GstStateChange transition);
  57
  58 static void gst_vulkan_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
  59     GstClockTime * start, GstClockTime * end);
  60 static gboolean gst_vulkan_sink_set_caps (GstBaseSink * bsink, GstCaps * caps);
  61 static GstCaps *gst_vulkan_sink_get_caps (GstBaseSink * bsink,
  62     GstCaps * filter);
  63 static GstFlowReturn gst_vulkan_sink_prepare (GstBaseSink * bsink,
  64     GstBuffer * buf);
  65 static GstFlowReturn gst_vulkan_sink_show_frame (GstVideoSink * bsink,
  66     GstBuffer * buf);
  67
  68 static void gst_vulkan_sink_video_overlay_init (GstVideoOverlayInterface *
  69     iface);
  70
  71
  72 static GstStaticPadTemplate gst_vulkan_sink_template =
  73 GST_STATIC_PAD_TEMPLATE ("sink",
  74     GST_PAD_SINK,
  75     GST_PAD_ALWAYS,
  76     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  77         (GST_CAPS_FEATURE_MEMORY_VULKAN_BUFFER,
  78             GST_VULKAN_SWAPPER_VIDEO_FORMATS)));
  79
  80 enum
  81 {
  82   PROP_0,
  83   PROP_FORCE_ASPECT_RATIO,
  84   PROP_PIXEL_ASPECT_RATIO,
  85 };
  86
  87 enum
  88 {
  89   SIGNAL_0,
  90   LAST_SIGNAL
  91 };
  92
  93 /* static guint gst_vulkan_sink_signals[LAST_SIGNAL] = { 0 }; */
  94
  95 #define gst_vulkan_sink_parent_class parent_class
  96 G_DEFINE_TYPE_WITH_CODE (GstVulkanSink, gst_vulkan_sink,
  97     GST_TYPE_VIDEO_SINK, GST_DEBUG_CATEGORY_INIT (gst_debug_vulkan_sink,
  98         "vulkansink", 0, "Vulkan Video Sink");
  99     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
 100         gst_vulkan_sink_video_overlay_init));
 101
 102 static void
 103 gst_vulkan_sink_class_init (GstVulkanSinkClass * klass)
 104 {
 105   GObjectClass *gobject_class;
 106   GstElementClass *gstelement_class;
 107   GstBaseSinkClass *gstbasesink_class;
 108   GstVideoSinkClass *gstvideosink_class;
 109   GstElementClass *element_class;
 110
 111   gobject_class = (GObjectClass *) klass;
 112   gstelement_class = (GstElementClass *) klass;
 113   gstbasesink_class = (GstBaseSinkClass *) klass;
 114   gstvideosink_class = (GstVideoSinkClass *) klass;
 115   element_class = GST_ELEMENT_CLASS (klass);
 116
 117   gobject_class->set_property = gst_vulkan_sink_set_property;
 118   gobject_class->get_property = gst_vulkan_sink_get_property;
 119
 120   g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO,
 121       g_param_spec_boolean ("force-aspect-ratio", "Force aspect ratio",
 122           "When enabled, scaling will respect original aspect ratio",
 123           DEFAULT_FORCE_ASPECT_RATIO,
 124           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 125
 126   g_object_class_install_property (gobject_class, PROP_PIXEL_ASPECT_RATIO,
 127       gst_param_spec_fraction ("pixel-aspect-ratio", "Pixel Aspect Ratio",
 128           "The pixel aspect ratio of the device", 0, 1, G_MAXINT, 1, 1, 1,
 129           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 130
 131   gst_element_class_set_metadata (element_class, "Vulkan video sink",
 132       "Sink/Video", "A videosink based on OpenGL",
 133       "Matthew Waters <matthew@centricular.com>");
 134
 135   gst_element_class_add_static_pad_template (element_class,
 136       &gst_vulkan_sink_template);
 137
 138   gobject_class->finalize = gst_vulkan_sink_finalize;
 139
 140   gstelement_class->change_state = gst_vulkan_sink_change_state;
 141   gstelement_class->set_context = gst_vulkan_sink_set_context;
 142   gstbasesink_class->query = GST_DEBUG_FUNCPTR (gst_vulkan_sink_query);
 143   gstbasesink_class->set_caps = gst_vulkan_sink_set_caps;
 144   gstbasesink_class->get_caps = gst_vulkan_sink_get_caps;
 145   gstbasesink_class->get_times = gst_vulkan_sink_get_times;
 146   gstbasesink_class->prepare = gst_vulkan_sink_prepare;
 147
 148   gstvideosink_class->show_frame =
 149       GST_DEBUG_FUNCPTR (gst_vulkan_sink_show_frame);
 150 }
 151
 152 static void
 153 gst_vulkan_sink_init (GstVulkanSink * vk_sink)
 154 {
 155   vk_sink->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
 156   vk_sink->par_n = DEFAULT_PIXEL_ASPECT_RATIO_N;
 157   vk_sink->par_d = DEFAULT_PIXEL_ASPECT_RATIO_D;
 158
 159 //  g_mutex_init (&vk_sink->drawing_lock);
 160 }
 161
 162 static void
 163 gst_vulkan_sink_finalize (GObject * object)
 164 {
 165 //  GstVulkanSink *vk_sink = GST_VULKAN_SINK (object);
 166 //  g_mutex_clear (&vk_sink->drawing_lock);
 167
 168 //  GST_DEBUG ("finalized");
 169   G_OBJECT_CLASS (parent_class)->finalize (object);
 170 }
 171
 172 static void
 173 gst_vulkan_sink_set_property (GObject * object, guint prop_id,
 174     const GValue * value, GParamSpec * pspec)
 175 {
 176   GstVulkanSink *vk_sink = GST_VULKAN_SINK (object);
 177
 178   switch (prop_id) {
 179     case PROP_FORCE_ASPECT_RATIO:
 180       vk_sink->force_aspect_ratio = g_value_get_boolean (value);
 181       break;
 182     case PROP_PIXEL_ASPECT_RATIO:
 183       vk_sink->par_n = gst_value_get_fraction_numerator (value);
 184       vk_sink->par_d = gst_value_get_fraction_denominator (value);
 185       break;
 186     default:
 187       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 188       break;
 189   }
 190 }
 191
 192 static void
 193 gst_vulkan_sink_get_property (GObject * object, guint prop_id,
 194     GValue * value, GParamSpec * pspec)
 195 {
 196   GstVulkanSink *vk_sink = GST_VULKAN_SINK (object);
 197
 198   switch (prop_id) {
 199     case PROP_FORCE_ASPECT_RATIO:
 200       g_value_set_boolean (value, vk_sink->force_aspect_ratio);
 201       break;
 202     case PROP_PIXEL_ASPECT_RATIO:
 203       gst_value_set_fraction (value, vk_sink->par_n, vk_sink->par_d);
 204       break;
 205     default:
 206       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 207       break;
 208   }
 209 }
 210
 211 static gboolean
 212 gst_vulkan_sink_query (GstBaseSink * bsink, GstQuery * query)
 213 {
 214   GstVulkanSink *vk_sink = GST_VULKAN_SINK (bsink);
 215
 216   switch (GST_QUERY_TYPE (query)) {
 217     case GST_QUERY_CONTEXT:{
 218       if (gst_vulkan_handle_context_query (GST_ELEMENT (vk_sink), query,
 219               &vk_sink->display, &vk_sink->instance, &vk_sink->device))
 220         return TRUE;
 221
 222       break;
 223     }
 224     default:
 225       break;
 226   }
 227
 228   return GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
 229 }
 230
 231 static void
 232 gst_vulkan_sink_set_context (GstElement * element, GstContext * context)
 233 {
 234   GstVulkanSink *vk_sink = GST_VULKAN_SINK (element);
 235
 236   gst_vulkan_handle_set_context (element, context, &vk_sink->display,
 237       &vk_sink->instance);
 238
 239   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 240 }
 241
 242 static GstStateChangeReturn
 243 gst_vulkan_sink_change_state (GstElement * element, GstStateChange transition)
 244 {
 245   GstVulkanSink *vk_sink = GST_VULKAN_SINK (element);
 246   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 247   GError *error = NULL;
 248
 249   GST_DEBUG ("changing state: %s => %s",
 250       gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
 251       gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
 252
 253   switch (transition) {
 254     case GST_STATE_CHANGE_NULL_TO_READY:
 255       if (!gst_vulkan_ensure_element_data (element, &vk_sink->display,
 256               &vk_sink->instance)) {
 257         GST_ELEMENT_ERROR (vk_sink, RESOURCE, NOT_FOUND,
 258             ("Failed to retrieve vulkan instance/display"), (NULL));
 259         return GST_STATE_CHANGE_FAILURE;
 260       }
 261
 262       if (!(vk_sink->device =
 263               gst_vulkan_instance_create_device (vk_sink->instance, &error))) {
 264         GST_ELEMENT_ERROR (vk_sink, RESOURCE, NOT_FOUND,
 265             ("Failed to create vulkan device"), ("%s", error->message));
 266         g_clear_error (&error);
 267         return GST_STATE_CHANGE_FAILURE;
 268       }
 269
 270       /* FIXME: this probably doesn't need to be so early in the setup process */
 271       if (!(vk_sink->window =
 272               gst_vulkan_display_create_window (vk_sink->display))) {
 273         GST_ELEMENT_ERROR (vk_sink, RESOURCE, NOT_FOUND,
 274             ("Failed to create a window"), (NULL));
 275         return GST_STATE_CHANGE_FAILURE;
 276       }
 277
 278       if (!vk_sink->set_window_handle)
 279         gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (vk_sink));
 280
 281       if (vk_sink->set_window_handle)
 282         gst_vulkan_window_set_window_handle (vk_sink->window,
 283             vk_sink->set_window_handle);
 284
 285       if (!gst_vulkan_window_open (vk_sink->window, &error)) {
 286         GST_ELEMENT_ERROR (vk_sink, RESOURCE, NOT_FOUND,
 287             ("Failed to open window"), ("%s", error->message));
 288         g_clear_error (&error);
 289         return GST_STATE_CHANGE_FAILURE;
 290       }
 291
 292       if (!(vk_sink->swapper =
 293               gst_vulkan_swapper_new (vk_sink->device, vk_sink->window))) {
 294         GST_ELEMENT_ERROR (vk_sink, RESOURCE, NOT_FOUND,
 295             ("Failed to create a swapper"), (NULL));
 296         return GST_STATE_CHANGE_FAILURE;
 297       }
 298       break;
 299     case GST_STATE_CHANGE_READY_TO_PAUSED:
 300       break;
 301     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 302       break;
 303     default:
 304       break;
 305   }
 306
 307   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 308   if (ret == GST_STATE_CHANGE_FAILURE)
 309     return ret;
 310
 311   switch (transition) {
 312     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 313       break;
 314     case GST_STATE_CHANGE_PAUSED_TO_READY:
 315       break;
 316     case GST_STATE_CHANGE_READY_TO_NULL:
 317       if (vk_sink->swapper)
 318         gst_object_unref (vk_sink->swapper);
 319       vk_sink->swapper = NULL;
 320       if (vk_sink->display)
 321         gst_object_unref (vk_sink->display);
 322       vk_sink->display = NULL;
 323       if (vk_sink->window) {
 324         gst_vulkan_window_close (vk_sink->window);
 325         gst_object_unref (vk_sink->window);
 326       }
 327       vk_sink->window = NULL;
 328       if (vk_sink->device)
 329         gst_object_unref (vk_sink->device);
 330       vk_sink->device = NULL;
 331       if (vk_sink->instance)
 332         gst_object_unref (vk_sink->instance);
 333       vk_sink->instance = NULL;
 334       break;
 335     default:
 336       break;
 337   }
 338
 339   return ret;
 340 }
 341
 342 static void
 343 gst_vulkan_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
 344     GstClockTime * start, GstClockTime * end)
 345 {
 346   GstVulkanSink *vk_sink = GST_VULKAN_SINK (bsink);
 347
 348   if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
 349     *start = GST_BUFFER_TIMESTAMP (buf);
 350     if (GST_BUFFER_DURATION_IS_VALID (buf))
 351       *end = *start + GST_BUFFER_DURATION (buf);
 352     else {
 353       if (GST_VIDEO_INFO_FPS_N (&vk_sink->v_info) > 0) {
 354         *end = *start +
 355             gst_util_uint64_scale_int (GST_SECOND,
 356             GST_VIDEO_INFO_FPS_D (&vk_sink->v_info),
 357             GST_VIDEO_INFO_FPS_N (&vk_sink->v_info));
 358       }
 359     }
 360   }
 361 }
 362
 363 static GstCaps *
 364 gst_vulkan_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
 365 {
 366   GstVulkanSink *vk_sink = GST_VULKAN_SINK (bsink);
 367   GstCaps *tmp = NULL;
 368   GstCaps *result = NULL;
 369   GError *error = NULL;
 370
 371   if (vk_sink->swapper) {
 372     if (!(result =
 373             gst_vulkan_swapper_get_supported_caps (vk_sink->swapper, &error))) {
 374       GST_ELEMENT_ERROR (bsink, RESOURCE, NOT_FOUND, ("%s", error->message),
 375           (NULL));
 376       g_clear_error (&error);
 377       return NULL;
 378     }
 379     return result;
 380   }
 381
 382   tmp = gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD (bsink));
 383
 384   if (filter) {
 385     GST_DEBUG_OBJECT (bsink, "intersecting with filter caps %" GST_PTR_FORMAT,
 386         filter);
 387
 388     result = gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
 389     gst_caps_unref (tmp);
 390   } else {
 391     result = tmp;
 392   }
 393
 394   GST_DEBUG_OBJECT (bsink, "returning caps: %" GST_PTR_FORMAT, result);
 395
 396   return result;
 397 }
 398
 399 static gboolean
 400 _configure_display_from_info (GstVulkanSink * vk_sink, GstVideoInfo * vinfo)
 401 {
 402   guint display_ratio_num, display_ratio_den;
 403   gint display_par_n, display_par_d;
 404   gint par_n, par_d;
 405   gint width, height;
 406   gboolean ok;
 407
 408   width = GST_VIDEO_INFO_WIDTH (vinfo);
 409   height = GST_VIDEO_INFO_HEIGHT (vinfo);
 410
 411   par_n = GST_VIDEO_INFO_PAR_N (vinfo);
 412   par_d = GST_VIDEO_INFO_PAR_D (vinfo);
 413
 414   if (!par_n)
 415     par_n = 1;
 416
 417   /* get display's PAR */
 418   if (vk_sink->par_n != 0 && vk_sink->par_d != 0) {
 419     display_par_n = vk_sink->par_n;
 420     display_par_d = vk_sink->par_d;
 421   } else {
 422     display_par_n = 1;
 423     display_par_d = 1;
 424   }
 425
 426   ok = gst_video_calculate_display_ratio (&display_ratio_num,
 427       &display_ratio_den, width, height, par_n, par_d, display_par_n,
 428       display_par_d);
 429
 430   if (!ok)
 431     return FALSE;
 432
 433   GST_TRACE ("PAR: %u/%u DAR:%u/%u", par_n, par_d, display_par_n,
 434       display_par_d);
 435
 436   if (height % display_ratio_den == 0) {
 437     GST_DEBUG ("keeping video height");
 438     GST_VIDEO_SINK_WIDTH (vk_sink) = (guint)
 439         gst_util_uint64_scale_int (height, display_ratio_num,
 440         display_ratio_den);
 441     GST_VIDEO_SINK_HEIGHT (vk_sink) = height;
 442   } else if (width % display_ratio_num == 0) {
 443     GST_DEBUG ("keeping video width");
 444     GST_VIDEO_SINK_WIDTH (vk_sink) = width;
 445     GST_VIDEO_SINK_HEIGHT (vk_sink) = (guint)
 446         gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num);
 447   } else {
 448     GST_DEBUG ("approximating while keeping video height");
 449     GST_VIDEO_SINK_WIDTH (vk_sink) = (guint)
 450         gst_util_uint64_scale_int (height, display_ratio_num,
 451         display_ratio_den);
 452     GST_VIDEO_SINK_HEIGHT (vk_sink) = height;
 453   }
 454   GST_DEBUG ("scaling to %dx%d", GST_VIDEO_SINK_WIDTH (vk_sink),
 455       GST_VIDEO_SINK_HEIGHT (vk_sink));
 456
 457   return TRUE;
 458 }
 459
 460 static gboolean
 461 gst_vulkan_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
 462 {
 463   GstVulkanSink *vk_sink = GST_VULKAN_SINK (bsink);
 464   GError *error = NULL;
 465   GstVideoInfo v_info;
 466
 467   GST_DEBUG_OBJECT (bsink, "set caps with %" GST_PTR_FORMAT, caps);
 468
 469   if (!gst_video_info_from_caps (&v_info, caps))
 470     return FALSE;
 471
 472   if (!_configure_display_from_info (vk_sink, &v_info))
 473     return FALSE;
 474
 475   if (!gst_vulkan_swapper_set_caps (vk_sink->swapper, caps, &error)) {
 476     GST_ELEMENT_ERROR (vk_sink, RESOURCE, NOT_FOUND,
 477         ("Failed to configure caps"), ("%s", error->message));
 478     g_clear_error (&error);
 479     return FALSE;
 480   }
 481
 482   vk_sink->v_info = v_info;
 483
 484   return TRUE;
 485 }
 486
 487 static GstFlowReturn
 488 gst_vulkan_sink_prepare (GstBaseSink * bsink, GstBuffer * buf)
 489 {
 490   GstVulkanSink *vk_sink = GST_VULKAN_SINK (bsink);
 491
 492   GST_TRACE_OBJECT (vk_sink, "preparing buffer %" GST_PTR_FORMAT, buf);
 493
 494   if (GST_VIDEO_SINK_WIDTH (vk_sink) < 1 || GST_VIDEO_SINK_HEIGHT (vk_sink) < 1) {
 495     return GST_FLOW_NOT_NEGOTIATED;
 496   }
 497
 498   return GST_FLOW_OK;
 499 }
 500
 501 static GstFlowReturn
 502 gst_vulkan_sink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
 503 {
 504   GstVulkanSink *vk_sink = GST_VULKAN_SINK (vsink);
 505   GError *error = NULL;
 506
 507   GST_TRACE_OBJECT (vk_sink, "rendering buffer %" GST_PTR_FORMAT, buf);
 508
 509   if (!gst_vulkan_swapper_render_buffer (vk_sink->swapper, buf, &error)) {
 510     GST_ELEMENT_ERROR (vk_sink, RESOURCE, NOT_FOUND,
 511         ("Failed to render buffer"), ("%s", error->message));
 512     g_clear_error (&error);
 513     return GST_FLOW_ERROR;
 514   }
 515
 516   return GST_FLOW_OK;
 517 }
 518
 519 static void
 520 gst_vulkan_sink_set_window_handle (GstVideoOverlay * voverlay, guintptr handle)
 521 {
 522   GstVulkanSink *vk_sink = GST_VULKAN_SINK (voverlay);
 523
 524   vk_sink->set_window_handle = handle;
 525 }
 526
 527 static void
 528 gst_vulkan_sink_video_overlay_init (GstVideoOverlayInterface * iface)
 529 {
 530   iface->set_window_handle = gst_vulkan_sink_set_window_handle;
 531 }