subprojects/gst-plugins-bad/sys/d3d11/gstd3d11videosink.cpp

   1 /* GStreamer
   2  * Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.com>
   3  * Copyright (C) 2020 Seungha Yang <seungha@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-d3d11videosink
  23  * @title: d3d11videosink
  24  *
  25  * Direct3D11 based video render element
  26  *
  27  * ## Example launch line
  28  * ```
  29  * gst-launch-1.0 videotestsrc ! d3d11upload ! d3d11videosink
  30  * ```
  31  * This pipeline will display test video stream on screen via d3d11videosink
  32  *
  33  * Since: 1.18
  34  *
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include "gstd3d11videosink.h"
  42 #include "gstd3d11pluginutils.h"
  43 #include <string>
  44
  45 #if GST_D3D11_WINAPI_APP
  46 #include "gstd3d11window_corewindow.h"
  47 #include "gstd3d11window_swapchainpanel.h"
  48 #endif
  49 #if (!GST_D3D11_WINAPI_ONLY_APP)
  50 #include "gstd3d11window_win32.h"
  51 #endif
  52 #include "gstd3d11window_dummy.h"
  53
  54 enum
  55 {
  56   PROP_0,
  57   PROP_ADAPTER,
  58   PROP_FORCE_ASPECT_RATIO,
  59   PROP_ENABLE_NAVIGATION_EVENTS,
  60   PROP_FULLSCREEN_TOGGLE_MODE,
  61   PROP_FULLSCREEN,
  62   PROP_DRAW_ON_SHARED_TEXTURE,
  63   PROP_ROTATE_METHOD,
  64 };
  65
  66 #define DEFAULT_ADAPTER                   -1
  67 #define DEFAULT_FORCE_ASPECT_RATIO        TRUE
  68 #define DEFAULT_ENABLE_NAVIGATION_EVENTS  TRUE
  69 #define DEFAULT_FULLSCREEN_TOGGLE_MODE    GST_D3D11_WINDOW_FULLSCREEN_TOGGLE_MODE_NONE
  70 #define DEFAULT_FULLSCREEN                FALSE
  71 #define DEFAULT_DRAW_ON_SHARED_TEXTURE    FALSE
  72
  73 enum
  74 {
  75   /* signals */
  76   SIGNAL_BEGIN_DRAW,
  77
  78   /* actions */
  79   SIGNAL_DRAW,
  80
  81   LAST_SIGNAL
  82 };
  83
  84 static guint gst_d3d11_video_sink_signals[LAST_SIGNAL] = { 0, };
  85
  86 static GstStaticCaps pad_template_caps =
  87     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  88     (GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY, GST_D3D11_SINK_FORMATS) "; "
  89     GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  90     (GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY ","
  91         GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
  92         GST_D3D11_SINK_FORMATS) ";"
  93     GST_VIDEO_CAPS_MAKE (GST_D3D11_SINK_FORMATS) "; "
  94     GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  95     (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY ","
  96         GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
  97         GST_D3D11_SINK_FORMATS));
  98
  99 GST_DEBUG_CATEGORY (d3d11_video_sink_debug);
 100 #define GST_CAT_DEFAULT d3d11_video_sink_debug
 101
 102 struct _GstD3D11VideoSink
 103 {
 104   GstVideoSink parent;
 105   GstD3D11Device *device;
 106   GstD3D11Window *window;
 107   gint video_width;
 108   gint video_height;
 109
 110   GstVideoInfo info;
 111
 112   guintptr window_id;
 113
 114   gboolean caps_updated;
 115
 116   /* properties */
 117   gint adapter;
 118   gboolean force_aspect_ratio;
 119   gboolean enable_navigation_events;
 120   GstD3D11WindowFullscreenToggleMode fullscreen_toggle_mode;
 121   gboolean fullscreen;
 122   gboolean draw_on_shared_texture;
 123
 124   /* saved render rectangle until we have a window */
 125   GstVideoRectangle render_rect;
 126   gboolean pending_render_rect;
 127
 128   /* For drawing on user texture */
 129   gboolean drawing;
 130   GstBuffer *current_buffer;
 131   GRecMutex lock;
 132
 133   gchar *title;
 134
 135   /* method configured via property */
 136   GstVideoOrientationMethod method;
 137   /* method parsed from tag */
 138   GstVideoOrientationMethod tag_method;
 139   /* method currently selected based on "method" and "tag_method" */
 140   GstVideoOrientationMethod selected_method;
 141 };
 142
 143 #define GST_D3D11_VIDEO_SINK_GET_LOCK(d) (&(GST_D3D11_VIDEO_SINK_CAST(d)->lock))
 144 #define GST_D3D11_VIDEO_SINK_LOCK(d) G_STMT_START { \
 145     GST_TRACE_OBJECT (d, "Locking from thread %p", g_thread_self()); \
 146     g_rec_mutex_lock (GST_D3D11_VIDEO_SINK_GET_LOCK (d)); \
 147     GST_TRACE_OBJECT (d, "Locked from thread %p", g_thread_self()); \
 148  } G_STMT_END
 149
 150 #define GST_D3D11_VIDEO_SINK_UNLOCK(d) G_STMT_START { \
 151     GST_TRACE_OBJECT (d, "Unlocking from thread %p", g_thread_self()); \
 152     g_rec_mutex_unlock (GST_D3D11_VIDEO_SINK_GET_LOCK (d)); \
 153  } G_STMT_END
 154
 155 static void gst_d3d11_videosink_set_property (GObject * object, guint prop_id,
 156     const GValue * value, GParamSpec * pspec);
 157 static void gst_d3d11_videosink_get_property (GObject * object, guint prop_id,
 158     GValue * value, GParamSpec * pspec);
 159 static void gst_d3d11_video_sink_finalize (GObject * object);
 160 static gboolean
 161 gst_d3d11_video_sink_draw_action (GstD3D11VideoSink * self,
 162     gpointer shared_handle, guint texture_misc_flags, guint64 acquire_key,
 163     guint64 release_key);
 164
 165 static void
 166 gst_d3d11_video_sink_video_overlay_init (GstVideoOverlayInterface * iface);
 167 static void
 168 gst_d3d11_video_sink_navigation_init (GstNavigationInterface * iface);
 169
 170 static void gst_d3d11_video_sink_set_context (GstElement * element,
 171     GstContext * context);
 172 static GstCaps *gst_d3d11_video_sink_get_caps (GstBaseSink * sink,
 173     GstCaps * filter);
 174 static gboolean gst_d3d11_video_sink_set_caps (GstBaseSink * sink,
 175     GstCaps * caps);
 176
 177 static gboolean gst_d3d11_video_sink_start (GstBaseSink * sink);
 178 static gboolean gst_d3d11_video_sink_stop (GstBaseSink * sink);
 179 static gboolean gst_d3d11_video_sink_propose_allocation (GstBaseSink * sink,
 180     GstQuery * query);
 181 static gboolean gst_d3d11_video_sink_query (GstBaseSink * sink,
 182     GstQuery * query);
 183 static gboolean gst_d3d11_video_sink_unlock (GstBaseSink * sink);
 184 static gboolean gst_d3d11_video_sink_unlock_stop (GstBaseSink * sink);
 185 static gboolean gst_d3d11_video_sink_event (GstBaseSink * sink,
 186     GstEvent * event);
 187 static GstFlowReturn
 188 gst_d3d11_video_sink_show_frame (GstVideoSink * sink, GstBuffer * buf);
 189 static gboolean gst_d3d11_video_sink_prepare_window (GstD3D11VideoSink * self);
 190 static void gst_d3d11_video_sink_set_orientation (GstD3D11VideoSink * self,
 191     GstVideoOrientationMethod method, gboolean from_tag);
 192
 193 #define gst_d3d11_video_sink_parent_class parent_class
 194 G_DEFINE_TYPE_WITH_CODE (GstD3D11VideoSink, gst_d3d11_video_sink,
 195     GST_TYPE_VIDEO_SINK,
 196     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
 197         gst_d3d11_video_sink_video_overlay_init);
 198     G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
 199         gst_d3d11_video_sink_navigation_init);
 200     GST_DEBUG_CATEGORY_INIT (d3d11_video_sink_debug,
 201         "d3d11videosink", 0, "Direct3D11 Video Sink"));
 202
 203 static void
 204 gst_d3d11_video_sink_class_init (GstD3D11VideoSinkClass * klass)
 205 {
 206   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 207   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 208   GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS (klass);
 209   GstVideoSinkClass *videosink_class = GST_VIDEO_SINK_CLASS (klass);
 210   GstCaps *caps;
 211
 212   gobject_class->set_property = gst_d3d11_videosink_set_property;
 213   gobject_class->get_property = gst_d3d11_videosink_get_property;
 214   gobject_class->finalize = gst_d3d11_video_sink_finalize;
 215
 216   g_object_class_install_property (gobject_class, PROP_ADAPTER,
 217       g_param_spec_int ("adapter", "Adapter",
 218           "Adapter index for creating device (-1 for default)",
 219           -1, G_MAXINT32, DEFAULT_ADAPTER,
 220           (GParamFlags) (G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
 221               G_PARAM_STATIC_STRINGS)));
 222
 223   g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO,
 224       g_param_spec_boolean ("force-aspect-ratio",
 225           "Force aspect ratio",
 226           "When enabled, scaling will respect original aspect ratio",
 227           DEFAULT_FORCE_ASPECT_RATIO,
 228           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 229
 230   g_object_class_install_property (gobject_class, PROP_ENABLE_NAVIGATION_EVENTS,
 231       g_param_spec_boolean ("enable-navigation-events",
 232           "Enable navigation events",
 233           "When enabled, navigation events are sent upstream",
 234           DEFAULT_ENABLE_NAVIGATION_EVENTS,
 235           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 236
 237   g_object_class_install_property (gobject_class, PROP_FULLSCREEN_TOGGLE_MODE,
 238       g_param_spec_flags ("fullscreen-toggle-mode",
 239           "Full screen toggle mode",
 240           "Full screen toggle mode used to trigger fullscreen mode change",
 241           GST_D3D11_WINDOW_TOGGLE_MODE_GET_TYPE, DEFAULT_FULLSCREEN_TOGGLE_MODE,
 242           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 243
 244   g_object_class_install_property (gobject_class, PROP_FULLSCREEN,
 245       g_param_spec_boolean ("fullscreen",
 246           "fullscreen",
 247           "Ignored when \"fullscreen-toggle-mode\" does not include \"property\"",
 248           DEFAULT_FULLSCREEN,
 249           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 250
 251   /**
 252    * GstD3D11VideoSink:draw-on-shared-texture:
 253    *
 254    * Instruct the sink to draw on a shared texture provided by user.
 255    * User must watch #d3d11videosink::begin-draw signal and should call
 256    * #d3d11videosink::draw method on the #d3d11videosink::begin-draw
 257    * signal handler.
 258    *
 259    * Currently supported formats for user texture are:
 260    * - DXGI_FORMAT_R8G8B8A8_UNORM
 261    * - DXGI_FORMAT_B8G8R8A8_UNORM
 262    * - DXGI_FORMAT_R10G10B10A2_UNORM
 263    *
 264    * Since: 1.20
 265    */
 266   g_object_class_install_property (gobject_class, PROP_DRAW_ON_SHARED_TEXTURE,
 267       g_param_spec_boolean ("draw-on-shared-texture",
 268           "Draw on shared texture",
 269           "Draw on user provided shared texture instead of window. "
 270           "When enabled, user can pass application's own texture to sink "
 271           "by using \"draw\" action signal on \"begin-draw\" signal handler, "
 272           "so that sink can draw video data on application's texture. "
 273           "Supported texture formats for user texture are "
 274           "DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, and "
 275           "DXGI_FORMAT_R10G10B10A2_UNORM.",
 276           DEFAULT_DRAW_ON_SHARED_TEXTURE,
 277           (GParamFlags) (G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
 278               G_PARAM_STATIC_STRINGS)));
 279
 280   /**
 281    * GstD3D11VideoSink:rotate-method:
 282    *
 283    * Video rotation/flip method to use
 284    *
 285    * Since: 1.22
 286    */
 287   g_object_class_install_property (gobject_class, PROP_ROTATE_METHOD,
 288       g_param_spec_enum ("rotate-method", "Rotate Method",
 289           "Rotate method to use",
 290           GST_TYPE_VIDEO_ORIENTATION_METHOD, GST_VIDEO_ORIENTATION_IDENTITY,
 291           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 292
 293   /**
 294    * GstD3D11VideoSink::begin-draw:
 295    * @videosink: the #d3d11videosink
 296    *
 297    * Emitted when sink has a texture to draw. Application needs to invoke
 298    * #d3d11videosink::draw action signal before returning from
 299    * #d3d11videosink::begin-draw signal handler.
 300    *
 301    * Since: 1.20
 302    */
 303   gst_d3d11_video_sink_signals[SIGNAL_BEGIN_DRAW] =
 304       g_signal_new ("begin-draw", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 305       G_STRUCT_OFFSET (GstD3D11VideoSinkClass, begin_draw),
 306       NULL, NULL, NULL, G_TYPE_NONE, 0, G_TYPE_NONE);
 307
 308   /**
 309    * GstD3D11VideoSink::draw:
 310    * @videosink: the #d3d11videosink
 311    * @shard_handle: a pointer to HANDLE
 312    * @texture_misc_flags: a D3D11_RESOURCE_MISC_FLAG value
 313    * @acquire_key: a key value used for IDXGIKeyedMutex::AcquireSync
 314    * @release_key: a key value used for IDXGIKeyedMutex::ReleaseSync
 315    *
 316    * Draws on a shared texture. @shard_handle must be a valid pointer to
 317    * a HANDLE which was obtained via IDXGIResource::GetSharedHandle or
 318    * IDXGIResource1::CreateSharedHandle.
 319    *
 320    * If the texture was created with D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX flag,
 321    * caller must specify valid @acquire_key and @release_key.
 322    * Otherwise (i.e., created with D3D11_RESOURCE_MISC_SHARED flag),
 323    * @acquire_key and @release_key will be ignored.
 324    *
 325    * Since: 1.20
 326    */
 327   gst_d3d11_video_sink_signals[SIGNAL_DRAW] =
 328       g_signal_new ("draw", G_TYPE_FROM_CLASS (klass),
 329       (GSignalFlags) (G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
 330       G_STRUCT_OFFSET (GstD3D11VideoSinkClass, draw), NULL, NULL, NULL,
 331       G_TYPE_BOOLEAN, 4, G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_UINT64,
 332       G_TYPE_UINT64);
 333
 334   element_class->set_context =
 335       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_set_context);
 336
 337   gst_element_class_set_static_metadata (element_class,
 338       "Direct3D11 video sink", "Sink/Video",
 339       "A Direct3D11 based videosink",
 340       "Seungha Yang <seungha.yang@navercorp.com>");
 341
 342   caps = gst_d3d11_get_updated_template_caps (&pad_template_caps);
 343   gst_element_class_add_pad_template (element_class,
 344       gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps));
 345   gst_caps_unref (caps);
 346
 347   basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_get_caps);
 348   basesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_set_caps);
 349   basesink_class->start = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_start);
 350   basesink_class->stop = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_stop);
 351   basesink_class->propose_allocation =
 352       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_propose_allocation);
 353   basesink_class->query = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_query);
 354   basesink_class->unlock = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_unlock);
 355   basesink_class->unlock_stop =
 356       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_unlock_stop);
 357   basesink_class->event = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_event);
 358
 359   videosink_class->show_frame =
 360       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_show_frame);
 361
 362   klass->draw = gst_d3d11_video_sink_draw_action;
 363
 364   gst_type_mark_as_plugin_api (GST_D3D11_WINDOW_TOGGLE_MODE_GET_TYPE,
 365       (GstPluginAPIFlags) 0);
 366 }
 367
 368 static void
 369 gst_d3d11_video_sink_init (GstD3D11VideoSink * self)
 370 {
 371   self->adapter = DEFAULT_ADAPTER;
 372   self->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
 373   self->enable_navigation_events = DEFAULT_ENABLE_NAVIGATION_EVENTS;
 374   self->fullscreen_toggle_mode = DEFAULT_FULLSCREEN_TOGGLE_MODE;
 375   self->fullscreen = DEFAULT_FULLSCREEN;
 376   self->draw_on_shared_texture = DEFAULT_DRAW_ON_SHARED_TEXTURE;
 377
 378   g_rec_mutex_init (&self->lock);
 379 }
 380
 381 static void
 382 gst_d3d11_videosink_set_property (GObject * object, guint prop_id,
 383     const GValue * value, GParamSpec * pspec)
 384 {
 385   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (object);
 386
 387   GST_D3D11_VIDEO_SINK_LOCK (self);
 388   switch (prop_id) {
 389     case PROP_ADAPTER:
 390       self->adapter = g_value_get_int (value);
 391       break;
 392     case PROP_FORCE_ASPECT_RATIO:
 393       self->force_aspect_ratio = g_value_get_boolean (value);
 394       if (self->window)
 395         g_object_set (self->window,
 396             "force-aspect-ratio", self->force_aspect_ratio, NULL);
 397       break;
 398     case PROP_ENABLE_NAVIGATION_EVENTS:
 399       self->enable_navigation_events = g_value_get_boolean (value);
 400       if (self->window) {
 401         g_object_set (self->window,
 402             "enable-navigation-events", self->enable_navigation_events, NULL);
 403       }
 404       break;
 405     case PROP_FULLSCREEN_TOGGLE_MODE:
 406       self->fullscreen_toggle_mode =
 407           (GstD3D11WindowFullscreenToggleMode) g_value_get_flags (value);
 408       if (self->window) {
 409         g_object_set (self->window,
 410             "fullscreen-toggle-mode", self->fullscreen_toggle_mode, NULL);
 411       }
 412       break;
 413     case PROP_FULLSCREEN:
 414       self->fullscreen = g_value_get_boolean (value);
 415       if (self->window) {
 416         g_object_set (self->window, "fullscreen", self->fullscreen, NULL);
 417       }
 418       break;
 419     case PROP_DRAW_ON_SHARED_TEXTURE:
 420       self->draw_on_shared_texture = g_value_get_boolean (value);
 421       break;
 422     case PROP_ROTATE_METHOD:
 423       gst_d3d11_video_sink_set_orientation (self,
 424           (GstVideoOrientationMethod) g_value_get_enum (value), FALSE);
 425       break;
 426     default:
 427       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 428       break;
 429   }
 430   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 431 }
 432
 433 static void
 434 gst_d3d11_videosink_get_property (GObject * object, guint prop_id,
 435     GValue * value, GParamSpec * pspec)
 436 {
 437   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (object);
 438
 439   GST_D3D11_VIDEO_SINK_LOCK (self);
 440   switch (prop_id) {
 441     case PROP_ADAPTER:
 442       g_value_set_int (value, self->adapter);
 443       break;
 444     case PROP_FORCE_ASPECT_RATIO:
 445       g_value_set_boolean (value, self->force_aspect_ratio);
 446       break;
 447     case PROP_ENABLE_NAVIGATION_EVENTS:
 448       g_value_set_boolean (value, self->enable_navigation_events);
 449       break;
 450     case PROP_FULLSCREEN_TOGGLE_MODE:
 451       g_value_set_flags (value, self->fullscreen_toggle_mode);
 452       break;
 453     case PROP_FULLSCREEN:
 454       if (self->window) {
 455         g_object_get_property (G_OBJECT (self->window), pspec->name, value);
 456       } else {
 457         g_value_set_boolean (value, self->fullscreen);
 458       }
 459       break;
 460     case PROP_DRAW_ON_SHARED_TEXTURE:
 461       g_value_set_boolean (value, self->draw_on_shared_texture);
 462       break;
 463     case PROP_ROTATE_METHOD:
 464       g_value_set_enum (value, self->method);
 465       break;
 466     default:
 467       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 468       break;
 469   }
 470   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 471 }
 472
 473 static void
 474 gst_d3d11_video_sink_finalize (GObject * object)
 475 {
 476   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (object);
 477
 478   g_rec_mutex_clear (&self->lock);
 479   g_free (self->title);
 480
 481   G_OBJECT_CLASS (parent_class)->finalize (object);
 482 }
 483
 484 static void
 485 gst_d3d11_video_sink_set_context (GstElement * element, GstContext * context)
 486 {
 487   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (element);
 488
 489   gst_d3d11_handle_set_context (element, context, self->adapter, &self->device);
 490
 491   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 492 }
 493
 494 static GstCaps *
 495 gst_d3d11_video_sink_get_caps (GstBaseSink * sink, GstCaps * filter)
 496 {
 497   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 498   GstCaps *caps = NULL;
 499
 500   caps = gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (sink));
 501
 502   if (self->device) {
 503     gboolean is_hardware = FALSE;
 504
 505     g_object_get (self->device, "hardware", &is_hardware, NULL);
 506
 507     /* In case of WARP device, conversion via shader would be inefficient than
 508      * upstream videoconvert. Allow native formats in this case */
 509     if (!is_hardware) {
 510       GValue format_list = G_VALUE_INIT;
 511       GValue format = G_VALUE_INIT;
 512
 513       g_value_init (&format_list, GST_TYPE_LIST);
 514       g_value_init (&format, G_TYPE_STRING);
 515
 516       g_value_set_string (&format, "RGBA");
 517       gst_value_list_append_and_take_value (&format_list, &format);
 518
 519       format = G_VALUE_INIT;
 520       g_value_init (&format, G_TYPE_STRING);
 521       g_value_set_string (&format, "BGRA");
 522       gst_value_list_append_and_take_value (&format_list, &format);
 523
 524       caps = gst_caps_make_writable (caps);
 525       gst_caps_set_value (caps, "format", &format_list);
 526       g_value_unset (&format_list);
 527     }
 528   }
 529
 530   if (filter) {
 531     GstCaps *isect;
 532     isect = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 533     gst_caps_unref (caps);
 534     caps = isect;
 535   }
 536
 537   return caps;
 538 }
 539
 540 static gboolean
 541 gst_d3d11_video_sink_set_caps (GstBaseSink * sink, GstCaps * caps)
 542 {
 543   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 544
 545   GST_DEBUG_OBJECT (self, "set caps %" GST_PTR_FORMAT, caps);
 546
 547   /* We will update window on show_frame() */
 548   self->caps_updated = TRUE;
 549
 550   return TRUE;
 551 }
 552
 553 static gboolean
 554 gst_d3d11_video_sink_update_window (GstD3D11VideoSink * self, GstCaps * caps)
 555 {
 556   gint video_width, video_height;
 557   gint video_par_n, video_par_d;        /* video's PAR */
 558   gint display_par_n = 1, display_par_d = 1;    /* display's PAR */
 559   guint num, den;
 560   GError *error = NULL;
 561
 562   GST_DEBUG_OBJECT (self, "Updating window with caps %" GST_PTR_FORMAT, caps);
 563
 564   self->caps_updated = FALSE;
 565
 566   GST_D3D11_VIDEO_SINK_LOCK (self);
 567   if (!gst_d3d11_video_sink_prepare_window (self)) {
 568     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 569
 570     GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, (nullptr),
 571         ("Failed to open window."));
 572
 573     return FALSE;
 574   }
 575
 576   if (!gst_video_info_from_caps (&self->info, caps)) {
 577     GST_DEBUG_OBJECT (self,
 578         "Could not locate image format from caps %" GST_PTR_FORMAT, caps);
 579     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 580     return FALSE;
 581   }
 582
 583   video_width = GST_VIDEO_INFO_WIDTH (&self->info);
 584   video_height = GST_VIDEO_INFO_HEIGHT (&self->info);
 585   video_par_n = GST_VIDEO_INFO_PAR_N (&self->info);
 586   video_par_d = GST_VIDEO_INFO_PAR_D (&self->info);
 587
 588   /* get aspect ratio from caps if it's present, and
 589    * convert video width and height to a display width and height
 590    * using wd / hd = wv / hv * PARv / PARd */
 591
 592   if (!gst_video_calculate_display_ratio (&num, &den, video_width,
 593           video_height, video_par_n, video_par_d, display_par_n,
 594           display_par_d)) {
 595     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 596
 597     GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (nullptr),
 598         ("Error calculating the output display ratio of the video."));
 599     return FALSE;
 600   }
 601
 602   GST_DEBUG_OBJECT (self,
 603       "video width/height: %dx%d, calculated display ratio: %d/%d format: %s",
 604       video_width, video_height, num, den,
 605       gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&self->info)));
 606
 607   /* now find a width x height that respects this display ratio.
 608    * prefer those that have one of w/h the same as the incoming video
 609    * using wd / hd = num / den
 610    */
 611
 612   /* start with same height, because of interlaced video
 613    * check hd / den is an integer scale factor, and scale wd with the PAR
 614    */
 615   if (video_height % den == 0) {
 616     GST_DEBUG_OBJECT (self, "keeping video height");
 617     GST_VIDEO_SINK_WIDTH (self) = (guint)
 618         gst_util_uint64_scale_int (video_height, num, den);
 619     GST_VIDEO_SINK_HEIGHT (self) = video_height;
 620   } else if (video_width % num == 0) {
 621     GST_DEBUG_OBJECT (self, "keeping video width");
 622     GST_VIDEO_SINK_WIDTH (self) = video_width;
 623     GST_VIDEO_SINK_HEIGHT (self) = (guint)
 624         gst_util_uint64_scale_int (video_width, den, num);
 625   } else {
 626     GST_DEBUG_OBJECT (self, "approximating while keeping video height");
 627     GST_VIDEO_SINK_WIDTH (self) = (guint)
 628         gst_util_uint64_scale_int (video_height, num, den);
 629     GST_VIDEO_SINK_HEIGHT (self) = video_height;
 630   }
 631
 632   GST_DEBUG_OBJECT (self, "scaling to %dx%d",
 633       GST_VIDEO_SINK_WIDTH (self), GST_VIDEO_SINK_HEIGHT (self));
 634   self->video_width = video_width;
 635   self->video_height = video_height;
 636
 637   if (GST_VIDEO_SINK_WIDTH (self) <= 0 || GST_VIDEO_SINK_HEIGHT (self) <= 0) {
 638     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 639
 640     GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (nullptr),
 641         ("Error calculating the output display ratio of the video."));
 642     return FALSE;
 643   }
 644
 645   if (self->pending_render_rect) {
 646     GstVideoRectangle rect = self->render_rect;
 647
 648     self->pending_render_rect = FALSE;
 649     gst_d3d11_window_set_render_rectangle (self->window, &rect);
 650   }
 651
 652   if (!gst_d3d11_window_prepare (self->window, GST_VIDEO_SINK_WIDTH (self),
 653           GST_VIDEO_SINK_HEIGHT (self), caps, &error)) {
 654     GstMessage *error_msg;
 655
 656     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 657
 658     GST_ERROR_OBJECT (self, "cannot create swapchain");
 659     error_msg = gst_message_new_error (GST_OBJECT_CAST (self),
 660         error, "Failed to prepare d3d11window");
 661     g_clear_error (&error);
 662     gst_element_post_message (GST_ELEMENT (self), error_msg);
 663
 664     return FALSE;
 665   }
 666
 667   if (self->title) {
 668     gst_d3d11_window_set_title (self->window, self->title);
 669     g_clear_pointer (&self->title, g_free);
 670   }
 671
 672   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 673
 674   return TRUE;
 675 }
 676
 677 static void
 678 gst_d3d11_video_sink_key_event (GstD3D11Window * window, const gchar * event,
 679     const gchar * key, GstD3D11VideoSink * self)
 680 {
 681   GstEvent *key_event = NULL;
 682
 683   if (self->enable_navigation_events) {
 684     GST_LOG_OBJECT (self, "send key event %s, key %s", event, key);
 685     if (0 == g_strcmp0 ("key-press", event))
 686       key_event =
 687           gst_navigation_event_new_key_press (key,
 688           GST_NAVIGATION_MODIFIER_NONE);
 689     else if (0 == g_strcmp0 ("key-release", event))
 690       key_event =
 691           gst_navigation_event_new_key_release (key,
 692           GST_NAVIGATION_MODIFIER_NONE);
 693
 694     if (event)
 695       gst_navigation_send_event_simple (GST_NAVIGATION (self), key_event);
 696   }
 697 }
 698
 699 static void
 700 gst_d3d11_video_mouse_key_event (GstD3D11Window * window, const gchar * event,
 701     gint button, gdouble x, gdouble y, GstD3D11VideoSink * self)
 702 {
 703   GstEvent *mouse_event = NULL;
 704
 705   if (self->enable_navigation_events) {
 706     GST_LOG_OBJECT (self,
 707         "send mouse event %s, button %d (%.1f, %.1f)", event, button, x, y);
 708     if (0 == g_strcmp0 ("mouse-button-press", event))
 709       mouse_event =
 710           gst_navigation_event_new_mouse_button_press (button, x, y,
 711           GST_NAVIGATION_MODIFIER_NONE);
 712     else if (0 == g_strcmp0 ("mouse-button-release", event))
 713       mouse_event =
 714           gst_navigation_event_new_mouse_button_release (button, x, y,
 715           GST_NAVIGATION_MODIFIER_NONE);
 716     else if (0 == g_strcmp0 ("mouse-move", event))
 717       mouse_event =
 718           gst_navigation_event_new_mouse_move (x, y,
 719           GST_NAVIGATION_MODIFIER_NONE);
 720
 721     if (event)
 722       gst_navigation_send_event_simple (GST_NAVIGATION (self), mouse_event);
 723   }
 724 }
 725
 726 static gboolean
 727 gst_d3d11_video_sink_start (GstBaseSink * sink)
 728 {
 729   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 730
 731   GST_DEBUG_OBJECT (self, "Start");
 732
 733   if (!gst_d3d11_ensure_element_data (GST_ELEMENT_CAST (self), self->adapter,
 734           &self->device)) {
 735     GST_ERROR_OBJECT (sink, "Cannot create d3d11device");
 736     return FALSE;
 737   }
 738
 739   return TRUE;
 740 }
 741
 742 /* called with lock */
 743 static gboolean
 744 gst_d3d11_video_sink_prepare_window (GstD3D11VideoSink * self)
 745 {
 746   GstD3D11WindowNativeType window_type = GST_D3D11_WINDOW_NATIVE_TYPE_HWND;
 747
 748   if (self->window)
 749     return TRUE;
 750
 751   if (self->draw_on_shared_texture) {
 752     GST_INFO_OBJECT (self,
 753         "Create dummy window for rendering on shared texture");
 754     self->window = gst_d3d11_window_dummy_new (self->device);
 755     goto done;
 756   }
 757
 758   if (!self->window_id)
 759     gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (self));
 760
 761   if (self->window_id) {
 762     window_type =
 763         gst_d3d11_window_get_native_type_from_handle (self->window_id);
 764
 765     if (window_type != GST_D3D11_WINDOW_NATIVE_TYPE_NONE) {
 766       GST_DEBUG_OBJECT (self, "Have window handle %" G_GUINTPTR_FORMAT,
 767           self->window_id);
 768       gst_video_overlay_got_window_handle (GST_VIDEO_OVERLAY (self),
 769           self->window_id);
 770     }
 771   }
 772
 773   GST_DEBUG_OBJECT (self, "Create window (type: %s)",
 774       gst_d3d11_window_get_native_type_to_string (window_type));
 775
 776 #if GST_D3D11_WINAPI_ONLY_APP
 777   if (window_type != GST_D3D11_WINDOW_NATIVE_TYPE_CORE_WINDOW &&
 778       window_type != GST_D3D11_WINDOW_NATIVE_TYPE_SWAP_CHAIN_PANEL) {
 779     GST_ERROR_OBJECT (self, "Overlay handle must be set before READY state");
 780     return FALSE;
 781   }
 782 #endif
 783
 784   switch (window_type) {
 785 #if (!GST_D3D11_WINAPI_ONLY_APP)
 786     case GST_D3D11_WINDOW_NATIVE_TYPE_HWND:
 787       self->window = gst_d3d11_window_win32_new (self->device, self->window_id);
 788       break;
 789 #endif
 790 #if GST_D3D11_WINAPI_APP
 791     case GST_D3D11_WINDOW_NATIVE_TYPE_CORE_WINDOW:
 792       self->window = gst_d3d11_window_core_window_new (self->device,
 793           self->window_id);
 794       break;
 795     case GST_D3D11_WINDOW_NATIVE_TYPE_SWAP_CHAIN_PANEL:
 796       self->window = gst_d3d11_window_swap_chain_panel_new (self->device,
 797           self->window_id);
 798       break;
 799 #endif
 800     default:
 801       break;
 802   }
 803
 804 done:
 805   if (!self->window) {
 806     GST_ERROR_OBJECT (self, "Cannot create d3d11window");
 807     return FALSE;
 808   }
 809
 810   g_object_set (self->window,
 811       "force-aspect-ratio", self->force_aspect_ratio,
 812       "fullscreen-toggle-mode", self->fullscreen_toggle_mode,
 813       "fullscreen", self->fullscreen,
 814       "enable-navigation-events", self->enable_navigation_events, NULL);
 815
 816   gst_d3d11_window_set_orientation (self->window, self->selected_method);
 817
 818   g_signal_connect (self->window, "key-event",
 819       G_CALLBACK (gst_d3d11_video_sink_key_event), self);
 820   g_signal_connect (self->window, "mouse-event",
 821       G_CALLBACK (gst_d3d11_video_mouse_key_event), self);
 822
 823   return TRUE;
 824 }
 825
 826 static gboolean
 827 gst_d3d11_video_sink_stop (GstBaseSink * sink)
 828 {
 829   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 830
 831   GST_DEBUG_OBJECT (self, "Stop");
 832
 833   GST_D3D11_VIDEO_SINK_LOCK (self);
 834   if (self->window)
 835     gst_d3d11_window_unprepare (self->window);
 836
 837   gst_clear_object (&self->window);
 838   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 839
 840   gst_clear_object (&self->device);
 841
 842   g_clear_pointer (&self->title, g_free);
 843
 844   return TRUE;
 845 }
 846
 847 static gboolean
 848 gst_d3d11_video_sink_propose_allocation (GstBaseSink * sink, GstQuery * query)
 849 {
 850   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 851   GstCaps *caps;
 852   GstBufferPool *pool = NULL;
 853   GstVideoInfo info;
 854   guint size;
 855   gboolean need_pool;
 856
 857   if (!self->device)
 858     return FALSE;
 859
 860   gst_query_parse_allocation (query, &caps, &need_pool);
 861
 862   if (caps == NULL)
 863     goto no_caps;
 864
 865   if (!gst_video_info_from_caps (&info, caps))
 866     goto invalid_caps;
 867
 868   /* the normal size of a frame */
 869   size = info.size;
 870
 871   if (need_pool) {
 872     GstCapsFeatures *features;
 873     GstStructure *config;
 874     gboolean is_d3d11 = FALSE;
 875
 876     features = gst_caps_get_features (caps, 0);
 877     if (features
 878         && gst_caps_features_contains (features,
 879             GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY)) {
 880       GST_DEBUG_OBJECT (self, "upstream support d3d11 memory");
 881       pool = gst_d3d11_buffer_pool_new (self->device);
 882       is_d3d11 = TRUE;
 883     } else {
 884       pool = gst_video_buffer_pool_new ();
 885     }
 886
 887     config = gst_buffer_pool_get_config (pool);
 888     gst_buffer_pool_config_add_option (config,
 889         GST_BUFFER_POOL_OPTION_VIDEO_META);
 890     if (!is_d3d11) {
 891       gst_buffer_pool_config_add_option (config,
 892           GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
 893     }
 894
 895     size = GST_VIDEO_INFO_SIZE (&info);
 896     if (is_d3d11) {
 897       GstD3D11AllocationParams *d3d11_params;
 898
 899       d3d11_params =
 900           gst_d3d11_allocation_params_new (self->device,
 901           &info, GST_D3D11_ALLOCATION_FLAG_DEFAULT, D3D11_BIND_SHADER_RESOURCE,
 902           0);
 903
 904       gst_buffer_pool_config_set_d3d11_allocation_params (config, d3d11_params);
 905       gst_d3d11_allocation_params_free (d3d11_params);
 906     }
 907
 908     gst_buffer_pool_config_set_params (config, caps, (guint) size, 2, 0);
 909
 910     if (!gst_buffer_pool_set_config (pool, config)) {
 911       GST_ERROR_OBJECT (pool, "Couldn't set config");
 912       gst_object_unref (pool);
 913
 914       return FALSE;
 915     }
 916
 917     /* d3d11 buffer pool will update buffer size based on allocated texture,
 918      * get size from config again */
 919     config = gst_buffer_pool_get_config (pool);
 920     gst_buffer_pool_config_get_params (config, nullptr, &size, nullptr,
 921         nullptr);
 922     gst_structure_free (config);
 923
 924     if (is_d3d11) {
 925       /* In case of system memory, we will upload video frame to GPU memory,
 926        * (which is copy in any case), so crop meta support for system memory
 927        * is almost pointless */
 928       gst_query_add_allocation_meta (query,
 929           GST_VIDEO_CROP_META_API_TYPE, nullptr);
 930     }
 931   }
 932
 933   /* We need at least 2 buffers because we hold on to the last one for redrawing
 934    * on window-resize event */
 935   gst_query_add_allocation_pool (query, pool, size, 2, 0);
 936   if (pool)
 937     g_object_unref (pool);
 938
 939   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
 940   gst_query_add_allocation_meta (query,
 941       GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, NULL);
 942
 943   return TRUE;
 944
 945   /* ERRORS */
 946 no_caps:
 947   {
 948     GST_WARNING_OBJECT (self, "no caps specified");
 949     return FALSE;
 950   }
 951 invalid_caps:
 952   {
 953     GST_WARNING_OBJECT (self, "invalid caps specified");
 954     return FALSE;
 955   }
 956
 957   return TRUE;
 958 }
 959
 960 static gboolean
 961 gst_d3d11_video_sink_query (GstBaseSink * sink, GstQuery * query)
 962 {
 963   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 964
 965   switch (GST_QUERY_TYPE (query)) {
 966     case GST_QUERY_CONTEXT:
 967       if (gst_d3d11_handle_context_query (GST_ELEMENT (self), query,
 968               self->device)) {
 969         return TRUE;
 970       }
 971       break;
 972     default:
 973       break;
 974   }
 975
 976   return GST_BASE_SINK_CLASS (parent_class)->query (sink, query);
 977 }
 978
 979 static gboolean
 980 gst_d3d11_video_sink_unlock (GstBaseSink * sink)
 981 {
 982   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 983
 984   GST_D3D11_VIDEO_SINK_LOCK (self);
 985   if (self->window)
 986     gst_d3d11_window_unlock (self->window);
 987   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 988
 989   return TRUE;
 990 }
 991
 992 static gboolean
 993 gst_d3d11_video_sink_unlock_stop (GstBaseSink * sink)
 994 {
 995   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 996
 997   GST_D3D11_VIDEO_SINK_LOCK (self);
 998   if (self->window)
 999     gst_d3d11_window_unlock_stop (self->window);
1000   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1001
1002   return TRUE;
1003 }
1004
1005 static gboolean
1006 gst_d3d11_video_sink_event (GstBaseSink * sink, GstEvent * event)
1007 {
1008   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
1009
1010   switch (GST_EVENT_TYPE (event)) {
1011     case GST_EVENT_TAG:{
1012       GstTagList *taglist;
1013       gchar *title = nullptr;
1014       GstVideoOrientationMethod method = GST_VIDEO_ORIENTATION_IDENTITY;
1015
1016       gst_event_parse_tag (event, &taglist);
1017       gst_tag_list_get_string (taglist, GST_TAG_TITLE, &title);
1018
1019       if (title) {
1020         const gchar *app_name = g_get_application_name ();
1021         std::string title_string;
1022
1023         if (app_name) {
1024           title_string = std::string (title) + " : " + std::string (app_name);
1025         } else {
1026           title_string = std::string (title);
1027         }
1028
1029         GST_D3D11_VIDEO_SINK_LOCK (self);
1030         if (self->window) {
1031           gst_d3d11_window_set_title (self->window, title_string.c_str ());
1032         } else {
1033           g_free (self->title);
1034           self->title = g_strdup (title_string.c_str ());
1035         }
1036         GST_D3D11_VIDEO_SINK_UNLOCK (self);
1037
1038         g_free (title);
1039       }
1040
1041       if (gst_video_orientation_from_tag (taglist, &method)) {
1042         GST_D3D11_VIDEO_SINK_LOCK (self);
1043         gst_d3d11_video_sink_set_orientation (self, method, TRUE);
1044         GST_D3D11_VIDEO_SINK_UNLOCK (self);
1045       }
1046       break;
1047     }
1048     default:
1049       break;
1050   }
1051
1052   return GST_BASE_SINK_CLASS (parent_class)->event (sink, event);
1053 }
1054
1055 /* called with lock */
1056 static void
1057 gst_d3d11_video_sink_set_orientation (GstD3D11VideoSink * self,
1058     GstVideoOrientationMethod method, gboolean from_tag)
1059 {
1060   if (method == GST_VIDEO_ORIENTATION_CUSTOM) {
1061     GST_WARNING_OBJECT (self, "Unsupported custom orientation");
1062     return;
1063   }
1064
1065   if (from_tag)
1066     self->tag_method = method;
1067   else
1068     self->method = method;
1069
1070   if (self->method == GST_VIDEO_ORIENTATION_AUTO) {
1071     self->selected_method = self->tag_method;
1072   } else {
1073     self->selected_method = self->method;
1074   }
1075
1076   if (self->window)
1077     gst_d3d11_window_set_orientation (self->window, self->selected_method);
1078 }
1079
1080 static void
1081 gst_d3d11_video_sink_check_device_update (GstD3D11VideoSink * self,
1082     GstBuffer * buf)
1083 {
1084   GstMemory *mem;
1085   GstD3D11Memory *dmem;
1086   gboolean update_device = FALSE;
1087
1088   /* We have configured window already, cannot update device */
1089   if (self->window)
1090     return;
1091
1092   mem = gst_buffer_peek_memory (buf, 0);
1093   if (!gst_is_d3d11_memory (mem))
1094     return;
1095
1096   dmem = GST_D3D11_MEMORY_CAST (mem);
1097   /* Same device, nothing to do */
1098   if (dmem->device == self->device)
1099     return;
1100
1101   if (self->adapter < 0) {
1102     update_device = TRUE;
1103   } else {
1104     guint adapter = 0;
1105
1106     g_object_get (dmem->device, "adapter", &adapter, NULL);
1107     /* The same GPU as what user wanted, update */
1108     if (adapter == (guint) self->adapter)
1109       update_device = TRUE;
1110   }
1111
1112   if (!update_device)
1113     return;
1114
1115   GST_INFO_OBJECT (self, "Updating device %" GST_PTR_FORMAT " -> %"
1116       GST_PTR_FORMAT, self->device, dmem->device);
1117
1118   gst_object_unref (self->device);
1119   self->device = (GstD3D11Device *) gst_object_ref (dmem->device);
1120 }
1121
1122 static GstFlowReturn
1123 gst_d3d11_video_sink_show_frame (GstVideoSink * sink, GstBuffer * buf)
1124 {
1125   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
1126   GstFlowReturn ret = GST_FLOW_OK;
1127
1128   gst_d3d11_video_sink_check_device_update (self, buf);
1129
1130   if (self->caps_updated || !self->window) {
1131     GstCaps *caps = gst_pad_get_current_caps (GST_BASE_SINK_PAD (sink));
1132     gboolean update_ret;
1133
1134     /* shouldn't happen */
1135     if (!caps)
1136       return GST_FLOW_NOT_NEGOTIATED;
1137
1138     update_ret = gst_d3d11_video_sink_update_window (self, caps);
1139     gst_caps_unref (caps);
1140
1141     if (!update_ret)
1142       return GST_FLOW_NOT_NEGOTIATED;
1143   }
1144
1145   gst_d3d11_window_show (self->window);
1146
1147   if (self->draw_on_shared_texture) {
1148     GST_D3D11_VIDEO_SINK_LOCK (self);
1149     self->current_buffer = buf;
1150     self->drawing = TRUE;
1151
1152     GST_LOG_OBJECT (self, "Begin drawing");
1153
1154     /* Application should call draw method on this callback */
1155     g_signal_emit (self, gst_d3d11_video_sink_signals[SIGNAL_BEGIN_DRAW], 0,
1156         NULL);
1157
1158     GST_LOG_OBJECT (self, "End drawing");
1159     self->drawing = FALSE;
1160     self->current_buffer = nullptr;
1161     GST_D3D11_VIDEO_SINK_UNLOCK (self);
1162   } else {
1163     ret = gst_d3d11_window_render (self->window, buf);
1164   }
1165
1166   if (ret == GST_D3D11_WINDOW_FLOW_CLOSED) {
1167     GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
1168         ("Output window was closed"), (NULL));
1169
1170     ret = GST_FLOW_ERROR;
1171   }
1172
1173   return ret;
1174 }
1175
1176 /* VideoOverlay interface */
1177 static void
1178 gst_d3d11_video_sink_set_window_handle (GstVideoOverlay * overlay,
1179     guintptr window_id)
1180 {
1181   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (overlay);
1182
1183   GST_DEBUG ("set window handle %" G_GUINTPTR_FORMAT, window_id);
1184
1185   self->window_id = window_id;
1186 }
1187
1188 static void
1189 gst_d3d11_video_sink_set_render_rectangle (GstVideoOverlay * overlay, gint x,
1190     gint y, gint width, gint height)
1191 {
1192   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (overlay);
1193
1194   GST_DEBUG_OBJECT (self,
1195       "render rect x: %d, y: %d, width: %d, height %d", x, y, width, height);
1196
1197   GST_D3D11_VIDEO_SINK_LOCK (self);
1198   if (self->window) {
1199     GstVideoRectangle rect;
1200
1201     rect.x = x;
1202     rect.y = y;
1203     rect.w = width;
1204     rect.h = height;
1205
1206     self->render_rect = rect;
1207
1208     gst_d3d11_window_set_render_rectangle (self->window, &rect);
1209   } else {
1210     self->render_rect.x = x;
1211     self->render_rect.y = y;
1212     self->render_rect.w = width;
1213     self->render_rect.h = height;
1214     self->pending_render_rect = TRUE;
1215   }
1216
1217   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1218 }
1219
1220 static void
1221 gst_d3d11_video_sink_expose (GstVideoOverlay * overlay)
1222 {
1223   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (overlay);
1224
1225   GST_D3D11_VIDEO_SINK_LOCK (self);
1226   if (self->window && self->window->swap_chain)
1227     gst_d3d11_window_render (self->window, nullptr);
1228   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1229 }
1230
1231 static void
1232 gst_d3d11_video_sink_video_overlay_init (GstVideoOverlayInterface * iface)
1233 {
1234   iface->set_window_handle = gst_d3d11_video_sink_set_window_handle;
1235   iface->set_render_rectangle = gst_d3d11_video_sink_set_render_rectangle;
1236   iface->expose = gst_d3d11_video_sink_expose;
1237 }
1238
1239 /* Navigation interface */
1240 static void
1241 gst_d3d11_video_sink_navigation_send_event (GstNavigation * navigation,
1242     GstEvent * event)
1243 {
1244   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (navigation);
1245
1246   /* TODO: add support for translating native coordinate and video coordinate
1247    * when force-aspect-ratio is set */
1248   if (event) {
1249     gboolean handled;
1250
1251     gst_event_ref (event);
1252     handled = gst_pad_push_event (GST_VIDEO_SINK_PAD (self), event);
1253
1254     if (!handled)
1255       gst_element_post_message (GST_ELEMENT_CAST (self),
1256           gst_navigation_message_new_event (GST_OBJECT_CAST (self), event));
1257
1258     gst_event_unref (event);
1259   }
1260 }
1261
1262 static void
1263 gst_d3d11_video_sink_navigation_init (GstNavigationInterface * iface)
1264 {
1265   iface->send_event_simple = gst_d3d11_video_sink_navigation_send_event;
1266 }
1267
1268 static gboolean
1269 gst_d3d11_video_sink_draw_action (GstD3D11VideoSink * self,
1270     gpointer shared_handle, guint texture_misc_flags,
1271     guint64 acquire_key, guint64 release_key)
1272 {
1273   GstFlowReturn ret;
1274   g_return_val_if_fail (shared_handle != NULL, FALSE);
1275
1276   if (!self->draw_on_shared_texture) {
1277     GST_ERROR_OBJECT (self, "Invalid draw call, we are drawing on window");
1278     return FALSE;
1279   }
1280
1281   if (!shared_handle) {
1282     GST_ERROR_OBJECT (self, "Invalid handle");
1283     return FALSE;
1284   }
1285
1286   GST_D3D11_VIDEO_SINK_LOCK (self);
1287   if (!self->drawing || !self->current_buffer) {
1288     GST_WARNING_OBJECT (self, "Nothing to draw");
1289     GST_D3D11_VIDEO_SINK_UNLOCK (self);
1290     return FALSE;
1291   }
1292
1293   GST_LOG_OBJECT (self, "Drawing on shared handle %p, MiscFlags: 0x%x"
1294       ", acquire key: %" G_GUINT64_FORMAT ", release key: %"
1295       G_GUINT64_FORMAT, shared_handle, texture_misc_flags, acquire_key,
1296       release_key);
1297
1298   ret = gst_d3d11_window_render_on_shared_handle (self->window,
1299       self->current_buffer, shared_handle, texture_misc_flags, acquire_key,
1300       release_key);
1301   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1302
1303   return ret == GST_FLOW_OK;
1304 }