subprojects/gst-plugins-bad/sys/directshow/dshowsinkwrapper/dshowvideosink.cpp

   1 /* GStreamer
   2  * Copyright (C) 2008 Pioneers of the Inevitable <songbird@songbirdnest.com>
   3  *               2010 FLUENDO S.A. <support@fluendo.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 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include "dshowvideosink.h"
  26 #include "dshowvideofakesrc.h"
  27
  28 #include <gst/video/video.h>
  29 #include <gst/video/videooverlay.h>
  30 #include <gst/video/navigation.h>
  31
  32 #include "windows.h"
  33
  34 #define WM_GRAPH_NOTIFY WM_APP + 1 /* Private message */
  35
  36 GST_DEBUG_CATEGORY (dshowvideosink_debug);
  37 #define GST_CAT_DEFAULT dshowvideosink_debug
  38
  39 static GstCaps * gst_directshow_media_type_to_caps (AM_MEDIA_TYPE *mediatype);
  40 static gboolean gst_caps_to_directshow_media_type (GstDshowVideoSink * sink,
  41   GstCaps *caps, AM_MEDIA_TYPE *mediatype);
  42
  43 /* TODO: Support RGB! */
  44 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  45     GST_PAD_SINK,
  46     GST_PAD_ALWAYS,
  47     GST_STATIC_CAPS (
  48         "video/x-raw,"
  49         "width = (int) [ 1, MAX ],"
  50         "height = (int) [ 1, MAX ],"
  51         "framerate = (fraction) [ 0, MAX ],"
  52         "format = {(string)YUY2, (string)UYVY, (string)YV12 }")
  53     );
  54
  55 static void gst_dshowvideosink_init_interfaces (GType type);
  56
  57 static void gst_dshowvideosink_videooverlay_init (GstVideoOverlayInterface *iface);
  58 static void
  59 gst_dshowvideosink_navigation_interface_init (GstNavigationInterface * iface);
  60
  61 #define gst_dshowvideosink_parent_class parent_class
  62 G_DEFINE_TYPE_WITH_CODE (GstDshowVideoSink, gst_dshowvideosink,
  63                          GST_TYPE_VIDEO_SINK,
  64                          G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY, gst_dshowvideosink_videooverlay_init);
  65                          G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION, gst_dshowvideosink_navigation_interface_init))
  66
  67 enum
  68 {
  69   PROP_0,
  70   PROP_KEEP_ASPECT_RATIO,
  71   PROP_FULL_SCREEN,
  72   PROP_RENDERER
  73 };
  74
  75 /* GObject methods */
  76 static void gst_dshowvideosink_finalize (GObject * gobject);
  77 static void gst_dshowvideosink_set_property (GObject * object, guint prop_id,
  78     const GValue * value, GParamSpec * pspec);
  79 static void gst_dshowvideosink_get_property (GObject * object, guint prop_id,
  80     GValue * value, GParamSpec * pspec);
  81
  82 /* GstElement methods */
  83 static GstStateChangeReturn gst_dshowvideosink_change_state (GstElement * element, GstStateChange transition);
  84
  85 /* GstBaseSink methods */
  86 static gboolean gst_dshowvideosink_start (GstBaseSink * bsink);
  87 static gboolean gst_dshowvideosink_stop (GstBaseSink * bsink);
  88 static gboolean gst_dshowvideosink_unlock (GstBaseSink * bsink);
  89 static gboolean gst_dshowvideosink_unlock_stop (GstBaseSink * bsink);
  90 static gboolean gst_dshowvideosink_set_caps (GstBaseSink * bsink, GstCaps * caps);
  91 static GstCaps *gst_dshowvideosink_get_caps (GstBaseSink * bsink, GstCaps * filter);
  92 static GstFlowReturn gst_dshowvideosink_show_frame (GstVideoSink *sink, GstBuffer *buffer);
  93 static void gst_dshowvideosink_set_window_for_renderer (GstDshowVideoSink *sink);
  94
  95 /* COM initialization/uninitialization thread */
  96 static void gst_dshowvideosink_com_thread (GstDshowVideoSink * sink);
  97 /* TODO: event, preroll, buffer_alloc?
  98  * buffer_alloc won't generally be all that useful because the renderers require a
  99  * different stride to GStreamer's implicit values.
 100  */
 101
 102 static void
 103 gst_dshowvideosink_set_window_handle (GstVideoOverlay * overlay, guintptr window_id)
 104
 105 {
 106   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (overlay);
 107   HWND previous_window = sink->window_id;
 108   HWND videowindow = (HWND)window_id;
 109
 110   if (videowindow == sink->window_id) {
 111     GST_DEBUG_OBJECT (sink, "Window already set");
 112     return;
 113   }
 114
 115   sink->window_id = videowindow;
 116
 117   /* Update window if we're already playing. */
 118   if (sink->connected && sink->filter_media_event) {
 119     HRESULT hres;
 120
 121     if (sink->is_new_window) {
 122       /* If we created a new window */
 123       SendMessage (previous_window, WM_CLOSE, NULL, NULL);
 124       sink->is_new_window = FALSE;
 125       sink->window_closed = FALSE;
 126     } else {
 127       /* Return control of application window */
 128       SetWindowLongPtr (previous_window, GWLP_WNDPROC, (LONG_PTR)sink->prevWndProc);
 129       SetWindowPos (previous_window, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
 130     }
 131
 132     gst_dshowvideosink_set_window_for_renderer (sink);
 133
 134     hres = sink->filter_media_event->SetNotifyWindow ((OAHWND)sink->window_id, WM_GRAPH_NOTIFY, 0);
 135     GST_DEBUG_OBJECT (sink, "SetNotifyWindow(%p) returned %x", sink->window_id, hres);
 136   }
 137 }
 138
 139 static void
 140 gst_dshowvideosink_expose (GstVideoOverlay * overlay)
 141 {
 142   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (overlay);
 143
 144   if (sink->renderersupport) {
 145     sink->renderersupport->PaintWindow ();
 146   }
 147 }
 148
 149 static void
 150 gst_dshowvideosink_videooverlay_init (GstVideoOverlayInterface * iface)
 151 {
 152   iface->set_window_handle = gst_dshowvideosink_set_window_handle;
 153   iface->expose = gst_dshowvideosink_expose;
 154 }
 155
 156 static void
 157 gst_dshowvideosink_navigation_send_event (GstNavigation * navigation,
 158     GstStructure * structure)
 159 {
 160   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (navigation);
 161   GstEvent *event = NULL;
 162   GstPad *pad = NULL;
 163
 164   event = gst_event_new_navigation (structure);
 165
 166   /* FXIME: handle aspect ratio. */
 167
 168   pad = gst_pad_get_peer (GST_VIDEO_SINK_PAD (sink));
 169
 170   if (GST_IS_PAD (pad) && GST_IS_EVENT (event)) {
 171     gst_pad_send_event (pad, event);
 172
 173     gst_object_unref (pad);
 174   }
 175 }
 176
 177 static void
 178 gst_dshowvideosink_navigation_interface_init (GstNavigationInterface * iface)
 179 {
 180   /* FIXME: navigation interface partially implemented.
 181    * Need to call gst_navigation_send_mouse_event and
 182    * gst_navigation_send_key_event like in directdrawsink.
 183    */
 184   iface->send_event = gst_dshowvideosink_navigation_send_event;
 185 }
 186
 187 static void
 188 gst_dshowvideosink_class_init (GstDshowVideoSinkClass * klass)
 189 {
 190   GObjectClass *o_class;
 191   GstElementClass *e_class;
 192   GstBaseSinkClass *bs_class;
 193   GstVideoSinkClass *vs_class;
 194
 195   o_class = (GObjectClass *) klass;
 196   e_class = (GstElementClass *) klass;
 197   bs_class = (GstBaseSinkClass *) klass;
 198   vs_class = (GstVideoSinkClass *) klass;
 199
 200   o_class->finalize = gst_dshowvideosink_finalize;
 201   o_class->set_property = gst_dshowvideosink_set_property;
 202   o_class->get_property = gst_dshowvideosink_get_property;
 203
 204   gst_element_class_set_static_metadata (e_class, "DirectShow video sink",
 205       "Sink/Video", "Display data using a DirectShow video renderer",
 206       "Pioneers of the Inevitable <songbird@songbirdnest.com>, " \
 207       "FLUENDO S.A. <support@fluendo.com>");
 208
 209   gst_element_class_add_static_pad_template (e_class, &sink_template);
 210
 211   e_class->change_state = GST_DEBUG_FUNCPTR (gst_dshowvideosink_change_state);
 212
 213   bs_class->get_caps = GST_DEBUG_FUNCPTR (gst_dshowvideosink_get_caps);
 214   bs_class->set_caps = GST_DEBUG_FUNCPTR (gst_dshowvideosink_set_caps);
 215   bs_class->start = GST_DEBUG_FUNCPTR (gst_dshowvideosink_start);
 216   bs_class->stop = GST_DEBUG_FUNCPTR (gst_dshowvideosink_stop);
 217   bs_class->unlock = GST_DEBUG_FUNCPTR (gst_dshowvideosink_unlock);
 218   bs_class->unlock_stop =
 219       GST_DEBUG_FUNCPTR (gst_dshowvideosink_unlock_stop);
 220
 221   vs_class->show_frame = GST_DEBUG_FUNCPTR (gst_dshowvideosink_show_frame);
 222
 223   /* Add properties */
 224   g_object_class_install_property (G_OBJECT_CLASS (klass),
 225       PROP_KEEP_ASPECT_RATIO, g_param_spec_boolean ("force-aspect-ratio",
 226           "Force aspect ratio",
 227           "When enabled, scaling will respect original aspect ratio", TRUE,
 228           (GParamFlags)G_PARAM_READWRITE));
 229   g_object_class_install_property (G_OBJECT_CLASS (klass),
 230       PROP_FULL_SCREEN, g_param_spec_boolean ("fullscreen",
 231           "Full screen mode",
 232           "Use full-screen mode (not available when using XOverlay)", FALSE,
 233           (GParamFlags)G_PARAM_READWRITE));
 234
 235   g_object_class_install_property (G_OBJECT_CLASS (klass),
 236       PROP_RENDERER, g_param_spec_string ("renderer", "Renderer",
 237       "Force usage of specific DirectShow renderer (EVR, VMR9 or VMR7)",
 238       NULL, (GParamFlags)G_PARAM_READWRITE));
 239 }
 240
 241 static void
 242 gst_dshowvideosink_clear (GstDshowVideoSink *sink)
 243 {
 244   sink->renderersupport = NULL;
 245   sink->fakesrc = NULL;
 246   sink->filter_graph = NULL;
 247   sink->filter_media_event = NULL;
 248
 249   sink->keep_aspect_ratio = FALSE;
 250   sink->full_screen = FALSE;
 251
 252   sink->window_closed = FALSE;
 253   sink->window_id = NULL;
 254   sink->is_new_window = FALSE;
 255
 256   sink->connected = FALSE;
 257   sink->graph_running = FALSE;
 258 }
 259
 260 static void
 261 gst_dshowvideosink_init (GstDshowVideoSink * sink)
 262 {
 263   gst_dshowvideosink_clear (sink);
 264
 265   g_mutex_init (&sink->graph_lock);
 266   g_mutex_init (&sink->com_init_lock);
 267   g_mutex_init (&sink->com_deinit_lock);
 268   g_cond_init (&sink->com_initialized);
 269   g_cond_init (&sink->com_uninitialize);
 270   g_cond_init (&sink->com_uninitialized);
 271
 272   g_mutex_lock (&sink->com_init_lock);
 273
 274   /* create the COM initialization thread */
 275   g_thread_new ("gstdshowvideosinkcomthread", (GThreadFunc)gst_dshowvideosink_com_thread, sink);
 276
 277   /* wait until the COM thread signals that COM has been initialized */
 278   g_cond_wait (&sink->com_initialized, &sink->com_init_lock);
 279   g_mutex_unlock (&sink->com_init_lock);
 280 }
 281
 282 static void
 283 gst_dshowvideosink_finalize (GObject * gobject)
 284 {
 285   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (gobject);
 286
 287   g_free (sink->preferredrenderer);
 288
 289   /* signal the COM thread that it sould uninitialize COM */
 290   if (sink->comInitialized) {
 291     g_mutex_lock (&sink->com_deinit_lock);
 292     g_cond_signal (&sink->com_uninitialize);
 293     g_cond_wait (&sink->com_uninitialized, &sink->com_deinit_lock);
 294     g_mutex_unlock (&sink->com_deinit_lock);
 295   }
 296
 297   g_mutex_clear (&sink->com_init_lock);
 298   g_mutex_clear (&sink->com_deinit_lock);
 299   g_cond_clear (&sink->com_initialized);
 300   g_cond_clear (&sink->com_uninitialize);
 301   g_cond_clear (&sink->com_uninitialized);
 302
 303   g_mutex_clear (&sink->graph_lock);
 304
 305   G_OBJECT_CLASS (parent_class)->finalize (gobject);
 306 }
 307
 308 static void
 309 gst_dshowvideosink_set_property (GObject * object, guint prop_id,
 310     const GValue * value, GParamSpec * pspec)
 311 {
 312   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (object);
 313
 314   switch (prop_id) {
 315     case PROP_RENDERER:
 316       g_free (sink->preferredrenderer);
 317       sink->preferredrenderer = g_value_dup_string (value);
 318       break;
 319     case PROP_KEEP_ASPECT_RATIO:
 320       sink->keep_aspect_ratio = g_value_get_boolean (value);
 321       if (sink->renderersupport)
 322         sink->renderersupport->SetAspectRatioMode();
 323       break;
 324     case PROP_FULL_SCREEN:
 325       sink->full_screen = g_value_get_boolean (value);
 326       break;
 327     default:
 328       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 329       break;
 330   }
 331 }
 332
 333 static void
 334 gst_dshowvideosink_get_property (GObject * object, guint prop_id,
 335     GValue * value, GParamSpec * pspec)
 336 {
 337   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (object);
 338
 339   switch (prop_id) {
 340     case PROP_RENDERER:
 341       g_value_take_string (value, sink->preferredrenderer);
 342       break;
 343     case PROP_KEEP_ASPECT_RATIO:
 344       g_value_set_boolean (value, sink->keep_aspect_ratio);
 345       break;
 346     case PROP_FULL_SCREEN:
 347       g_value_set_boolean (value, sink->full_screen);
 348       break;
 349     default:
 350       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 351       break;
 352   }
 353 }
 354
 355 static void
 356 gst_dshowvideosink_com_thread (GstDshowVideoSink * sink)
 357 {
 358   HRESULT res;
 359
 360   g_mutex_lock (&sink->com_init_lock);
 361
 362   /* Initialize COM with a MTA for this process. This thread will
 363    * be the first one to enter the apartement and the last one to leave
 364    * it, unitializing COM properly */
 365
 366   res = CoInitializeEx (0, COINIT_MULTITHREADED);
 367   if (res == S_FALSE)
 368     GST_WARNING_OBJECT (sink, "COM has been already initialized in the same process");
 369   else if (res == RPC_E_CHANGED_MODE)
 370     GST_WARNING_OBJECT (sink, "The concurrency model of COM has changed.");
 371   else
 372     GST_INFO_OBJECT (sink, "COM initialized successfully");
 373
 374   sink->comInitialized = TRUE;
 375
 376   /* Signal other threads waiting on this condition that COM was initialized */
 377   g_cond_signal (&sink->com_initialized);
 378
 379   g_mutex_unlock (&sink->com_init_lock);
 380
 381   /* Wait until the uninitialize condition is met to leave the COM apartement */
 382   g_mutex_lock (&sink->com_deinit_lock);
 383   g_cond_wait (&sink->com_uninitialize, &sink->com_deinit_lock);
 384
 385   CoUninitialize ();
 386   GST_INFO_OBJECT (sink, "COM uninitialized successfully");
 387   sink->comInitialized = FALSE;
 388   g_cond_signal (&sink->com_uninitialized);
 389   g_mutex_unlock (&sink->com_deinit_lock);
 390 }
 391
 392 static GstCaps *
 393 gst_dshowvideosink_get_caps (GstBaseSink * basesink, GstCaps * filter)
 394 {
 395   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (basesink);
 396   GstCaps *ret = NULL;
 397
 398   return ret;
 399 }
 400
 401 static void dump_available_media_types (IPin *pin)
 402 {
 403   /* Enumerate all media types on this pin, output info about them */
 404   IEnumMediaTypes *enumerator = NULL;
 405   AM_MEDIA_TYPE *type;
 406   GstCaps *caps;
 407   int i = 0;
 408
 409   GST_INFO ("Enumerating media types on pin %p", pin);
 410
 411   pin->EnumMediaTypes (&enumerator);
 412
 413   while (enumerator->Next (1, &type, NULL) == S_OK) {
 414     i++;
 415     caps = gst_directshow_media_type_to_caps (type);
 416
 417     if (caps) {
 418       gchar *str = gst_caps_to_string (caps);
 419       GST_INFO ("Type %d: converted to caps \"%s\"", i, str);
 420       g_free (str);
 421
 422       gst_caps_unref (caps);
 423     }
 424     else
 425       GST_INFO ("Failed to convert type to GstCaps");
 426
 427     DeleteMediaType (type);
 428   }
 429   GST_INFO ("Enumeration complete");
 430
 431   enumerator->Release();
 432 }
 433
 434 static void
 435 dump_all_pin_media_types (IBaseFilter *filter)
 436 {
 437   IEnumPins *enumpins = NULL;
 438   IPin *pin = NULL;
 439   HRESULT hres;
 440
 441   hres = filter->EnumPins (&enumpins);
 442   if (FAILED(hres)) {
 443     GST_WARNING ("Cannot enumerate pins on filter");
 444     return;
 445   }
 446
 447   GST_INFO ("Enumerating pins on filter %p", filter);
 448   while (enumpins->Next (1, &pin, NULL) == S_OK)
 449   {
 450     IMemInputPin *meminputpin;
 451     PIN_DIRECTION pindir;
 452     hres = pin->QueryDirection (&pindir);
 453
 454     GST_INFO ("Found a pin with direction: %s", (pindir == PINDIR_INPUT)? "input": "output");
 455     dump_available_media_types (pin);
 456
 457     hres = pin->QueryInterface (
 458             IID_IMemInputPin, (void **) &meminputpin);
 459     if (hres == S_OK) {
 460       GST_INFO ("Pin is a MemInputPin (push mode): %p", meminputpin);
 461       meminputpin->Release();
 462     }
 463     else
 464       GST_INFO ("Pin is not a MemInputPin (pull mode?): %p", pin);
 465
 466     pin->Release();
 467   }
 468   enumpins->Release();
 469 }
 470
 471 gboolean
 472 gst_dshow_get_pin_from_filter (IBaseFilter *filter, PIN_DIRECTION pindir, IPin **pin)
 473 {
 474   gboolean ret = FALSE;
 475   IEnumPins *enumpins = NULL;
 476   IPin *pintmp = NULL;
 477   HRESULT hres;
 478   *pin = NULL;
 479
 480   hres = filter->EnumPins (&enumpins);
 481   if (FAILED(hres)) {
 482     return ret;
 483   }
 484
 485   while (enumpins->Next (1, &pintmp, NULL) == S_OK)
 486   {
 487     PIN_DIRECTION pindirtmp;
 488     hres = pintmp->QueryDirection (&pindirtmp);
 489     if (hres == S_OK && pindir == pindirtmp) {
 490       *pin = pintmp;
 491       ret = TRUE;
 492       break;
 493     }
 494     pintmp->Release ();
 495   }
 496   enumpins->Release ();
 497
 498   return ret;
 499 }
 500
 501 static void
 502 gst_dshowvideosink_handle_event (GstDshowVideoSink *sink)
 503 {
 504   if (sink->filter_media_event) {
 505     long evCode;
 506     LONG_PTR param1, param2;
 507     while (SUCCEEDED (sink->filter_media_event->GetEvent(&evCode, &param1, &param2, 0)))
 508     {
 509       GST_INFO_OBJECT (sink, "Received DirectShow graph event code 0x%x", evCode);
 510       sink->filter_media_event->FreeEventParams(evCode, param1, param2);
 511     }
 512   }
 513 }
 514
 515 /* WNDPROC for application-supplied windows */
 516 LRESULT APIENTRY WndProcHook (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 517 {
 518   /* Handle certain actions specially on the window passed to us.
 519    * Then forward back to the original window.
 520    */
 521   GstDshowVideoSink *sink = (GstDshowVideoSink *)GetProp (hWnd, (LPCSTR)"GstDShowVideoSink");
 522   g_assert (sink != NULL);
 523
 524   switch (message) {
 525     case WM_GRAPH_NOTIFY:
 526       gst_dshowvideosink_handle_event (sink);
 527       return 0;
 528     case WM_PAINT:
 529       sink->renderersupport->PaintWindow ();
 530       break;
 531     case WM_MOVE:
 532     case WM_SIZE:
 533       sink->renderersupport->MoveWindow ();
 534       break;
 535     case WM_DISPLAYCHANGE:
 536       sink->renderersupport->DisplayModeChanged();
 537       break;
 538     case WM_ERASEBKGND:
 539       /* DirectShow docs recommend ignoring this message to avoid flicker */
 540       return TRUE;
 541     case WM_CLOSE:
 542       sink->window_closed = TRUE;
 543   }
 544   return CallWindowProc (sink->prevWndProc, hWnd, message, wParam, lParam);
 545 }
 546
 547 /* WndProc for our default window, if the application didn't supply one */
 548 LRESULT APIENTRY
 549 WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 550 {
 551   GstDshowVideoSink *sink = (GstDshowVideoSink *)GetWindowLongPtr (hWnd, GWLP_USERDATA);
 552
 553   if (!sink) {
 554     /* I think these happen before we have a chance to set our userdata pointer */
 555     GST_DEBUG ("No sink!");
 556     return DefWindowProc (hWnd, message, wParam, lParam);
 557   }
 558
 559   //GST_DEBUG_OBJECT (sink, "Got a window message for %x, %x", hWnd, message);
 560
 561   switch (message) {
 562     case WM_GRAPH_NOTIFY:
 563       GST_LOG_OBJECT (sink, "GRAPH_NOTIFY WINDOW MESSAGE");
 564       gst_dshowvideosink_handle_event (sink);
 565       return 0;
 566     case WM_PAINT:
 567       sink->renderersupport->PaintWindow ();
 568       break;
 569     case WM_MOVE:
 570     case WM_SIZE:
 571       sink->renderersupport->MoveWindow ();
 572       break;
 573     case WM_DISPLAYCHANGE:
 574       sink->renderersupport->DisplayModeChanged();
 575       break;
 576     case WM_ERASEBKGND:
 577       /* DirectShow docs recommend ignoring this message */
 578       return TRUE;
 579     case WM_CLOSE:
 580       sink->renderersupport->DestroyWindow ();
 581       sink->window_closed = TRUE;
 582       PostQuitMessage (WM_QUIT);
 583       return 0;
 584   }
 585
 586   return DefWindowProc (hWnd, message, wParam, lParam);
 587 }
 588
 589 static gpointer
 590 gst_dshowvideosink_window_thread (GstDshowVideoSink * sink)
 591 {
 592   WNDCLASS WndClass;
 593   int width, height;
 594   int offx, offy;
 595   DWORD exstyle, style;
 596
 597   memset (&WndClass, 0, sizeof (WNDCLASS));
 598   WndClass.style = CS_HREDRAW | CS_VREDRAW;
 599   WndClass.hInstance = GetModuleHandle (NULL);
 600   WndClass.lpszClassName = (LPCSTR)"GST-DShowSink";
 601   WndClass.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
 602   WndClass.cbClsExtra = 0;
 603   WndClass.cbWndExtra = 0;
 604   WndClass.lpfnWndProc = WndProc;
 605   WndClass.hCursor = LoadCursor (NULL, IDC_ARROW);
 606   RegisterClass (&WndClass);
 607
 608   if (sink->full_screen) {
 609     /* This doesn't seem to work, it returns the wrong values! But when we
 610      * later use ShowWindow to show it maximized, it goes to full-screen
 611      * anyway. TODO: Figure out why. */
 612     width = GetSystemMetrics (SM_CXFULLSCREEN);
 613     height = GetSystemMetrics (SM_CYFULLSCREEN);
 614     offx = 0;
 615     offy = 0;
 616
 617     style = WS_POPUP; /* No window decorations */
 618     exstyle = 0;
 619   }
 620   else {
 621     /* By default, create a normal top-level window, the size
 622      * of the video.
 623      */
 624     RECT rect;
 625     AM_MEDIA_TYPE pmt = (AM_MEDIA_TYPE)sink->mediatype;
 626     VIDEOINFOHEADER *vi = (VIDEOINFOHEADER *)pmt.pbFormat;
 627
 628     if (vi == NULL)
 629     {
 630         GST_ELEMENT_ERROR (sink, RESOURCE, NOT_FOUND, ("Unknown media format"), (NULL));
 631         return NULL;
 632     }
 633
 634     /* rcTarget is the aspect-ratio-corrected size of the video. */
 635     width = vi->rcTarget.right + GetSystemMetrics (SM_CXSIZEFRAME) * 2;
 636     height = vi->rcTarget.bottom + GetSystemMetrics (SM_CYCAPTION) +
 637         (GetSystemMetrics (SM_CYSIZEFRAME) * 2);
 638
 639     SystemParametersInfo (SPI_GETWORKAREA, NULL, &rect, 0);
 640     int screenwidth = rect.right - rect.left;
 641     int screenheight = rect.bottom - rect.top;
 642     offx = rect.left;
 643     offy = rect.top;
 644
 645     /* Make it fit into the screen without changing the
 646      * aspect ratio. */
 647     if (width > screenwidth) {
 648       double ratio = (double)screenwidth/(double)width;
 649       width = screenwidth;
 650       height = (int)(height * ratio);
 651     }
 652     if (height > screenheight) {
 653       double ratio = (double)screenheight/(double)height;
 654       height = screenheight;
 655       width = (int)(width * ratio);
 656     }
 657
 658     style = WS_OVERLAPPEDWINDOW; /* Normal top-level window */
 659     exstyle = 0;
 660   }
 661
 662   HWND video_window = CreateWindowEx (exstyle, (LPCSTR)"GST-DShowSink",
 663       (LPCSTR)"GStreamer DirectShow sink default window",
 664       style, offx, offy, width, height, NULL, NULL,
 665       WndClass.hInstance, NULL);
 666   if (video_window == NULL) {
 667     GST_ERROR_OBJECT (sink, "Failed to create window!");
 668     return NULL;
 669   }
 670
 671   sink->is_new_window = TRUE;
 672
 673   SetWindowLongPtr (video_window, GWLP_USERDATA, (LONG_PTR)sink);
 674
 675   sink->window_id = video_window;
 676
 677   /* signal application we created a window */
 678   gst_video_overlay_got_window_handle (GST_VIDEO_OVERLAY (sink),
 679       (gulong)video_window);
 680
 681   /* Set the renderer's clipping window */
 682   if (!sink->renderersupport->SetRendererWindow (video_window)) {
 683     GST_WARNING_OBJECT (sink, "Failed to set video clipping window on filter %p", sink->renderersupport);
 684   }
 685
 686   /* Now show the window, as appropriate */
 687   if (sink->full_screen) {
 688     ShowWindow (video_window, SW_SHOWMAXIMIZED);
 689     ShowCursor (FALSE);
 690   }
 691   else
 692     ShowWindow (video_window, SW_SHOWNORMAL);
 693
 694   /* Trigger the initial paint of the window */
 695   UpdateWindow (video_window);
 696
 697   ReleaseSemaphore (sink->window_created_signal, 1, NULL);
 698
 699   /* start message loop processing our default window messages */
 700   while (1) {
 701     MSG msg;
 702
 703     if (GetMessage (&msg, video_window, 0, 0) <= 0) {
 704       GST_LOG_OBJECT (sink, "our window received WM_QUIT or error.");
 705       break;
 706     }
 707     DispatchMessage (&msg);
 708   }
 709
 710   return NULL;
 711 }
 712
 713 static gboolean
 714 gst_dshowvideosink_create_default_window (GstDshowVideoSink * sink)
 715 {
 716   sink->window_created_signal = CreateSemaphore (NULL, 0, 1, NULL);
 717   if (sink->window_created_signal == NULL)
 718     goto failed;
 719
 720   sink -> window_thread = g_thread_new ("windowthread",
 721                                         (GThreadFunc) gst_dshowvideosink_window_thread,
 722                                         sink);
 723
 724   /* wait maximum 10 seconds for window to be created */
 725   if (WaitForSingleObject (sink->window_created_signal,
 726           10000) != WAIT_OBJECT_0)
 727     goto failed;
 728
 729   CloseHandle (sink->window_created_signal);
 730   return TRUE;
 731
 732 failed:
 733   CloseHandle (sink->window_created_signal);
 734   GST_ELEMENT_ERROR (sink, RESOURCE, WRITE,
 735       ("Error creating our default window"), (NULL));
 736
 737   return FALSE;
 738 }
 739
 740 static void gst_dshowvideosink_set_window_for_renderer (GstDshowVideoSink *sink)
 741 {
 742   WNDPROC prevWndProc = (WNDPROC)GetWindowLongPtr (sink->window_id, GWLP_WNDPROC);
 743   if (prevWndProc == WndProcHook) {
 744     /* The WndProc already points to our hook. Something has gone wrong
 745      * somewhere else and this safety net prevents an infinite recursion */
 746     return;
 747   }
 748
 749   /* Application has requested a specific window ID */
 750   sink->prevWndProc = (WNDPROC) SetWindowLongPtr (sink->window_id, GWLP_WNDPROC, (LONG_PTR)WndProcHook);
 751   GST_DEBUG_OBJECT (sink, "Set wndproc to %p from %p", WndProcHook, sink->prevWndProc);
 752   SetProp (sink->window_id, (LPCSTR)"GstDShowVideoSink", sink);
 753   /* This causes the new WNDPROC to become active */
 754   SetWindowPos (sink->window_id, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
 755
 756   if (!sink->renderersupport->SetRendererWindow (sink->window_id)) {
 757     GST_WARNING_OBJECT (sink, "Failed to set HWND %x on renderer", sink->window_id);
 758     return;
 759   }
 760   sink->is_new_window = FALSE;
 761
 762   /* This tells the renderer where the window is located, needed to
 763    * start drawing in the right place.  */
 764   sink->renderersupport->MoveWindow();
 765   GST_INFO_OBJECT (sink, "Set renderer window to %x", sink->window_id);
 766 }
 767
 768 static void
 769 gst_dshowvideosink_prepare_window (GstDshowVideoSink *sink)
 770 {
 771   HRESULT hres;
 772
 773   /* Give the app a last chance to supply a window id */
 774   if (!sink->window_id) {
 775     gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (sink));
 776   }
 777
 778   /* If the app supplied one, use it. Otherwise, go ahead
 779    * and create (and use) our own window */
 780   if (sink->window_id) {
 781     gst_dshowvideosink_set_window_for_renderer (sink);
 782   }
 783   else {
 784     gst_dshowvideosink_create_default_window (sink);
 785   }
 786
 787   if (sink->filter_media_event) {
 788     sink->filter_media_event->Release();
 789     sink->filter_media_event = NULL;
 790   }
 791
 792   hres = sink->filter_graph->QueryInterface(
 793           IID_IMediaEventEx, (void **) &sink->filter_media_event);
 794
 795   if (FAILED (hres)) {
 796     GST_WARNING_OBJECT (sink, "Failed to get IMediaEventEx");
 797   }
 798   else {
 799     hres = sink->filter_media_event->SetNotifyWindow ((OAHWND)sink->window_id,
 800             WM_GRAPH_NOTIFY, 0);
 801     GST_DEBUG_OBJECT (sink, "SetNotifyWindow(%p) returned %x", sink->window_id, hres);
 802   }
 803 }
 804
 805 static gboolean
 806 gst_dshowvideosink_connect_graph (GstDshowVideoSink *sink)
 807 {
 808   HRESULT hres;
 809   IPin *srcpin;
 810   IPin *sinkpin;
 811
 812   GST_INFO_OBJECT (sink, "Connecting DirectShow pins");
 813
 814   srcpin = sink->fakesrc->GetOutputPin();
 815
 816   gst_dshow_get_pin_from_filter (sink->renderersupport->GetFilter(), PINDIR_INPUT,
 817       &sinkpin);
 818   if (!sinkpin) {
 819     GST_WARNING_OBJECT (sink, "Cannot get input pin from Renderer");
 820     return FALSE;
 821   }
 822
 823   /* Be warned that this call WILL deadlock unless you call it from
 824    * the main thread. Thus, we call this from the state change, not from
 825    * setcaps (which happens in a streaming thread).
 826    */
 827   hres = sink->filter_graph->ConnectDirect (
 828            srcpin, sinkpin, NULL);
 829   if (FAILED (hres)) {
 830     GST_WARNING_OBJECT (sink, "Could not connect pins: %x", hres);
 831     sinkpin->Release();
 832     return FALSE;
 833   }
 834   sinkpin->Release();
 835   return TRUE;
 836 }
 837
 838 static GstStateChangeReturn
 839 gst_dshowvideosink_start_graph (GstDshowVideoSink *sink)
 840 {
 841   IMediaControl *control = NULL;
 842   HRESULT hres;
 843   GstStateChangeReturn ret;
 844
 845   GST_DEBUG_OBJECT (sink, "Connecting and starting DirectShow graph");
 846
 847   hres = sink->filter_graph->QueryInterface(
 848           IID_IMediaControl, (void **) &control);
 849
 850   if (FAILED (hres)) {
 851     GST_WARNING_OBJECT (sink, "Failed to get IMediaControl interface");
 852     ret = GST_STATE_CHANGE_FAILURE;
 853     goto done;
 854   }
 855
 856   GST_INFO_OBJECT (sink, "Running DirectShow graph");
 857   hres = control->Run();
 858   if (FAILED (hres)) {
 859     GST_ERROR_OBJECT (sink,
 860         "Failed to run the directshow graph (error=%x)", hres);
 861     ret = GST_STATE_CHANGE_FAILURE;
 862     goto done;
 863   }
 864
 865   GST_DEBUG_OBJECT (sink, "DirectShow graph is now running");
 866   ret = GST_STATE_CHANGE_SUCCESS;
 867
 868 done:
 869   if (control)
 870     control->Release();
 871
 872   return ret;
 873 }
 874 static GstStateChangeReturn
 875 gst_dshowvideosink_pause_graph (GstDshowVideoSink *sink)
 876 {
 877   IMediaControl *control = NULL;
 878   GstStateChangeReturn ret;
 879   HRESULT hres;
 880
 881   hres = sink->filter_graph->QueryInterface(
 882           IID_IMediaControl, (void **) &control);
 883   if (FAILED (hres)) {
 884     GST_WARNING_OBJECT (sink, "Failed to get IMediaControl interface");
 885     ret = GST_STATE_CHANGE_FAILURE;
 886     goto done;
 887   }
 888
 889   GST_INFO_OBJECT (sink, "Pausing DirectShow graph");
 890   hres = control->Pause();
 891   if (FAILED (hres)) {
 892     GST_WARNING_OBJECT (sink,
 893         "Can't pause the directshow graph (error=%x)", hres);
 894     ret = GST_STATE_CHANGE_FAILURE;
 895     goto done;
 896   }
 897
 898   ret = GST_STATE_CHANGE_SUCCESS;
 899
 900 done:
 901   if (control)
 902     control->Release();
 903
 904   return ret;
 905 }
 906
 907 static GstStateChangeReturn
 908 gst_dshowvideosink_stop_graph (GstDshowVideoSink *sink)
 909 {
 910   IMediaControl *control = NULL;
 911   GstStateChangeReturn ret;
 912   HRESULT hres;
 913   IPin *sinkpin;
 914
 915   hres = sink->filter_graph->QueryInterface(
 916           IID_IMediaControl, (void **) &control);
 917   if (FAILED (hres)) {
 918     GST_WARNING_OBJECT (sink, "Failed to get IMediaControl interface");
 919     ret = GST_STATE_CHANGE_FAILURE;
 920     goto done;
 921   }
 922
 923   GST_INFO_OBJECT (sink, "Stopping DirectShow graph");
 924   hres = control->Stop();
 925   if (FAILED (hres)) {
 926     GST_WARNING_OBJECT (sink,
 927         "Can't stop the directshow graph (error=%x)", hres);
 928     ret = GST_STATE_CHANGE_FAILURE;
 929     goto done;
 930   }
 931
 932   sink->filter_graph->Disconnect(sink->fakesrc->GetOutputPin());
 933
 934   gst_dshow_get_pin_from_filter (sink->renderersupport->GetFilter(), PINDIR_INPUT,
 935       &sinkpin);
 936   sink->filter_graph->Disconnect(sinkpin);
 937   sinkpin->Release();
 938
 939   GST_DEBUG_OBJECT (sink, "DirectShow graph has stopped");
 940
 941   if (sink->window_id) {
 942     /* Return control of application window */
 943     SetWindowLongPtr (sink->window_id, GWLP_WNDPROC, (LONG_PTR)sink->prevWndProc);
 944     RemoveProp (sink->window_id, (LPCSTR)"GstDShowVideoSink");
 945     SetWindowPos (sink->window_id, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
 946     sink->prevWndProc = NULL;
 947   }
 948   sink->connected = FALSE;
 949
 950   ret = GST_STATE_CHANGE_SUCCESS;
 951
 952 done:
 953   if (control)
 954     control->Release();
 955
 956   return ret;
 957 }
 958
 959 static GstStateChangeReturn
 960 gst_dshowvideosink_change_state (GstElement * element, GstStateChange transition)
 961 {
 962   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (element);
 963   GstStateChangeReturn ret, rettmp;
 964
 965   switch (transition) {
 966     case GST_STATE_CHANGE_NULL_TO_READY:
 967       break;
 968     case GST_STATE_CHANGE_READY_TO_PAUSED:
 969       break;
 970     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 971       ret = gst_dshowvideosink_start_graph (sink);
 972       if (ret == GST_STATE_CHANGE_FAILURE)
 973         return ret;
 974       sink->graph_running = TRUE;
 975       break;
 976     default:
 977       break;
 978   }
 979
 980   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 981
 982   switch (transition) {
 983     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 984       GST_DSHOWVIDEOSINK_GRAPH_LOCK(sink);
 985       rettmp = gst_dshowvideosink_pause_graph (sink);
 986       if (rettmp == GST_STATE_CHANGE_FAILURE)
 987         ret = rettmp;
 988       sink->graph_running = FALSE;
 989       GST_DSHOWVIDEOSINK_GRAPH_UNLOCK(sink);
 990       break;
 991     case GST_STATE_CHANGE_PAUSED_TO_READY:
 992       GST_DSHOWVIDEOSINK_GRAPH_LOCK(sink);
 993       rettmp = gst_dshowvideosink_stop_graph (sink);
 994       if (rettmp == GST_STATE_CHANGE_FAILURE)
 995         ret = rettmp;
 996       sink->graph_running = FALSE;
 997       GST_DSHOWVIDEOSINK_GRAPH_UNLOCK(sink);
 998       break;
 999     case GST_STATE_CHANGE_READY_TO_NULL:
1000       gst_dshowvideosink_clear (sink);
1001       break;
1002     default:
1003       break;
1004   }
1005
1006   return ret;
1007 }
1008
1009 class EVRSupport : public RendererSupport
1010 {
1011 private:
1012   GstDshowVideoSink *sink;
1013   IBaseFilter *filter;
1014   IMFGetService *service;
1015   IMFVideoDisplayControl *control;
1016   HWND video_window;
1017
1018 public:
1019   EVRSupport (GstDshowVideoSink *sink) :
1020       sink(sink),
1021       filter(NULL),
1022       service(NULL),
1023       control(NULL)
1024   {
1025   }
1026
1027   ~EVRSupport() {
1028     if (control)
1029       control->Release();
1030     if (service)
1031       service->Release();
1032     if (filter)
1033       filter->Release();
1034   }
1035
1036   const char *GetName() {
1037     return "EnhancedVideoRenderer";
1038   }
1039
1040   IBaseFilter *GetFilter() {
1041     return filter;
1042   }
1043
1044   gboolean CheckOS () {
1045     OSVERSIONINFO info;
1046     info.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
1047     GetVersionEx (&info);
1048
1049     if (info.dwMajorVersion < 6) {
1050       return false;
1051     }
1052     else {
1053       return true;
1054     }
1055   }
1056
1057   gboolean Configure() {
1058     HRESULT hres;
1059
1060     if (!this->CheckOS ()) {
1061       GST_DEBUG_OBJECT (sink, "Windows Vista is required at least for EVR to work");
1062       return FALSE;
1063     }
1064
1065     hres = CoCreateInstance (CLSID_EnhancedVideoRenderer, NULL, CLSCTX_INPROC,
1066         IID_IBaseFilter, (LPVOID *) &filter);
1067     GST_DEBUG_OBJECT (sink, "cocreateinstance returned %d", hres);
1068     if (FAILED (hres)) {
1069       GST_ERROR_OBJECT (sink,
1070           "Can't create an instance of renderer (error=%x)",
1071           hres);
1072       return FALSE;
1073     }
1074
1075     hres = filter->QueryInterface (IID_IMFGetService,
1076           (void **) &service);
1077     if (FAILED (hres)) {
1078       GST_WARNING_OBJECT (sink, "EVR service interface missing: %x", hres);
1079       return FALSE;
1080     }
1081
1082     hres = service->GetService (MR_VIDEO_RENDER_SERVICE,
1083           IID_IMFVideoDisplayControl, (void **) &control);
1084     if (FAILED (hres)) {
1085       GST_WARNING_OBJECT (sink, "EVR control service missing: %x", hres);
1086       return FALSE;
1087     }
1088
1089     SetAspectRatioMode();
1090     return TRUE;
1091   }
1092
1093   void SetAspectRatioMode() {
1094     if (sink->keep_aspect_ratio) {
1095       control->SetAspectRatioMode(MFVideoARMode_PreservePicture);
1096     }
1097     else {
1098       control->SetAspectRatioMode(MFVideoARMode_None);
1099     }
1100   }
1101
1102   gboolean SetRendererWindow(HWND window) {
1103     video_window = window;
1104     HRESULT hres = control->SetVideoWindow (video_window);
1105     if (FAILED (hres)) {
1106       GST_WARNING_OBJECT (sink, "Failed to set video clipping window on filter %p: %x", filter, hres);
1107       return FALSE;
1108     }
1109     return TRUE;
1110   }
1111
1112   void PaintWindow()
1113   {
1114     HRESULT hr;
1115     PAINTSTRUCT ps;
1116     HDC         hdc;
1117     RECT        rcClient;
1118
1119     GetClientRect(video_window, &rcClient);
1120     hdc = BeginPaint(video_window, &ps);
1121
1122     hr = control->RepaintVideo();
1123
1124     EndPaint(video_window, &ps);
1125   }
1126
1127   void MoveWindow()
1128   {
1129     HRESULT hr;
1130     RECT rect;
1131
1132     // Track the movement of the container window and resize as needed
1133     GetClientRect(video_window, &rect);
1134     hr = control->SetVideoPosition(NULL, &rect);
1135   }
1136
1137   void DisplayModeChanged() {
1138   }
1139
1140   void DestroyWindow() {
1141     ::DestroyWindow (video_window);
1142   }
1143 };
1144
1145 class VMR9Support : public RendererSupport
1146 {
1147 private:
1148   GstDshowVideoSink *sink;
1149   IBaseFilter *filter;
1150   IVMRWindowlessControl9 *control;
1151   IVMRFilterConfig9 *config;
1152   HWND video_window;
1153
1154 public:
1155   VMR9Support (GstDshowVideoSink *sink) :
1156       sink(sink),
1157       filter(NULL),
1158       control(NULL),
1159       config(NULL)
1160   {
1161   }
1162
1163   ~VMR9Support() {
1164     if (control)
1165       control->Release();
1166     if (config)
1167       config->Release();
1168     if (filter)
1169       filter->Release();
1170   }
1171
1172   const char *GetName() {
1173     return "VideoMixingRenderer9";
1174   }
1175
1176   IBaseFilter *GetFilter() {
1177     return filter;
1178   }
1179
1180   gboolean Configure() {
1181     HRESULT hres;
1182
1183     hres = CoCreateInstance (CLSID_VideoMixingRenderer9, NULL, CLSCTX_INPROC,
1184         IID_IBaseFilter, (LPVOID *) &filter);
1185     if (FAILED (hres)) {
1186       GST_ERROR_OBJECT (sink,
1187           "Can't create an instance of renderer (error=%x)",
1188           hres);
1189       return FALSE;
1190     }
1191
1192     hres = filter->QueryInterface (
1193           IID_IVMRFilterConfig9, (void **) &config);
1194     if (FAILED (hres)) {
1195       GST_WARNING_OBJECT (sink, "VMR9 filter config interface missing: %x", hres);
1196       return FALSE;
1197     }
1198
1199     hres = config->SetRenderingMode (VMR9Mode_Windowless);
1200     if (FAILED (hres)) {
1201       GST_WARNING_OBJECT (sink, "VMR9 couldn't be set to windowless mode: %x", hres);
1202       return FALSE;
1203     }
1204     else {
1205       GST_DEBUG_OBJECT (sink, "Set VMR9 (%p) to windowless mode!", filter);
1206     }
1207
1208     /* We can't QI to this until _after_ we've been set to windowless mode.
1209      * Apparently this is against the rules in COM, but that's how it is... */
1210     hres = filter->QueryInterface (
1211           IID_IVMRWindowlessControl9, (void **) &control);
1212     if (FAILED (hres)) {
1213       GST_WARNING_OBJECT (sink, "VMR9 windowless control interface missing: %x", hres);
1214       return FALSE;
1215     }
1216
1217     SetAspectRatioMode();
1218     return TRUE;
1219   }
1220
1221   void SetAspectRatioMode() {
1222     if (sink->keep_aspect_ratio) {
1223       control->SetAspectRatioMode(VMR9ARMode_LetterBox);
1224     }
1225     else {
1226       control->SetAspectRatioMode(VMR9ARMode_None);
1227     }
1228   }
1229
1230   gboolean SetRendererWindow(HWND window) {
1231     video_window = window;
1232     HRESULT hres = control->SetVideoClippingWindow (video_window);
1233     if (FAILED (hres)) {
1234       GST_WARNING_OBJECT (sink, "Failed to set video clipping window on filter %p: %x", filter, hres);
1235       return FALSE;
1236     }
1237     return TRUE;
1238   }
1239
1240   void PaintWindow()
1241   {
1242     HRESULT hr;
1243     PAINTSTRUCT ps;
1244     HDC         hdc;
1245     RECT        rcClient;
1246
1247     GetClientRect(video_window, &rcClient);
1248     hdc = BeginPaint(video_window, &ps);
1249
1250     hr = control->RepaintVideo(video_window, hdc);
1251
1252     EndPaint(video_window, &ps);
1253   }
1254
1255   void MoveWindow()
1256   {
1257     HRESULT hr;
1258     RECT rect;
1259
1260     // Track the movement of the container window and resize as needed
1261     GetClientRect(video_window, &rect);
1262     hr = control->SetVideoPosition(NULL, &rect);
1263   }
1264
1265   void DisplayModeChanged() {
1266     control->DisplayModeChanged();
1267   }
1268
1269   void DestroyWindow() {
1270     ::DestroyWindow (video_window);
1271   }
1272 };
1273
1274 class VMR7Support : public RendererSupport
1275 {
1276 private:
1277   GstDshowVideoSink *sink;
1278   IBaseFilter *filter;
1279   IVMRWindowlessControl *control;
1280   IVMRFilterConfig *config;
1281   HWND video_window;
1282
1283 public:
1284   VMR7Support (GstDshowVideoSink *sink) :
1285       sink(sink),
1286       filter(NULL),
1287       control(NULL),
1288       config(NULL)
1289   {
1290   }
1291
1292   ~VMR7Support() {
1293     if (control)
1294       control->Release();
1295     if (config)
1296       config->Release();
1297     if (filter)
1298       filter->Release();
1299   }
1300
1301   const char *GetName() {
1302     return "VideoMixingRenderer";
1303   }
1304
1305   IBaseFilter *GetFilter() {
1306     return filter;
1307   }
1308
1309   gboolean Configure() {
1310     HRESULT hres;
1311
1312     hres = CoCreateInstance (CLSID_VideoMixingRenderer, NULL, CLSCTX_INPROC,
1313         IID_IBaseFilter, (LPVOID *) &filter);
1314     if (FAILED (hres)) {
1315       GST_ERROR_OBJECT (sink,
1316           "Can't create an instance of renderer (error=%x)",
1317           hres);
1318       return FALSE;
1319     }
1320
1321     hres = filter->QueryInterface (
1322           IID_IVMRFilterConfig, (void **) &config);
1323     if (FAILED (hres)) {
1324       GST_WARNING_OBJECT (sink, "VMR filter config interface missing: %x", hres);
1325       return FALSE;
1326     }
1327
1328     hres = config->SetRenderingMode (VMRMode_Windowless);
1329     if (FAILED (hres)) {
1330       GST_WARNING_OBJECT (sink, "VMR couldn't be set to windowless mode: %x", hres);
1331       return FALSE;
1332     }
1333     else {
1334       GST_DEBUG_OBJECT (sink, "Set VMR (%p) to windowless mode!", filter);
1335     }
1336
1337     hres = filter->QueryInterface (
1338           IID_IVMRWindowlessControl, (void **) &control);
1339     if (FAILED (hres)) {
1340       GST_WARNING_OBJECT (sink, "VMR windowless control interface missing: %x", hres);
1341       return FALSE;
1342     }
1343
1344     SetAspectRatioMode();
1345     return TRUE;
1346   }
1347
1348   void SetAspectRatioMode() {
1349     if (sink->keep_aspect_ratio) {
1350       control->SetAspectRatioMode(VMR_ARMODE_LETTER_BOX);
1351     }
1352     else {
1353       control->SetAspectRatioMode(VMR_ARMODE_NONE);
1354     }
1355   }
1356
1357   gboolean SetRendererWindow(HWND window) {
1358     video_window = window;
1359     HRESULT hres = control->SetVideoClippingWindow (video_window);
1360     if (FAILED (hres)) {
1361       GST_WARNING_OBJECT (sink, "Failed to set video clipping window on filter %p: %x", filter, hres);
1362       return FALSE;
1363     }
1364     return TRUE;
1365   }
1366
1367   void PaintWindow()
1368   {
1369     HRESULT hr;
1370     PAINTSTRUCT ps;
1371     HDC         hdc;
1372     RECT        rcClient;
1373
1374     GetClientRect(video_window, &rcClient);
1375     hdc = BeginPaint(video_window, &ps);
1376
1377     hr = control->RepaintVideo(video_window, hdc);
1378
1379     EndPaint(video_window, &ps);
1380   }
1381
1382   void MoveWindow()
1383   {
1384     HRESULT hr;
1385     RECT rect;
1386
1387     // Track the movement of the container window and resize as needed
1388     GetClientRect(video_window, &rect);
1389     hr = control->SetVideoPosition(NULL, &rect);
1390   }
1391
1392   void DisplayModeChanged() {
1393     control->DisplayModeChanged();
1394   }
1395
1396   void DestroyWindow() {
1397     ::DestroyWindow (video_window);
1398   }
1399 };
1400
1401 static gboolean
1402 gst_dshowvideosink_create_renderer (GstDshowVideoSink *sink)
1403 {
1404   GST_DEBUG_OBJECT (sink, "Trying to create renderer '%s'", "EVR");
1405
1406   RendererSupport *support = NULL;
1407
1408   if (sink->preferredrenderer) {
1409     if (!strcmp (sink->preferredrenderer, "EVR")) {
1410       GST_INFO_OBJECT (sink, "Forcing use of EVR");
1411       support = new EVRSupport (sink);
1412     }
1413     else if (!strcmp (sink->preferredrenderer, "VMR9")) {
1414       GST_INFO_OBJECT (sink, "Forcing use of VMR9");
1415       support = new VMR9Support (sink);
1416     }
1417     else if (!strcmp (sink->preferredrenderer, "VMR")) {
1418       GST_INFO_OBJECT (sink, "Forcing use of VMR");
1419       support = new VMR7Support (sink);
1420     }
1421     else {
1422       GST_ERROR_OBJECT (sink, "Unknown sink type '%s'", sink->preferredrenderer);
1423       return FALSE;
1424     }
1425
1426     if (!support->Configure()) {
1427       GST_ERROR_OBJECT (sink, "Couldn't configure selected renderer");
1428       delete support;
1429       return FALSE;
1430     }
1431     goto done;
1432   }
1433
1434   support = new EVRSupport (sink);
1435   if (!support->Configure ()) {
1436     GST_INFO_OBJECT (sink, "Failed to configure EVR, trying VMR9");
1437     delete support;
1438     support = new VMR9Support (sink);
1439     if (!support->Configure()) {
1440       GST_INFO_OBJECT (sink, "Failed to configure VMR9, trying VMR7");
1441       delete support;
1442       support = new VMR7Support (sink);
1443       if (!support->Configure()) {
1444         GST_ERROR_OBJECT (sink, "Failed to configure VMR9 or VMR7");
1445         delete support;
1446         return FALSE;
1447       }
1448     }
1449   }
1450
1451 done:
1452   sink->renderersupport = support;
1453   return TRUE;
1454 }
1455
1456 static gboolean
1457 gst_dshowvideosink_build_filtergraph (GstDshowVideoSink *sink)
1458 {
1459   HRESULT hres;
1460
1461   /* Build our DirectShow FilterGraph, looking like:
1462    *
1463    *    [ fakesrc ] -> [ sink filter ]
1464    *
1465    * so we can feed data in through the fakesrc.
1466    *
1467    * The sink filter can be one of our supported filters: VMR9 (VMR7?, EMR?)
1468    */
1469
1470   hres = CoCreateInstance (CLSID_FilterGraph, NULL, CLSCTX_INPROC,
1471       IID_IFilterGraph, (LPVOID *) & sink->filter_graph);
1472   if (FAILED (hres)) {
1473     GST_ERROR_OBJECT (sink,
1474           "Can't create an instance of the dshow graph manager (error=%x)", hres);
1475     goto error;
1476   }
1477
1478   sink->fakesrc = new VideoFakeSrc();
1479
1480   IBaseFilter *filter;
1481   hres = sink->fakesrc->QueryInterface (
1482           IID_IBaseFilter, (void **) &filter);
1483   if (FAILED (hres)) {
1484     GST_ERROR_OBJECT (sink, "Could not QI fakesrc to IBaseFilter");
1485     goto error;
1486   }
1487
1488   hres = sink->filter_graph->AddFilter (filter, L"fakesrc");
1489   if (FAILED (hres)) {
1490     GST_ERROR_OBJECT (sink,
1491         "Can't add our fakesrc filter to the graph (error=%x)", hres);
1492     goto error;
1493   }
1494
1495   if (!gst_dshowvideosink_create_renderer (sink)) {
1496     GST_ERROR_OBJECT (sink, "Could not create a video renderer");
1497     goto error;
1498   }
1499
1500   /* dump_all_pin_media_types (sink->renderer); */
1501
1502   hres =
1503       sink->filter_graph->AddFilter (sink->renderersupport->GetFilter(),
1504       L"renderer");
1505   if (FAILED (hres)) {
1506     GST_ERROR_OBJECT (sink,
1507           "Can't add renderer to the graph (error=%x)", hres);
1508     goto error;
1509   }
1510
1511   return TRUE;
1512
1513 error:
1514   if (sink->fakesrc) {
1515     sink->fakesrc->Release();
1516     sink->fakesrc = NULL;
1517   }
1518
1519   if (sink->filter_graph) {
1520     sink->filter_graph->Release();
1521     sink->filter_graph = NULL;
1522   }
1523
1524   if (sink->filter_media_event) {
1525     sink->filter_media_event->Release();
1526     sink->filter_media_event = NULL;
1527   }
1528
1529   return FALSE;
1530 }
1531
1532 static gboolean
1533 gst_dshowvideosink_start (GstBaseSink * bsink)
1534 {
1535   HRESULT hres = S_FALSE;
1536   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (bsink);
1537
1538   /* Just build the filtergraph; we don't link or otherwise configure it yet */
1539   return gst_dshowvideosink_build_filtergraph (sink);
1540 }
1541
1542 static gboolean
1543 gst_dshowvideosink_set_caps (GstBaseSink * bsink, GstCaps * caps)
1544 {
1545   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (bsink);
1546
1547   if (sink->connected) {
1548       IPin *sinkpin;
1549       sink->filter_graph->Disconnect(sink->fakesrc->GetOutputPin());
1550       gst_dshow_get_pin_from_filter (sink->renderersupport->GetFilter(), PINDIR_INPUT,
1551           &sinkpin);
1552       sink->filter_graph->Disconnect(sinkpin);
1553       sinkpin->Release();
1554   }
1555
1556   if (!gst_caps_to_directshow_media_type (sink, caps, &sink->mediatype)) {
1557     GST_WARNING_OBJECT (sink, "Cannot convert caps to AM_MEDIA_TYPE, rejecting");
1558     return FALSE;
1559   }
1560
1561   GST_DEBUG_OBJECT (sink, "Configuring output pin media type");
1562   /* Now we have an AM_MEDIA_TYPE describing what we're going to send.
1563    * We set this on our DirectShow fakesrc's output pin.
1564    */
1565   sink->fakesrc->GetOutputPin()->SetMediaType (&sink->mediatype);
1566   GST_DEBUG_OBJECT (sink, "Configured output pin media type");
1567
1568   /* We have configured the output pin media type.
1569   * So, create a window (or start using an application-supplied
1570   * one, then connect the graph */
1571   gst_dshowvideosink_prepare_window (sink);
1572   if (!gst_dshowvideosink_connect_graph (sink)) {
1573     GST_ELEMENT_ERROR (sink, CORE, NEGOTIATION,
1574           ("Failed to initialize DirectShow graph with the input caps"), (NULL));
1575     return FALSE;
1576   }
1577   sink->connected = TRUE;
1578
1579   return TRUE;
1580 }
1581
1582 static gboolean
1583 gst_dshowvideosink_stop (GstBaseSink * bsink)
1584 {
1585   IPin *input_pin = NULL, *output_pin = NULL;
1586   HRESULT hres = S_FALSE;
1587   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (bsink);
1588
1589   if (!sink->filter_graph) {
1590     GST_WARNING_OBJECT (sink, "Cannot destroy filter graph; it doesn't exist");
1591     return TRUE;
1592   }
1593
1594   /* If we created a new window, send the close message and wait until
1595    * it's closed in the window thread */
1596   if (sink->is_new_window) {
1597     SendMessage (sink->window_id, WM_CLOSE, NULL, NULL);
1598     while (!sink->window_closed);
1599     sink->is_new_window = FALSE;
1600   }
1601
1602   /* Release the renderer */
1603   if (sink->renderersupport) {
1604     delete sink->renderersupport;
1605     sink->renderersupport = NULL;
1606   }
1607
1608   /* Release our dshow fakesrc */
1609   if (sink->fakesrc) {
1610     sink->fakesrc->Release();
1611     sink->fakesrc = NULL;
1612   }
1613
1614   /* Release the filter graph manager */
1615   if (sink->filter_graph) {
1616     sink->filter_graph->Release();
1617     sink->filter_graph = NULL;
1618   }
1619
1620   if (sink->filter_media_event) {
1621     sink->filter_media_event->Release();
1622     sink->filter_media_event = NULL;
1623   }
1624
1625   return TRUE;
1626 }
1627
1628 static GstFlowReturn
1629 gst_dshowvideosink_show_frame (GstVideoSink *vsink, GstBuffer *buffer)
1630 {
1631   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (vsink);
1632   GstFlowReturn ret;
1633   GstStateChangeReturn retst;
1634
1635   if (sink->window_closed) {
1636     GST_ELEMENT_ERROR (sink, RESOURCE, NOT_FOUND, ("Output window was closed"), (NULL));
1637     return GST_FLOW_ERROR;
1638   }
1639
1640   GST_DEBUG_OBJECT (sink, "Pushing buffer through fakesrc->renderer");
1641   GST_DSHOWVIDEOSINK_GRAPH_LOCK(sink);
1642   if (!sink->graph_running){
1643     retst = gst_dshowvideosink_start_graph(sink);
1644     if (retst == GST_STATE_CHANGE_FAILURE)
1645       return GST_FLOW_FLUSHING;
1646   }
1647   ret = sink->fakesrc->GetOutputPin()->PushBuffer (buffer);
1648   if (!sink->graph_running){
1649     retst = gst_dshowvideosink_pause_graph(sink);
1650     if (retst == GST_STATE_CHANGE_FAILURE)
1651       return GST_FLOW_FLUSHING;
1652   }
1653   GST_DSHOWVIDEOSINK_GRAPH_UNLOCK(sink);
1654   GST_DEBUG_OBJECT (sink, "Done pushing buffer through fakesrc->renderer: %s", gst_flow_get_name(ret));
1655
1656   return ret;
1657 }
1658
1659 /* TODO: How can we implement these? Figure that out... */
1660 static gboolean
1661 gst_dshowvideosink_unlock (GstBaseSink * bsink)
1662 {
1663   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (bsink);
1664
1665   return TRUE;
1666 }
1667
1668 static gboolean
1669 gst_dshowvideosink_unlock_stop (GstBaseSink * bsink)
1670 {
1671   GstDshowVideoSink *sink = GST_DSHOWVIDEOSINK (bsink);
1672
1673   return TRUE;
1674 }
1675
1676 /* TODO: Move all of this into generic code? */
1677
1678 /* Helpers to format GUIDs the same way we find them in the source */
1679 #define GUID_FORMAT "{%.8x, %.4x, %.4x, { %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x }}"
1680 #define GUID_ARGS(guid) \
1681     guid.Data1, guid.Data2, guid.Data3, \
1682     guid.Data4[0], guid.Data4[1], guid.Data4[3], guid.Data4[4], \
1683     guid.Data4[5], guid.Data4[6], guid.Data4[7], guid.Data4[8]
1684
1685 static GstCaps *
1686 audio_media_type_to_caps (AM_MEDIA_TYPE *mediatype)
1687 {
1688   return NULL;
1689 }
1690
1691 static GstCaps *
1692 video_media_type_to_caps (AM_MEDIA_TYPE *mediatype)
1693 {
1694   GstCaps *caps = NULL;
1695
1696   /* TODO: Add  RGB types. */
1697   if (IsEqualGUID (mediatype->subtype, MEDIASUBTYPE_YUY2))
1698     caps = gst_caps_new_simple ("video/x-raw",
1699             "format", GST_TYPE_VIDEO_FORMAT, GST_VIDEO_FORMAT_YUY2, NULL);
1700   else if (IsEqualGUID (mediatype->subtype, MEDIASUBTYPE_UYVY))
1701     caps = gst_caps_new_simple ("video/x-raw",
1702             "format", GST_TYPE_VIDEO_FORMAT, GST_VIDEO_FORMAT_UYVY, NULL);
1703   else if (IsEqualGUID (mediatype->subtype, MEDIASUBTYPE_YV12))
1704     caps = gst_caps_new_simple ("video/x-raw",
1705             "format", GST_TYPE_VIDEO_FORMAT, GST_VIDEO_FORMAT_YV12, NULL);
1706
1707   if (!caps) {
1708     GST_DEBUG ("No subtype known; cannot continue");
1709     return NULL;
1710   }
1711
1712   if (IsEqualGUID (mediatype->formattype, FORMAT_VideoInfo) &&
1713           mediatype->cbFormat >= sizeof(VIDEOINFOHEADER))
1714   {
1715     VIDEOINFOHEADER *vh = (VIDEOINFOHEADER *)mediatype->pbFormat;
1716
1717         /* TODO: Set PAR here. Based on difference between source and target RECTs?
1718      *       Do we want framerate? Based on AvgTimePerFrame? */
1719     gst_caps_set_simple (caps,
1720             "width", G_TYPE_INT, vh->bmiHeader.biWidth,
1721             "height", G_TYPE_INT, vh->bmiHeader.biHeight,
1722                         NULL);
1723   }
1724
1725   return caps;
1726 }
1727
1728
1729 /* Create a GstCaps object representing the same media type as
1730  * this AM_MEDIA_TYPE.
1731  *
1732  * Returns NULL if no corresponding GStreamer type is known.
1733  *
1734  * May modify mediatype.
1735  */
1736 static GstCaps *
1737 gst_directshow_media_type_to_caps (AM_MEDIA_TYPE *mediatype)
1738 {
1739   GstCaps *caps = NULL;
1740
1741   if (IsEqualGUID (mediatype->majortype, MEDIATYPE_Video))
1742     caps = video_media_type_to_caps (mediatype);
1743   else if (IsEqualGUID (mediatype->majortype, MEDIATYPE_Audio))
1744     caps = audio_media_type_to_caps (mediatype);
1745   else {
1746     GST_DEBUG ("Non audio/video media types not yet " \
1747         "recognised, please add me: " GUID_FORMAT,
1748         GUID_ARGS(mediatype->majortype));
1749   }
1750
1751   if (caps) {
1752     gchar *capsstring = gst_caps_to_string (caps);
1753     GST_DEBUG ("Converted AM_MEDIA_TYPE to \"%s\"", capsstring);
1754     g_free (capsstring);
1755   }
1756   else {
1757     GST_WARNING ("Failed to convert AM_MEDIA_TYPE to caps");
1758   }
1759
1760   return caps;
1761 }
1762
1763 /* Fill in a DirectShow AM_MEDIA_TYPE structure representing the same media
1764  * type as this GstCaps object.
1765  *
1766  * Returns FALSE if no corresponding type is known.
1767  *
1768  * Only operates on simple (single structure) caps.
1769  */
1770 static gboolean
1771 gst_caps_to_directshow_media_type (GstDshowVideoSink * sink, GstCaps *caps,
1772     AM_MEDIA_TYPE *mediatype)
1773 {
1774   GstVideoInfo info;
1775   int width, height;
1776   int bpp;
1777
1778   gst_video_info_init (&info);
1779   if (!gst_video_info_from_caps (&info, caps))
1780   {
1781     GST_WARNING_OBJECT (sink, "Couldn't parse caps");
1782       return FALSE;
1783   }
1784   memset (mediatype, 0, sizeof (AM_MEDIA_TYPE));
1785
1786   if (GST_VIDEO_FORMAT_INFO_IS_YUV (info.finfo))
1787   {
1788     guint32 fourcc;
1789     GST_VIDEO_SINK_WIDTH (sink) = info.width;
1790     GST_VIDEO_SINK_HEIGHT (sink) = info.height;
1791     width = info.width;
1792     height = info.height;
1793     mediatype->majortype = MEDIATYPE_Video;
1794
1795     switch (GST_VIDEO_INFO_FORMAT (&info))
1796     {
1797         case GST_VIDEO_FORMAT_YUY2:
1798           mediatype->subtype = MEDIASUBTYPE_YUY2;
1799           fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
1800           bpp = 16;
1801           break;
1802         case GST_VIDEO_FORMAT_UYVY:
1803           mediatype->subtype = MEDIASUBTYPE_UYVY;
1804           fourcc = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
1805           bpp = 16;
1806           break;
1807         case GST_VIDEO_FORMAT_YV12:
1808           mediatype->subtype = MEDIASUBTYPE_YV12;
1809           fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
1810           bpp = 12;
1811           break;
1812         default:
1813           GST_WARNING_OBJECT (sink, "Couldn't parse caps");
1814           return FALSE;
1815     }
1816
1817     mediatype->bFixedSizeSamples = TRUE; /* Always true for raw video */
1818     mediatype->bTemporalCompression = FALSE; /* Likewise, always false */
1819
1820     {
1821       int par_n, par_d;
1822       VIDEOINFOHEADER *vi = (VIDEOINFOHEADER *)CoTaskMemAlloc (sizeof (VIDEOINFOHEADER));
1823       memset (vi, 0, sizeof (VIDEOINFOHEADER));
1824
1825       mediatype->formattype = FORMAT_VideoInfo;
1826       mediatype->cbFormat = sizeof (VIDEOINFOHEADER);
1827       mediatype->pbFormat = (BYTE *)vi;
1828
1829       mediatype->lSampleSize = width * height * bpp / 8;
1830
1831       GST_INFO_OBJECT (sink, "Set mediatype format: size %d, sample size %d",
1832           mediatype->cbFormat, mediatype->lSampleSize);
1833
1834       vi->rcSource.top = 0;
1835       vi->rcSource.left = 0;
1836       vi->rcSource.bottom = height;
1837       vi->rcSource.right = width;
1838
1839       vi->rcTarget.top = 0;
1840       vi->rcTarget.left = 0;
1841       if (sink->keep_aspect_ratio) {
1842         par_n = GST_VIDEO_INFO_PAR_N (&info);
1843         par_d = GST_VIDEO_INFO_PAR_D (&info);
1844         /* To handle non-square pixels, we set the target rectangle to a
1845          * different size than the source rectangle.
1846          * There might be a better way, but this seems to work. */
1847         vi->rcTarget.bottom = height;
1848         vi->rcTarget.right = width * par_n / par_d;
1849         GST_DEBUG_OBJECT (sink, "Got PAR: set target right to %d from width %d",
1850             vi->rcTarget.right, width);
1851       }
1852       else {
1853         vi->rcTarget.bottom = height;
1854         vi->rcTarget.right = width;
1855       }
1856
1857       vi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
1858       vi->bmiHeader.biWidth = width;
1859       vi->bmiHeader.biHeight = -height; /* Required to be negative. */
1860       vi->bmiHeader.biPlanes = 1; /* Required to be 1 */
1861       vi->bmiHeader.biBitCount = bpp;
1862       vi->bmiHeader.biCompression = fourcc;
1863       vi->bmiHeader.biSizeImage = width * height * bpp / 8;
1864
1865       /* We can safely zero these; they don't matter for our uses */
1866       vi->bmiHeader.biXPelsPerMeter = 0;
1867       vi->bmiHeader.biYPelsPerMeter = 0;
1868       vi->bmiHeader.biClrUsed = 0;
1869       vi->bmiHeader.biClrImportant = 0;
1870     }
1871
1872     GST_DEBUG_OBJECT (sink, "Successfully built AM_MEDIA_TYPE from caps");
1873     return TRUE;
1874   }
1875
1876   GST_WARNING_OBJECT (sink, "Failed to convert caps, not a known caps type");
1877   /* Only YUV supported so far */
1878
1879   return FALSE;
1880 }
1881
1882 /* Plugin entry point */
1883 extern "C" static gboolean
1884 plugin_init (GstPlugin * plugin)
1885 {
1886   /* PRIMARY: this is the best videosink to use on windows */
1887   if (!gst_element_register (plugin, "dshowvideosink",
1888           GST_RANK_SECONDARY, GST_TYPE_DSHOWVIDEOSINK))
1889     return FALSE;
1890
1891   return TRUE;
1892 }
1893
1894 extern "C" GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1895     GST_VERSION_MINOR,
1896     dshowsinkwrapper,
1897     "DirectShow sink wrapper plugin",
1898     plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)