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 "gstd3d11videoprocessor.h"
  43 #include "gstd3d11pluginutils.h"
  44 #include <string>
  45
  46 #if GST_D3D11_WINAPI_APP
  47 #include "gstd3d11window_corewindow.h"
  48 #include "gstd3d11window_swapchainpanel.h"
  49 #endif
  50 #if (!GST_D3D11_WINAPI_ONLY_APP)
  51 #include "gstd3d11window_win32.h"
  52 #endif
  53 #include "gstd3d11window_dummy.h"
  54
  55 enum
  56 {
  57   PROP_0,
  58   PROP_ADAPTER,
  59   PROP_FORCE_ASPECT_RATIO,
  60   PROP_ENABLE_NAVIGATION_EVENTS,
  61   PROP_FULLSCREEN_TOGGLE_MODE,
  62   PROP_FULLSCREEN,
  63   PROP_DRAW_ON_SHARED_TEXTURE,
  64   PROP_ROTATE_METHOD,
  65 };
  66
  67 #define DEFAULT_ADAPTER                   -1
  68 #define DEFAULT_FORCE_ASPECT_RATIO        TRUE
  69 #define DEFAULT_ENABLE_NAVIGATION_EVENTS  TRUE
  70 #define DEFAULT_FULLSCREEN_TOGGLE_MODE    GST_D3D11_WINDOW_FULLSCREEN_TOGGLE_MODE_NONE
  71 #define DEFAULT_FULLSCREEN                FALSE
  72 #define DEFAULT_DRAW_ON_SHARED_TEXTURE    FALSE
  73
  74 enum
  75 {
  76   /* signals */
  77   SIGNAL_BEGIN_DRAW,
  78
  79   /* actions */
  80   SIGNAL_DRAW,
  81
  82   LAST_SIGNAL
  83 };
  84
  85 static guint gst_d3d11_video_sink_signals[LAST_SIGNAL] = { 0, };
  86
  87 static GstStaticCaps pad_template_caps =
  88     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  89     (GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY, GST_D3D11_SINK_FORMATS) "; "
  90     GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  91     (GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY ","
  92         GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
  93         GST_D3D11_SINK_FORMATS) ";"
  94     GST_VIDEO_CAPS_MAKE (GST_D3D11_SINK_FORMATS) "; "
  95     GST_VIDEO_CAPS_MAKE_WITH_FEATURES
  96     (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY ","
  97         GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,
  98         GST_D3D11_SINK_FORMATS));
  99
 100 GST_DEBUG_CATEGORY (d3d11_video_sink_debug);
 101 #define GST_CAT_DEFAULT d3d11_video_sink_debug
 102
 103 struct _GstD3D11VideoSink
 104 {
 105   GstVideoSink parent;
 106   GstD3D11Device *device;
 107   GstD3D11Window *window;
 108   gint video_width;
 109   gint video_height;
 110
 111   GstVideoInfo info;
 112
 113   guintptr window_id;
 114
 115   gboolean caps_updated;
 116
 117   /* properties */
 118   gint adapter;
 119   gboolean force_aspect_ratio;
 120   gboolean enable_navigation_events;
 121   GstD3D11WindowFullscreenToggleMode fullscreen_toggle_mode;
 122   gboolean fullscreen;
 123   gboolean draw_on_shared_texture;
 124
 125   /* saved render rectangle until we have a window */
 126   GstVideoRectangle render_rect;
 127   gboolean pending_render_rect;
 128
 129   /* For drawing on user texture */
 130   gboolean drawing;
 131   GstBuffer *current_buffer;
 132   GRecMutex lock;
 133
 134   gchar *title;
 135
 136   /* method configured via property */
 137   GstVideoOrientationMethod method;
 138   /* method parsed from tag */
 139   GstVideoOrientationMethod tag_method;
 140   /* method currently selected based on "method" and "tag_method" */
 141   GstVideoOrientationMethod selected_method;
 142 };
 143
 144 #define GST_D3D11_VIDEO_SINK_GET_LOCK(d) (&(GST_D3D11_VIDEO_SINK_CAST(d)->lock))
 145 #define GST_D3D11_VIDEO_SINK_LOCK(d) G_STMT_START { \
 146     GST_TRACE_OBJECT (d, "Locking from thread %p", g_thread_self()); \
 147     g_rec_mutex_lock (GST_D3D11_VIDEO_SINK_GET_LOCK (d)); \
 148     GST_TRACE_OBJECT (d, "Locked from thread %p", g_thread_self()); \
 149  } G_STMT_END
 150
 151 #define GST_D3D11_VIDEO_SINK_UNLOCK(d) G_STMT_START { \
 152     GST_TRACE_OBJECT (d, "Unlocking from thread %p", g_thread_self()); \
 153     g_rec_mutex_unlock (GST_D3D11_VIDEO_SINK_GET_LOCK (d)); \
 154  } G_STMT_END
 155
 156 static void gst_d3d11_videosink_set_property (GObject * object, guint prop_id,
 157     const GValue * value, GParamSpec * pspec);
 158 static void gst_d3d11_videosink_get_property (GObject * object, guint prop_id,
 159     GValue * value, GParamSpec * pspec);
 160 static void gst_d3d11_video_sink_finalize (GObject * object);
 161 static gboolean
 162 gst_d3d11_video_sink_draw_action (GstD3D11VideoSink * self,
 163     gpointer shared_handle, guint texture_misc_flags, guint64 acquire_key,
 164     guint64 release_key);
 165
 166 static void
 167 gst_d3d11_video_sink_video_overlay_init (GstVideoOverlayInterface * iface);
 168 static void
 169 gst_d3d11_video_sink_navigation_init (GstNavigationInterface * iface);
 170
 171 static void gst_d3d11_video_sink_set_context (GstElement * element,
 172     GstContext * context);
 173 static GstCaps *gst_d3d11_video_sink_get_caps (GstBaseSink * sink,
 174     GstCaps * filter);
 175 static gboolean gst_d3d11_video_sink_set_caps (GstBaseSink * sink,
 176     GstCaps * caps);
 177
 178 static gboolean gst_d3d11_video_sink_start (GstBaseSink * sink);
 179 static gboolean gst_d3d11_video_sink_stop (GstBaseSink * sink);
 180 static gboolean gst_d3d11_video_sink_propose_allocation (GstBaseSink * sink,
 181     GstQuery * query);
 182 static gboolean gst_d3d11_video_sink_query (GstBaseSink * sink,
 183     GstQuery * query);
 184 static gboolean gst_d3d11_video_sink_unlock (GstBaseSink * sink);
 185 static gboolean gst_d3d11_video_sink_unlock_stop (GstBaseSink * sink);
 186 static gboolean gst_d3d11_video_sink_event (GstBaseSink * sink,
 187     GstEvent * event);
 188 static GstFlowReturn
 189 gst_d3d11_video_sink_show_frame (GstVideoSink * sink, GstBuffer * buf);
 190 static gboolean gst_d3d11_video_sink_prepare_window (GstD3D11VideoSink * self);
 191 static void gst_d3d11_video_sink_set_orientation (GstD3D11VideoSink * self,
 192     GstVideoOrientationMethod method, gboolean from_tag);
 193
 194 #define gst_d3d11_video_sink_parent_class parent_class
 195 G_DEFINE_TYPE_WITH_CODE (GstD3D11VideoSink, gst_d3d11_video_sink,
 196     GST_TYPE_VIDEO_SINK,
 197     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
 198         gst_d3d11_video_sink_video_overlay_init);
 199     G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
 200         gst_d3d11_video_sink_navigation_init);
 201     GST_DEBUG_CATEGORY_INIT (d3d11_video_sink_debug,
 202         "d3d11videosink", 0, "Direct3D11 Video Sink"));
 203
 204 static void
 205 gst_d3d11_video_sink_class_init (GstD3D11VideoSinkClass * klass)
 206 {
 207   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 208   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 209   GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS (klass);
 210   GstVideoSinkClass *videosink_class = GST_VIDEO_SINK_CLASS (klass);
 211   GstCaps *caps;
 212
 213   gobject_class->set_property = gst_d3d11_videosink_set_property;
 214   gobject_class->get_property = gst_d3d11_videosink_get_property;
 215   gobject_class->finalize = gst_d3d11_video_sink_finalize;
 216
 217   g_object_class_install_property (gobject_class, PROP_ADAPTER,
 218       g_param_spec_int ("adapter", "Adapter",
 219           "Adapter index for creating device (-1 for default)",
 220           -1, G_MAXINT32, DEFAULT_ADAPTER,
 221           (GParamFlags) (G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
 222               G_PARAM_STATIC_STRINGS)));
 223
 224   g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO,
 225       g_param_spec_boolean ("force-aspect-ratio",
 226           "Force aspect ratio",
 227           "When enabled, scaling will respect original aspect ratio",
 228           DEFAULT_FORCE_ASPECT_RATIO,
 229           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 230
 231   g_object_class_install_property (gobject_class, PROP_ENABLE_NAVIGATION_EVENTS,
 232       g_param_spec_boolean ("enable-navigation-events",
 233           "Enable navigation events",
 234           "When enabled, navigation events are sent upstream",
 235           DEFAULT_ENABLE_NAVIGATION_EVENTS,
 236           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 237
 238   g_object_class_install_property (gobject_class, PROP_FULLSCREEN_TOGGLE_MODE,
 239       g_param_spec_flags ("fullscreen-toggle-mode",
 240           "Full screen toggle mode",
 241           "Full screen toggle mode used to trigger fullscreen mode change",
 242           GST_D3D11_WINDOW_TOGGLE_MODE_GET_TYPE, DEFAULT_FULLSCREEN_TOGGLE_MODE,
 243           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 244
 245   g_object_class_install_property (gobject_class, PROP_FULLSCREEN,
 246       g_param_spec_boolean ("fullscreen",
 247           "fullscreen",
 248           "Ignored when \"fullscreen-toggle-mode\" does not include \"property\"",
 249           DEFAULT_FULLSCREEN,
 250           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 251
 252   /**
 253    * GstD3D11VideoSink:draw-on-shared-texture:
 254    *
 255    * Instruct the sink to draw on a shared texture provided by user.
 256    * User must watch #d3d11videosink::begin-draw signal and should call
 257    * #d3d11videosink::draw method on the #d3d11videosink::begin-draw
 258    * signal handler.
 259    *
 260    * Currently supported formats for user texture are:
 261    * - DXGI_FORMAT_R8G8B8A8_UNORM
 262    * - DXGI_FORMAT_B8G8R8A8_UNORM
 263    * - DXGI_FORMAT_R10G10B10A2_UNORM
 264    *
 265    * Since: 1.20
 266    */
 267   g_object_class_install_property (gobject_class, PROP_DRAW_ON_SHARED_TEXTURE,
 268       g_param_spec_boolean ("draw-on-shared-texture",
 269           "Draw on shared texture",
 270           "Draw on user provided shared texture instead of window. "
 271           "When enabled, user can pass application's own texture to sink "
 272           "by using \"draw\" action signal on \"begin-draw\" signal handler, "
 273           "so that sink can draw video data on application's texture. "
 274           "Supported texture formats for user texture are "
 275           "DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, and "
 276           "DXGI_FORMAT_R10G10B10A2_UNORM.",
 277           DEFAULT_DRAW_ON_SHARED_TEXTURE,
 278           (GParamFlags) (G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
 279               G_PARAM_STATIC_STRINGS)));
 280
 281   /**
 282    * GstD3D11VideoSink:rotate-method:
 283    *
 284    * Video rotation/flip method to use
 285    *
 286    * Since: 1.22
 287    */
 288   g_object_class_install_property (gobject_class, PROP_ROTATE_METHOD,
 289       g_param_spec_enum ("rotate-method", "Rotate Method",
 290           "Rotate method to use",
 291           GST_TYPE_VIDEO_ORIENTATION_METHOD, GST_VIDEO_ORIENTATION_IDENTITY,
 292           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 293
 294   /**
 295    * GstD3D11VideoSink::begin-draw:
 296    * @videosink: the #d3d11videosink
 297    *
 298    * Emitted when sink has a texture to draw. Application needs to invoke
 299    * #d3d11videosink::draw action signal before returning from
 300    * #d3d11videosink::begin-draw signal handler.
 301    *
 302    * Since: 1.20
 303    */
 304   gst_d3d11_video_sink_signals[SIGNAL_BEGIN_DRAW] =
 305       g_signal_new ("begin-draw", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 306       G_STRUCT_OFFSET (GstD3D11VideoSinkClass, begin_draw),
 307       NULL, NULL, NULL, G_TYPE_NONE, 0, G_TYPE_NONE);
 308
 309   /**
 310    * GstD3D11VideoSink::draw:
 311    * @videosink: the #d3d11videosink
 312    * @shard_handle: a pointer to HANDLE
 313    * @texture_misc_flags: a D3D11_RESOURCE_MISC_FLAG value
 314    * @acquire_key: a key value used for IDXGIKeyedMutex::AcquireSync
 315    * @release_key: a key value used for IDXGIKeyedMutex::ReleaseSync
 316    *
 317    * Draws on a shared texture. @shard_handle must be a valid pointer to
 318    * a HANDLE which was obtained via IDXGIResource::GetSharedHandle or
 319    * IDXGIResource1::CreateSharedHandle.
 320    *
 321    * If the texture was created with D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX flag,
 322    * caller must specify valid @acquire_key and @release_key.
 323    * Otherwise (i.e., created with D3D11_RESOURCE_MISC_SHARED flag),
 324    * @acquire_key and @release_key will be ignored.
 325    *
 326    * Since: 1.20
 327    */
 328   gst_d3d11_video_sink_signals[SIGNAL_DRAW] =
 329       g_signal_new ("draw", G_TYPE_FROM_CLASS (klass),
 330       (GSignalFlags) (G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
 331       G_STRUCT_OFFSET (GstD3D11VideoSinkClass, draw), NULL, NULL, NULL,
 332       G_TYPE_BOOLEAN, 4, G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_UINT64,
 333       G_TYPE_UINT64);
 334
 335   element_class->set_context =
 336       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_set_context);
 337
 338   gst_element_class_set_static_metadata (element_class,
 339       "Direct3D11 video sink", "Sink/Video",
 340       "A Direct3D11 based videosink",
 341       "Seungha Yang <seungha.yang@navercorp.com>");
 342
 343   caps = gst_d3d11_get_updated_template_caps (&pad_template_caps);
 344   gst_element_class_add_pad_template (element_class,
 345       gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps));
 346   gst_caps_unref (caps);
 347
 348   basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_get_caps);
 349   basesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_set_caps);
 350   basesink_class->start = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_start);
 351   basesink_class->stop = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_stop);
 352   basesink_class->propose_allocation =
 353       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_propose_allocation);
 354   basesink_class->query = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_query);
 355   basesink_class->unlock = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_unlock);
 356   basesink_class->unlock_stop =
 357       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_unlock_stop);
 358   basesink_class->event = GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_event);
 359
 360   videosink_class->show_frame =
 361       GST_DEBUG_FUNCPTR (gst_d3d11_video_sink_show_frame);
 362
 363   klass->draw = gst_d3d11_video_sink_draw_action;
 364
 365   gst_type_mark_as_plugin_api (GST_D3D11_WINDOW_TOGGLE_MODE_GET_TYPE,
 366       (GstPluginAPIFlags) 0);
 367 }
 368
 369 static void
 370 gst_d3d11_video_sink_init (GstD3D11VideoSink * self)
 371 {
 372   self->adapter = DEFAULT_ADAPTER;
 373   self->force_aspect_ratio = DEFAULT_FORCE_ASPECT_RATIO;
 374   self->enable_navigation_events = DEFAULT_ENABLE_NAVIGATION_EVENTS;
 375   self->fullscreen_toggle_mode = DEFAULT_FULLSCREEN_TOGGLE_MODE;
 376   self->fullscreen = DEFAULT_FULLSCREEN;
 377   self->draw_on_shared_texture = DEFAULT_DRAW_ON_SHARED_TEXTURE;
 378
 379   g_rec_mutex_init (&self->lock);
 380 }
 381
 382 static void
 383 gst_d3d11_videosink_set_property (GObject * object, guint prop_id,
 384     const GValue * value, GParamSpec * pspec)
 385 {
 386   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (object);
 387
 388   GST_D3D11_VIDEO_SINK_LOCK (self);
 389   switch (prop_id) {
 390     case PROP_ADAPTER:
 391       self->adapter = g_value_get_int (value);
 392       break;
 393     case PROP_FORCE_ASPECT_RATIO:
 394       self->force_aspect_ratio = g_value_get_boolean (value);
 395       if (self->window)
 396         g_object_set (self->window,
 397             "force-aspect-ratio", self->force_aspect_ratio, NULL);
 398       break;
 399     case PROP_ENABLE_NAVIGATION_EVENTS:
 400       self->enable_navigation_events = g_value_get_boolean (value);
 401       if (self->window) {
 402         g_object_set (self->window,
 403             "enable-navigation-events", self->enable_navigation_events, NULL);
 404       }
 405       break;
 406     case PROP_FULLSCREEN_TOGGLE_MODE:
 407       self->fullscreen_toggle_mode =
 408           (GstD3D11WindowFullscreenToggleMode) g_value_get_flags (value);
 409       if (self->window) {
 410         g_object_set (self->window,
 411             "fullscreen-toggle-mode", self->fullscreen_toggle_mode, NULL);
 412       }
 413       break;
 414     case PROP_FULLSCREEN:
 415       self->fullscreen = g_value_get_boolean (value);
 416       if (self->window) {
 417         g_object_set (self->window, "fullscreen", self->fullscreen, NULL);
 418       }
 419       break;
 420     case PROP_DRAW_ON_SHARED_TEXTURE:
 421       self->draw_on_shared_texture = g_value_get_boolean (value);
 422       break;
 423     case PROP_ROTATE_METHOD:
 424       gst_d3d11_video_sink_set_orientation (self,
 425           (GstVideoOrientationMethod) g_value_get_enum (value), FALSE);
 426       break;
 427     default:
 428       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 429       break;
 430   }
 431   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 432 }
 433
 434 static void
 435 gst_d3d11_videosink_get_property (GObject * object, guint prop_id,
 436     GValue * value, GParamSpec * pspec)
 437 {
 438   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (object);
 439
 440   GST_D3D11_VIDEO_SINK_LOCK (self);
 441   switch (prop_id) {
 442     case PROP_ADAPTER:
 443       g_value_set_int (value, self->adapter);
 444       break;
 445     case PROP_FORCE_ASPECT_RATIO:
 446       g_value_set_boolean (value, self->force_aspect_ratio);
 447       break;
 448     case PROP_ENABLE_NAVIGATION_EVENTS:
 449       g_value_set_boolean (value, self->enable_navigation_events);
 450       break;
 451     case PROP_FULLSCREEN_TOGGLE_MODE:
 452       g_value_set_flags (value, self->fullscreen_toggle_mode);
 453       break;
 454     case PROP_FULLSCREEN:
 455       if (self->window) {
 456         g_object_get_property (G_OBJECT (self->window), pspec->name, value);
 457       } else {
 458         g_value_set_boolean (value, self->fullscreen);
 459       }
 460       break;
 461     case PROP_DRAW_ON_SHARED_TEXTURE:
 462       g_value_set_boolean (value, self->draw_on_shared_texture);
 463       break;
 464     case PROP_ROTATE_METHOD:
 465       g_value_set_enum (value, self->method);
 466       break;
 467     default:
 468       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 469       break;
 470   }
 471   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 472 }
 473
 474 static void
 475 gst_d3d11_video_sink_finalize (GObject * object)
 476 {
 477   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (object);
 478
 479   g_rec_mutex_clear (&self->lock);
 480   g_free (self->title);
 481
 482   G_OBJECT_CLASS (parent_class)->finalize (object);
 483 }
 484
 485 static void
 486 gst_d3d11_video_sink_set_context (GstElement * element, GstContext * context)
 487 {
 488   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (element);
 489
 490   gst_d3d11_handle_set_context (element, context, self->adapter, &self->device);
 491
 492   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 493 }
 494
 495 static GstCaps *
 496 gst_d3d11_video_sink_get_caps (GstBaseSink * sink, GstCaps * filter)
 497 {
 498   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 499   GstCaps *caps = NULL;
 500
 501   caps = gst_pad_get_pad_template_caps (GST_VIDEO_SINK_PAD (sink));
 502
 503   if (self->device) {
 504     gboolean is_hardware = FALSE;
 505
 506     g_object_get (self->device, "hardware", &is_hardware, NULL);
 507
 508     /* In case of WARP device, conversion via shader would be inefficient than
 509      * upstream videoconvert. Allow native formats in this case */
 510     if (!is_hardware) {
 511       GValue format_list = G_VALUE_INIT;
 512       GValue format = G_VALUE_INIT;
 513
 514       g_value_init (&format_list, GST_TYPE_LIST);
 515       g_value_init (&format, G_TYPE_STRING);
 516
 517       g_value_set_string (&format, "RGBA");
 518       gst_value_list_append_and_take_value (&format_list, &format);
 519
 520       format = G_VALUE_INIT;
 521       g_value_init (&format, G_TYPE_STRING);
 522       g_value_set_string (&format, "BGRA");
 523       gst_value_list_append_and_take_value (&format_list, &format);
 524
 525       caps = gst_caps_make_writable (caps);
 526       gst_caps_set_value (caps, "format", &format_list);
 527       g_value_unset (&format_list);
 528     }
 529   }
 530
 531   if (filter) {
 532     GstCaps *isect;
 533     isect = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 534     gst_caps_unref (caps);
 535     caps = isect;
 536   }
 537
 538   return caps;
 539 }
 540
 541 static gboolean
 542 gst_d3d11_video_sink_set_caps (GstBaseSink * sink, GstCaps * caps)
 543 {
 544   GstD3D11VideoSink *self = GST_D3D11_VIDEO_SINK (sink);
 545
 546   GST_DEBUG_OBJECT (self, "set caps %" GST_PTR_FORMAT, caps);
 547
 548   /* We will update window on show_frame() */
 549   self->caps_updated = TRUE;
 550
 551   return TRUE;
 552 }
 553
 554 static gboolean
 555 gst_d3d11_video_sink_update_window (GstD3D11VideoSink * self, GstCaps * caps)
 556 {
 557   gint video_width, video_height;
 558   gint video_par_n, video_par_d;        /* video's PAR */
 559   gint display_par_n = 1, display_par_d = 1;    /* display's PAR */
 560   guint num, den;
 561   GError *error = NULL;
 562
 563   GST_DEBUG_OBJECT (self, "Updating window with caps %" GST_PTR_FORMAT, caps);
 564
 565   self->caps_updated = FALSE;
 566
 567   GST_D3D11_VIDEO_SINK_LOCK (self);
 568   if (!gst_d3d11_video_sink_prepare_window (self)) {
 569     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 570
 571     GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, (nullptr),
 572         ("Failed to open window."));
 573
 574     return FALSE;
 575   }
 576
 577   if (!gst_video_info_from_caps (&self->info, caps)) {
 578     GST_DEBUG_OBJECT (self,
 579         "Could not locate image format from caps %" GST_PTR_FORMAT, caps);
 580     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 581     return FALSE;
 582   }
 583
 584   video_width = GST_VIDEO_INFO_WIDTH (&self->info);
 585   video_height = GST_VIDEO_INFO_HEIGHT (&self->info);
 586   video_par_n = GST_VIDEO_INFO_PAR_N (&self->info);
 587   video_par_d = GST_VIDEO_INFO_PAR_D (&self->info);
 588
 589   /* get aspect ratio from caps if it's present, and
 590    * convert video width and height to a display width and height
 591    * using wd / hd = wv / hv * PARv / PARd */
 592
 593   if (!gst_video_calculate_display_ratio (&num, &den, video_width,
 594           video_height, video_par_n, video_par_d, display_par_n,
 595           display_par_d)) {
 596     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 597
 598     GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (nullptr),
 599         ("Error calculating the output display ratio of the video."));
 600     return FALSE;
 601   }
 602
 603   GST_DEBUG_OBJECT (self,
 604       "video width/height: %dx%d, calculated display ratio: %d/%d format: %s",
 605       video_width, video_height, num, den,
 606       gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&self->info)));
 607
 608   /* now find a width x height that respects this display ratio.
 609    * prefer those that have one of w/h the same as the incoming video
 610    * using wd / hd = num / den
 611    */
 612
 613   /* start with same height, because of interlaced video
 614    * check hd / den is an integer scale factor, and scale wd with the PAR
 615    */
 616   if (video_height % den == 0) {
 617     GST_DEBUG_OBJECT (self, "keeping video height");
 618     GST_VIDEO_SINK_WIDTH (self) = (guint)
 619         gst_util_uint64_scale_int (video_height, num, den);
 620     GST_VIDEO_SINK_HEIGHT (self) = video_height;
 621   } else if (video_width % num == 0) {
 622     GST_DEBUG_OBJECT (self, "keeping video width");
 623     GST_VIDEO_SINK_WIDTH (self) = video_width;
 624     GST_VIDEO_SINK_HEIGHT (self) = (guint)
 625         gst_util_uint64_scale_int (video_width, den, num);
 626   } else {
 627     GST_DEBUG_OBJECT (self, "approximating while keeping video height");
 628     GST_VIDEO_SINK_WIDTH (self) = (guint)
 629         gst_util_uint64_scale_int (video_height, num, den);
 630     GST_VIDEO_SINK_HEIGHT (self) = video_height;
 631   }
 632
 633   GST_DEBUG_OBJECT (self, "scaling to %dx%d",
 634       GST_VIDEO_SINK_WIDTH (self), GST_VIDEO_SINK_HEIGHT (self));
 635   self->video_width = video_width;
 636   self->video_height = video_height;
 637
 638   if (GST_VIDEO_SINK_WIDTH (self) <= 0 || GST_VIDEO_SINK_HEIGHT (self) <= 0) {
 639     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 640
 641     GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, (nullptr),
 642         ("Error calculating the output display ratio of the video."));
 643     return FALSE;
 644   }
 645
 646   if (self->pending_render_rect) {
 647     GstVideoRectangle rect = self->render_rect;
 648
 649     self->pending_render_rect = FALSE;
 650     gst_d3d11_window_set_render_rectangle (self->window, &rect);
 651   }
 652
 653   if (!gst_d3d11_window_prepare (self->window, GST_VIDEO_SINK_WIDTH (self),
 654           GST_VIDEO_SINK_HEIGHT (self), caps, &error)) {
 655     GstMessage *error_msg;
 656
 657     GST_D3D11_VIDEO_SINK_UNLOCK (self);
 658
 659     GST_ERROR_OBJECT (self, "cannot create swapchain");
 660     error_msg = gst_message_new_error (GST_OBJECT_CAST (self),
 661         error, "Failed to prepare d3d11window");
 662     g_clear_error (&error);
 663     gst_element_post_message (GST_ELEMENT (self), error_msg);
 664
 665     return FALSE;
 666   }
 667
 668   if (self->title) {
 669     gst_d3d11_window_set_title (self->window, self->title);
 670     g_clear_pointer (&self->title, g_free);
 671   }
 672
 673   GST_D3D11_VIDEO_SINK_UNLOCK (self);
 674
 675   return TRUE;
 676 }
 677
 678 static void
 679 gst_d3d11_video_sink_key_event (GstD3D11Window * window, const gchar * event,
 680     const gchar * key, GstD3D11VideoSink * self)
 681 {
 682   GstEvent *key_event = NULL;
 683
 684   if (self->enable_navigation_events) {
 685     GST_LOG_OBJECT (self, "send key event %s, key %s", event, key);
 686     if (0 == g_strcmp0 ("key-press", event))
 687       key_event =
 688           gst_navigation_event_new_key_press (key,
 689           GST_NAVIGATION_MODIFIER_NONE);
 690     else if (0 == g_strcmp0 ("key-release", event))
 691       key_event =
 692           gst_navigation_event_new_key_release (key,
 693           GST_NAVIGATION_MODIFIER_NONE);
 694
 695     if (event)
 696       gst_navigation_send_event_simple (GST_NAVIGATION (self), key_event);
 697   }
 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 = NULL;
 705
 706   if (self->enable_navigation_events) {
 707     GST_LOG_OBJECT (self,
 708         "send mouse event %s, button %d (%.1f, %.1f)", event, button, x, y);
 709     if (0 == g_strcmp0 ("mouse-button-press", event))
 710       mouse_event =
 711           gst_navigation_event_new_mouse_button_press (button, x, y,
 712           GST_NAVIGATION_MODIFIER_NONE);
 713     else if (0 == g_strcmp0 ("mouse-button-release", event))
 714       mouse_event =
 715           gst_navigation_event_new_mouse_button_release (button, x, y,
 716           GST_NAVIGATION_MODIFIER_NONE);
 717     else if (0 == g_strcmp0 ("mouse-move", event))
 718       mouse_event =
 719           gst_navigation_event_new_mouse_move (x, y,
 720           GST_NAVIGATION_MODIFIER_NONE);
 721
 722     if (event)
 723       gst_navigation_send_event_simple (GST_NAVIGATION (self), mouse_event);
 724   }
 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 }