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;
 682
 683   if (!self->enable_navigation_events || !event || !key)
 684     return;
 685
 686   GST_LOG_OBJECT (self, "send key event %s, key %s", event, key);
 687   if (g_strcmp0 ("key-press", event) == 0) {
 688     key_event = gst_navigation_event_new_key_press (key,
 689         GST_NAVIGATION_MODIFIER_NONE);
 690   } else if (g_strcmp0 ("key-release", event) == 0) {
 691     key_event = gst_navigation_event_new_key_release (key,
 692         GST_NAVIGATION_MODIFIER_NONE);
 693   } else {
 694     return;
 695   }
 696
 697   gst_navigation_send_event_simple (GST_NAVIGATION (self), key_event);
 698 }
 699
 700 static void
 701 gst_d3d11_video_mouse_key_event (GstD3D11Window * window, const gchar * event,
 702     gint button, gdouble x, gdouble y, GstD3D11VideoSink * self)
 703 {
 704   GstEvent *mouse_event;
 705
 706   if (!self->enable_navigation_events || !event)
 707     return;
 708
 709   GST_LOG_OBJECT (self,
 710       "send mouse event %s, button %d (%.1f, %.1f)", event, button, x, y);
 711   if (g_strcmp0 ("mouse-button-press", event) == 0) {
 712     mouse_event = gst_navigation_event_new_mouse_button_press (button, x, y,
 713         GST_NAVIGATION_MODIFIER_NONE);
 714   } else if (g_strcmp0 ("mouse-button-release", event) == 0) {
 715     mouse_event = gst_navigation_event_new_mouse_button_release (button, x, y,
 716         GST_NAVIGATION_MODIFIER_NONE);
 717   } else if (g_strcmp0 ("mouse-move", event) == 0) {
 718     mouse_event = gst_navigation_event_new_mouse_move (x, y,
 719         GST_NAVIGATION_MODIFIER_NONE);
 720   } else {
 721     return;
 722   }
 723
 724   gst_navigation_send_event_simple (GST_NAVIGATION (self), mouse_event);
 725 }
 726
 727 static gboolean
 728 gst_d3d11_video_sink_start (GstBaseSink * sink)
 729 {
 730   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 731
 732   GST_DEBUG_OBJECT (self, "Start");
 733
 734   if (!gst_d3d11_ensure_element_data (GST_ELEMENT_CAST (self), self->adapter,
 735           &self->device)) {
 736     GST_ERROR_OBJECT (sink, "Cannot create d3d11device");
 737     return FALSE;
 738   }
 739
 740   return TRUE;
 741 }
 742
 743 /* called with lock */
 744 static gboolean
 745 gst_d3d11_video_sink_prepare_window (GstD3D11VideoSink * self)
 746 {
 747   GstD3D11WindowNativeType window_type = GST_D3D11_WINDOW_NATIVE_TYPE_HWND;
 748
 749   if (self->window)
 750     return TRUE;
 751
 752   if (self->draw_on_shared_texture) {
 753     GST_INFO_OBJECT (self,
 754         "Create dummy window for rendering on shared texture");
 755     self->window = gst_d3d11_window_dummy_new (self->device);
 756     goto done;
 757   }
 758
 759   if (!self->window_id)
 760     gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (self));
 761
 762   if (self->window_id) {
 763     window_type =
 764         gst_d3d11_window_get_native_type_from_handle (self->window_id);
 765
 766     if (window_type != GST_D3D11_WINDOW_NATIVE_TYPE_NONE) {
 767       GST_DEBUG_OBJECT (self, "Have window handle %" G_GUINTPTR_FORMAT,
 768           self->window_id);
 769       gst_video_overlay_got_window_handle (GST_VIDEO_OVERLAY (self),
 770           self->window_id);
 771     }
 772   }
 773
 774   GST_DEBUG_OBJECT (self, "Create window (type: %s)",
 775       gst_d3d11_window_get_native_type_to_string (window_type));
 776
 777 #if GST_D3D11_WINAPI_ONLY_APP
 778   if (window_type != GST_D3D11_WINDOW_NATIVE_TYPE_CORE_WINDOW &&
 779       window_type != GST_D3D11_WINDOW_NATIVE_TYPE_SWAP_CHAIN_PANEL) {
 780     GST_ERROR_OBJECT (self, "Overlay handle must be set before READY state");
 781     return FALSE;
 782   }
 783 #endif
 784
 785   switch (window_type) {
 786 #if (!GST_D3D11_WINAPI_ONLY_APP)
 787     case GST_D3D11_WINDOW_NATIVE_TYPE_HWND:
 788       self->window = gst_d3d11_window_win32_new (self->device, self->window_id);
 789       break;
 790 #endif
 791 #if GST_D3D11_WINAPI_APP
 792     case GST_D3D11_WINDOW_NATIVE_TYPE_CORE_WINDOW:
 793       self->window = gst_d3d11_window_core_window_new (self->device,
 794           self->window_id);
 795       break;
 796     case GST_D3D11_WINDOW_NATIVE_TYPE_SWAP_CHAIN_PANEL:
 797       self->window = gst_d3d11_window_swap_chain_panel_new (self->device,
 798           self->window_id);
 799       break;
 800 #endif
 801     default:
 802       break;
 803   }
 804
 805 done:
 806   if (!self->window) {
 807     GST_ERROR_OBJECT (self, "Cannot create d3d11window");
 808     return FALSE;
 809   }
 810
 811   g_object_set (self->window,
 812       "force-aspect-ratio", self->force_aspect_ratio,
 813       "fullscreen-toggle-mode", self->fullscreen_toggle_mode,
 814       "fullscreen", self->fullscreen,
 815       "enable-navigation-events", self->enable_navigation_events, NULL);
 816
 817   gst_d3d11_window_set_orientation (self->window, self->selected_method);
 818
 819   g_signal_connect (self->window, "key-event",
 820       G_CALLBACK (gst_d3d11_video_sink_key_event), self);
 821   g_signal_connect (self->window, "mouse-event",
 822       G_CALLBACK (gst_d3d11_video_mouse_key_event), self);
 823
 824   return TRUE;
 825 }
 826
 827 static gboolean
 828 gst_d3d11_video_sink_stop (GstBaseSink * sink)
 829 {
 830   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 831
 832   GST_DEBUG_OBJECT (self, "Stop");
 833
 834   GST_D3D11_VIDEO_SINK_LOCK (self);
 835   if (self->window)
 836     gst_d3d11_window_unprepare (self->window);
 837
 838   gst_clear_object (&self->window);
 839   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 840
 841   gst_clear_object (&self->device);
 842
 843   g_clear_pointer (&self->title, g_free);
 844
 845   return TRUE;
 846 }
 847
 848 static gboolean
 849 gst_d3d11_video_sink_propose_allocation (GstBaseSink * sink, GstQuery * query)
 850 {
 851   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 852   GstCaps *caps;
 853   GstBufferPool *pool = NULL;
 854   GstVideoInfo info;
 855   guint size;
 856   gboolean need_pool;
 857
 858   if (!self->device)
 859     return FALSE;
 860
 861   gst_query_parse_allocation (query, &caps, &need_pool);
 862
 863   if (caps == NULL)
 864     goto no_caps;
 865
 866   if (!gst_video_info_from_caps (&info, caps))
 867     goto invalid_caps;
 868
 869   /* the normal size of a frame */
 870   size = info.size;
 871
 872   if (need_pool) {
 873     GstCapsFeatures *features;
 874     GstStructure *config;
 875     gboolean is_d3d11 = FALSE;
 876
 877     features = gst_caps_get_features (caps, 0);
 878     if (features
 879         && gst_caps_features_contains (features,
 880             GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY)) {
 881       GST_DEBUG_OBJECT (self, "upstream support d3d11 memory");
 882       pool = gst_d3d11_buffer_pool_new (self->device);
 883       is_d3d11 = TRUE;
 884     } else {
 885       pool = gst_video_buffer_pool_new ();
 886     }
 887
 888     config = gst_buffer_pool_get_config (pool);
 889     gst_buffer_pool_config_add_option (config,
 890         GST_BUFFER_POOL_OPTION_VIDEO_META);
 891     if (!is_d3d11) {
 892       gst_buffer_pool_config_add_option (config,
 893           GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
 894     }
 895
 896     size = GST_VIDEO_INFO_SIZE (&info);
 897     if (is_d3d11) {
 898       GstD3D11AllocationParams *d3d11_params;
 899
 900       d3d11_params =
 901           gst_d3d11_allocation_params_new (self->device,
 902           &info, GST_D3D11_ALLOCATION_FLAG_DEFAULT, D3D11_BIND_SHADER_RESOURCE,
 903           0);
 904
 905       gst_buffer_pool_config_set_d3d11_allocation_params (config, d3d11_params);
 906       gst_d3d11_allocation_params_free (d3d11_params);
 907     }
 908
 909     gst_buffer_pool_config_set_params (config, caps, (guint) size, 2, 0);
 910
 911     if (!gst_buffer_pool_set_config (pool, config)) {
 912       GST_ERROR_OBJECT (pool, "Couldn't set config");
 913       gst_object_unref (pool);
 914
 915       return FALSE;
 916     }
 917
 918     /* d3d11 buffer pool will update buffer size based on allocated texture,
 919      * get size from config again */
 920     config = gst_buffer_pool_get_config (pool);
 921     gst_buffer_pool_config_get_params (config, nullptr, &size, nullptr,
 922         nullptr);
 923     gst_structure_free (config);
 924
 925     if (is_d3d11) {
 926       /* In case of system memory, we will upload video frame to GPU memory,
 927        * (which is copy in any case), so crop meta support for system memory
 928        * is almost pointless */
 929       gst_query_add_allocation_meta (query,
 930           GST_VIDEO_CROP_META_API_TYPE, nullptr);
 931     }
 932   }
 933
 934   /* We need at least 2 buffers because we hold on to the last one for redrawing
 935    * on window-resize event */
 936   gst_query_add_allocation_pool (query, pool, size, 2, 0);
 937   if (pool)
 938     g_object_unref (pool);
 939
 940   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
 941   gst_query_add_allocation_meta (query,
 942       GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, NULL);
 943
 944   return TRUE;
 945
 946   /* ERRORS */
 947 no_caps:
 948   {
 949     GST_WARNING_OBJECT (self, "no caps specified");
 950     return FALSE;
 951   }
 952 invalid_caps:
 953   {
 954     GST_WARNING_OBJECT (self, "invalid caps specified");
 955     return FALSE;
 956   }
 957
 958   return TRUE;
 959 }
 960
 961 static gboolean
 962 gst_d3d11_video_sink_query (GstBaseSink * sink, GstQuery * query)
 963 {
 964   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 965
 966   switch (GST_QUERY_TYPE (query)) {
 967     case GST_QUERY_CONTEXT:
 968       if (gst_d3d11_handle_context_query (GST_ELEMENT (self), query,
 969               self->device)) {
 970         return TRUE;
 971       }
 972       break;
 973     default:
 974       break;
 975   }
 976
 977   return GST_BASE_SINK_CLASS (parent_class)->query (sink, query);
 978 }
 979
 980 static gboolean
 981 gst_d3d11_video_sink_unlock (GstBaseSink * sink)
 982 {
 983   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 984
 985   GST_D3D11_VIDEO_SINK_LOCK (self);
 986   if (self->window)
 987     gst_d3d11_window_unlock (self->window);
 988   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 989
 990   return TRUE;
 991 }
 992
 993 static gboolean
 994 gst_d3d11_video_sink_unlock_stop (GstBaseSink * sink)
 995 {
 996   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 997
 998   GST_D3D11_VIDEO_SINK_LOCK (self);
 999   if (self->window)
1000     gst_d3d11_window_unlock_stop (self->window);
1001   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1002
1003   return TRUE;
1004 }
1005
1006 static gboolean
1007 gst_d3d11_video_sink_event (GstBaseSink * sink, GstEvent * event)
1008 {
1009   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
1010
1011   switch (GST_EVENT_TYPE (event)) {
1012     case GST_EVENT_TAG:{
1013       GstTagList *taglist;
1014       gchar *title = nullptr;
1015       GstVideoOrientationMethod method = GST_VIDEO_ORIENTATION_IDENTITY;
1016
1017       gst_event_parse_tag (event, &taglist);
1018       gst_tag_list_get_string (taglist, GST_TAG_TITLE, &title);
1019
1020       if (title) {
1021         const gchar *app_name = g_get_application_name ();
1022         std::string title_string;
1023
1024         if (app_name) {
1025           title_string = std::string (title) + " : " + std::string (app_name);
1026         } else {
1027           title_string = std::string (title);
1028         }
1029
1030         GST_D3D11_VIDEO_SINK_LOCK (self);
1031         if (self->window) {
1032           gst_d3d11_window_set_title (self->window, title_string.c_str ());
1033         } else {
1034           g_free (self->title);
1035           self->title = g_strdup (title_string.c_str ());
1036         }
1037         GST_D3D11_VIDEO_SINK_UNLOCK (self);
1038
1039         g_free (title);
1040       }
1041
1042       if (gst_video_orientation_from_tag (taglist, &method)) {
1043         GST_D3D11_VIDEO_SINK_LOCK (self);
1044         gst_d3d11_video_sink_set_orientation (self, method, TRUE);
1045         GST_D3D11_VIDEO_SINK_UNLOCK (self);
1046       }
1047       break;
1048     }
1049     default:
1050       break;
1051   }
1052
1053   return GST_BASE_SINK_CLASS (parent_class)->event (sink, event);
1054 }
1055
1056 /* called with lock */
1057 static void
1058 gst_d3d11_video_sink_set_orientation (GstD3D11VideoSink * self,
1059     GstVideoOrientationMethod method, gboolean from_tag)
1060 {
1061   if (method == GST_VIDEO_ORIENTATION_CUSTOM) {
1062     GST_WARNING_OBJECT (self, "Unsupported custom orientation");
1063     return;
1064   }
1065
1066   if (from_tag)
1067     self->tag_method = method;
1068   else
1069     self->method = method;
1070
1071   if (self->method == GST_VIDEO_ORIENTATION_AUTO) {
1072     self->selected_method = self->tag_method;
1073   } else {
1074     self->selected_method = self->method;
1075   }
1076
1077   if (self->window)
1078     gst_d3d11_window_set_orientation (self->window, self->selected_method);
1079 }
1080
1081 static void
1082 gst_d3d11_video_sink_check_device_update (GstD3D11VideoSink * self,
1083     GstBuffer * buf)
1084 {
1085   GstMemory *mem;
1086   GstD3D11Memory *dmem;
1087   gboolean update_device = FALSE;
1088
1089   /* We have configured window already, cannot update device */
1090   if (self->window)
1091     return;
1092
1093   mem = gst_buffer_peek_memory (buf, 0);
1094   if (!gst_is_d3d11_memory (mem))
1095     return;
1096
1097   dmem = GST_D3D11_MEMORY_CAST (mem);
1098   /* Same device, nothing to do */
1099   if (dmem->device == self->device)
1100     return;
1101
1102   if (self->adapter < 0) {
1103     update_device = TRUE;
1104   } else {
1105     guint adapter = 0;
1106
1107     g_object_get (dmem->device, "adapter", &adapter, NULL);
1108     /* The same GPU as what user wanted, update */
1109     if (adapter == (guint) self->adapter)
1110       update_device = TRUE;
1111   }
1112
1113   if (!update_device)
1114     return;
1115
1116   GST_INFO_OBJECT (self, "Updating device %" GST_PTR_FORMAT " -> %"
1117       GST_PTR_FORMAT, self->device, dmem->device);
1118
1119   gst_object_unref (self->device);
1120   self->device = (GstD3D11Device *) gst_object_ref (dmem->device);
1121 }
1122
1123 static GstFlowReturn
1124 gst_d3d11_video_sink_show_frame (GstVideoSink * sink, GstBuffer * buf)
1125 {
1126   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
1127   GstFlowReturn ret = GST_FLOW_OK;
1128
1129   gst_d3d11_video_sink_check_device_update (self, buf);
1130
1131   if (self->caps_updated || !self->window) {
1132     GstCaps *caps = gst_pad_get_current_caps (GST_BASE_SINK_PAD (sink));
1133     gboolean update_ret;
1134
1135     /* shouldn't happen */
1136     if (!caps)
1137       return GST_FLOW_NOT_NEGOTIATED;
1138
1139     update_ret = gst_d3d11_video_sink_update_window (self, caps);
1140     gst_caps_unref (caps);
1141
1142     if (!update_ret)
1143       return GST_FLOW_NOT_NEGOTIATED;
1144   }
1145
1146   gst_d3d11_window_show (self->window);
1147
1148   if (self->draw_on_shared_texture) {
1149     GST_D3D11_VIDEO_SINK_LOCK (self);
1150     self->current_buffer = buf;
1151     self->drawing = TRUE;
1152
1153     GST_LOG_OBJECT (self, "Begin drawing");
1154
1155     /* Application should call draw method on this callback */
1156     g_signal_emit (self, gst_d3d11_video_sink_signals[SIGNAL_BEGIN_DRAW], 0,
1157         NULL);
1158
1159     GST_LOG_OBJECT (self, "End drawing");
1160     self->drawing = FALSE;
1161     self->current_buffer = nullptr;
1162     GST_D3D11_VIDEO_SINK_UNLOCK (self);
1163   } else {
1164     ret = gst_d3d11_window_render (self->window, buf);
1165   }
1166
1167   if (ret == GST_D3D11_WINDOW_FLOW_CLOSED) {
1168     GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND,
1169         ("Output window was closed"), (NULL));
1170
1171     ret = GST_FLOW_ERROR;
1172   }
1173
1174   return ret;
1175 }
1176
1177 /* VideoOverlay interface */
1178 static void
1179 gst_d3d11_video_sink_set_window_handle (GstVideoOverlay * overlay,
1180     guintptr window_id)
1181 {
1182   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (overlay);
1183
1184   GST_DEBUG ("set window handle %" G_GUINTPTR_FORMAT, window_id);
1185
1186   self->window_id = window_id;
1187 }
1188
1189 static void
1190 gst_d3d11_video_sink_set_render_rectangle (GstVideoOverlay * overlay, gint x,
1191     gint y, gint width, gint height)
1192 {
1193   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (overlay);
1194
1195   GST_DEBUG_OBJECT (self,
1196       "render rect x: %d, y: %d, width: %d, height %d", x, y, width, height);
1197
1198   GST_D3D11_VIDEO_SINK_LOCK (self);
1199   if (self->window) {
1200     GstVideoRectangle rect;
1201
1202     rect.x = x;
1203     rect.y = y;
1204     rect.w = width;
1205     rect.h = height;
1206
1207     self->render_rect = rect;
1208
1209     gst_d3d11_window_set_render_rectangle (self->window, &rect);
1210   } else {
1211     self->render_rect.x = x;
1212     self->render_rect.y = y;
1213     self->render_rect.w = width;
1214     self->render_rect.h = height;
1215     self->pending_render_rect = TRUE;
1216   }
1217
1218   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1219 }
1220
1221 static void
1222 gst_d3d11_video_sink_expose (GstVideoOverlay * overlay)
1223 {
1224   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (overlay);
1225
1226   GST_D3D11_VIDEO_SINK_LOCK (self);
1227   if (self->window && self->window->swap_chain)
1228     gst_d3d11_window_render (self->window, nullptr);
1229   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1230 }
1231
1232 static void
1233 gst_d3d11_video_sink_video_overlay_init (GstVideoOverlayInterface * iface)
1234 {
1235   iface->set_window_handle = gst_d3d11_video_sink_set_window_handle;
1236   iface->set_render_rectangle = gst_d3d11_video_sink_set_render_rectangle;
1237   iface->expose = gst_d3d11_video_sink_expose;
1238 }
1239
1240 /* Navigation interface */
1241 static void
1242 gst_d3d11_video_sink_navigation_send_event (GstNavigation * navigation,
1243     GstEvent * event)
1244 {
1245   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (navigation);
1246
1247   /* TODO: add support for translating native coordinate and video coordinate
1248    * when force-aspect-ratio is set */
1249   if (event) {
1250     gboolean handled;
1251
1252     gst_event_ref (event);
1253     handled = gst_pad_push_event (GST_VIDEO_SINK_PAD (self), event);
1254
1255     if (!handled)
1256       gst_element_post_message (GST_ELEMENT_CAST (self),
1257           gst_navigation_message_new_event (GST_OBJECT_CAST (self), event));
1258
1259     gst_event_unref (event);
1260   }
1261 }
1262
1263 static void
1264 gst_d3d11_video_sink_navigation_init (GstNavigationInterface * iface)
1265 {
1266   iface->send_event_simple = gst_d3d11_video_sink_navigation_send_event;
1267 }
1268
1269 static gboolean
1270 gst_d3d11_video_sink_draw_action (GstD3D11VideoSink * self,
1271     gpointer shared_handle, guint texture_misc_flags,
1272     guint64 acquire_key, guint64 release_key)
1273 {
1274   GstFlowReturn ret;
1275   g_return_val_if_fail (shared_handle != NULL, FALSE);
1276
1277   if (!self->draw_on_shared_texture) {
1278     GST_ERROR_OBJECT (self, "Invalid draw call, we are drawing on window");
1279     return FALSE;
1280   }
1281
1282   if (!shared_handle) {
1283     GST_ERROR_OBJECT (self, "Invalid handle");
1284     return FALSE;
1285   }
1286
1287   GST_D3D11_VIDEO_SINK_LOCK (self);
1288   if (!self->drawing || !self->current_buffer) {
1289     GST_WARNING_OBJECT (self, "Nothing to draw");
1290     GST_D3D11_VIDEO_SINK_UNLOCK (self);
1291     return FALSE;
1292   }
1293
1294   GST_LOG_OBJECT (self, "Drawing on shared handle %p, MiscFlags: 0x%x"
1295       ", acquire key: %" G_GUINT64_FORMAT ", release key: %"
1296       G_GUINT64_FORMAT, shared_handle, texture_misc_flags, acquire_key,
1297       release_key);
1298
1299   ret = gst_d3d11_window_render_on_shared_handle (self->window,
1300       self->current_buffer, shared_handle, texture_misc_flags, acquire_key,
1301       release_key);
1302   GST_D3D11_VIDEO_SINK_UNLOCK (self);
1303
1304   return ret == GST_FLOW_OK;
1305 }