--- /dev/null
+/*
+ * GStreamer
+ * Copyright (C) 2022 Seungha Yang <seungha@centricular.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+#include <gst/d3d11/gstd3d11.h>
+#include <gst/app/app.h>
+#include <windows.h>
+#include <wrl.h>
+#include <string>
+#include <d3d11_1.h>
+#include <dxgi1_2.h>
+
+/* *INDENT-OFF* */
+using namespace Microsoft::WRL;
+/* *INDENT-ON* */
+
+#define APP_DATA_PROP_NAME "AppData"
+
+typedef struct
+{
+ GMainLoop *loop;
+ GstElement *pipeline;
+ GstD3D11Device *d3d11_device;
+
+ LUID luid;
+
+ IDXGIFactory1 *factory;
+ ID3D11Device *device;
+ ID3D11DeviceContext *context;
+
+ ID3D11VideoDevice *video_device;
+ ID3D11VideoContext1 *video_context;
+ ID3D11VideoProcessorEnumerator *proc_enum;
+ ID3D11VideoProcessor *processor;
+
+ IDXGISwapChain1 *swapchain;
+ ID3D11VideoProcessorOutputView *pov;
+
+ guint window_width;
+ guint window_height;
+
+ HWND hwnd;
+} AppData;
+
+static bool
+create_device (AppData * data)
+{
+ ComPtr < IDXGIFactory1 > factory;
+ ComPtr < ID3D11Device > device;
+ ComPtr < ID3D11DeviceContext > context;
+ ComPtr < IDXGIAdapter1 > adapter;
+ HRESULT hr;
+ DXGI_ADAPTER_DESC1 desc;
+ static const D3D_FEATURE_LEVEL feature_levels[] = {
+ D3D_FEATURE_LEVEL_11_1,
+ D3D_FEATURE_LEVEL_11_0,
+ D3D_FEATURE_LEVEL_10_1,
+ D3D_FEATURE_LEVEL_10_0,
+ };
+
+ hr = CreateDXGIFactory1 (IID_PPV_ARGS (&factory));
+ if (FAILED (hr))
+ return false;
+
+ /* Find hardware adapter */
+ for (guint i = 0; SUCCEEDED (hr); i++) {
+
+ hr = factory->EnumAdapters1 (i, &adapter);
+ if (FAILED (hr))
+ return false;
+
+ hr = adapter->GetDesc1 (&desc);
+ if (FAILED (hr))
+ return false;
+
+ /* DXGI_ADAPTER_FLAG_SOFTWARE, old mingw does not define this enum */
+ if ((desc.Flags & 0x2) == 0)
+ break;
+
+ adapter = nullptr;
+ }
+
+ if (!adapter)
+ return false;
+
+ hr = D3D11CreateDevice (adapter.Get (), D3D_DRIVER_TYPE_UNKNOWN,
+ nullptr, D3D11_CREATE_DEVICE_BGRA_SUPPORT,
+ feature_levels,
+ G_N_ELEMENTS (feature_levels), D3D11_SDK_VERSION, &device, nullptr,
+ &context);
+
+ if (FAILED (hr))
+ return false;
+
+ data->factory = factory.Detach ();
+ data->device = device.Detach ();
+ data->context = context.Detach ();
+ data->luid = desc.AdapterLuid;
+
+ return true;
+}
+
+static bool
+find_decoder (gint64 luid, std::string & feature_name)
+{
+ GList *features;
+ GList *iter;
+
+ /* Load features of d3d11 plugin */
+ features = gst_registry_get_feature_list_by_plugin (gst_registry_get (),
+ "d3d11");
+
+ if (!features)
+ return false;
+
+ for (iter = features; iter; iter = g_list_next (iter)) {
+ GstPluginFeature *f = GST_PLUGIN_FEATURE (iter->data);
+ GstElementFactory *factory;
+ const gchar *name;
+ GstElement *element;
+ gint64 adapter_luid;
+
+ if (!GST_IS_ELEMENT_FACTORY (f))
+ continue;
+
+ factory = GST_ELEMENT_FACTORY (f);
+ if (!gst_element_factory_list_is_type (factory,
+ GST_ELEMENT_FACTORY_TYPE_DECODER))
+ continue;
+
+ name = gst_plugin_feature_get_name (f);
+ if (!g_strrstr (name, "h264"))
+ continue;
+
+ element = gst_element_factory_create (factory, nullptr);
+ /* unexpected */
+ if (!element)
+ continue;
+
+ /* query adapter-luid associated with this decoder */
+ g_object_get (element, "adapter-luid", &adapter_luid, nullptr);
+ gst_object_unref (element);
+
+ /* element object can be directly used in pipeline, but this example
+ * demonstrates a way of plugin enumeration */
+ if (adapter_luid == luid) {
+ feature_name = name;
+ break;
+ }
+ }
+
+ gst_plugin_feature_list_free (features);
+
+ if (feature_name.empty ())
+ return false;
+
+ return true;
+}
+
+static bool
+create_video_processor (AppData * data)
+{
+ ComPtr < ID3D11VideoDevice > video_device;
+ ComPtr < ID3D11VideoContext1 > video_context;
+ ComPtr < ID3D11VideoProcessorEnumerator > proc_enum;
+ ComPtr < ID3D11VideoProcessor > processor;
+ D3D11_VIDEO_PROCESSOR_CONTENT_DESC desc = { 0, };
+ HRESULT hr;
+
+ hr = data->device->QueryInterface (IID_PPV_ARGS (&video_device));
+ if (FAILED (hr))
+ return false;
+
+ hr = data->context->QueryInterface (IID_PPV_ARGS (&video_context));
+ if (FAILED (hr))
+ return false;
+
+ memset (&desc, 0, sizeof (desc));
+
+ /* resolution here is not that important */
+ desc.InputWidth = desc.OutputWidth = 640;
+ desc.InputHeight = desc.OutputHeight = 480;
+ desc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
+ desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
+
+ hr = video_device->CreateVideoProcessorEnumerator (&desc, &proc_enum);
+ if (FAILED (hr))
+ return false;
+
+ hr = video_device->CreateVideoProcessor (proc_enum.Get (), 0, &processor);
+ if (FAILED (hr))
+ return false;
+
+ video_context->VideoProcessorSetStreamColorSpace1 (processor.Get (),
+ 0, DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709);
+ video_context->VideoProcessorSetOutputColorSpace1 (processor.Get (),
+ DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709);
+
+ data->video_device = video_device.Detach ();
+ data->video_context = video_context.Detach ();
+ data->proc_enum = proc_enum.Detach ();
+ data->processor = processor.Detach ();
+
+ return true;
+}
+
+static gboolean
+bus_handler (GstBus * bus, GstMessage * msg, AppData * app_data)
+{
+ switch (GST_MESSAGE_TYPE (msg)) {
+ case GST_MESSAGE_ERROR:{
+ GError *err;
+ gchar *dbg;
+
+ gst_message_parse_error (msg, &err, &dbg);
+ gst_printerrln ("ERROR %s", err->message);
+ if (dbg != nullptr)
+ gst_printerrln ("ERROR debug information: %s", dbg);
+ g_clear_error (&err);
+ g_free (dbg);
+
+ g_main_loop_quit (app_data->loop);
+ break;
+ }
+ case GST_MESSAGE_EOS:
+ gst_println ("Got EOS");
+ g_main_loop_quit (app_data->loop);
+ break;
+ default:
+ break;
+ }
+
+ return TRUE;
+}
+
+static GstBusSyncReply
+bus_sync_handler (GstBus * bus, GstMessage * msg, AppData * data)
+{
+ const gchar *context_type;
+ GstContext *context;
+ gchar *context_str;
+
+ switch (GST_MESSAGE_TYPE (msg)) {
+ case GST_MESSAGE_HAVE_CONTEXT:{
+ gchar *context_str;
+
+ gst_message_parse_have_context (msg, &context);
+
+ context_type = gst_context_get_context_type (context);
+ context_str =
+ gst_structure_to_string (gst_context_get_structure (context));
+ gst_println ("Got context from element '%s': %s=%s",
+ GST_ELEMENT_NAME (GST_MESSAGE_SRC (msg)), context_type, context_str);
+ g_free (context_str);
+ gst_context_unref (context);
+ break;
+ }
+ case GST_MESSAGE_NEED_CONTEXT:{
+ gst_message_parse_context_type (msg, &context_type);
+ if (g_strcmp0 (context_type, GST_D3D11_DEVICE_HANDLE_CONTEXT_TYPE) != 0)
+ return GST_BUS_PASS;
+
+ context = gst_d3d11_context_new (data->d3d11_device);
+ context_str =
+ gst_structure_to_string (gst_context_get_structure (context));
+ gst_println ("Setting context '%s': %s=%s",
+ GST_ELEMENT_NAME (GST_MESSAGE_SRC (msg)), context_type, context_str);
+ g_free (context_str);
+ gst_element_set_context (GST_ELEMENT (msg->src), context);
+ gst_context_unref (context);
+ break;
+ }
+ default:
+ break;
+ }
+
+ return GST_BUS_PASS;
+}
+
+static GstFlowReturn
+on_new_sample (GstAppSink * appsink, gpointer user_data)
+{
+ AppData *app_data = (AppData *) user_data;
+ ID3D11VideoContext1 *video_context = app_data->video_context;
+ ID3D11VideoProcessor *processor = app_data->processor;
+ ID3D11VideoProcessorOutputView *pov = app_data->pov;
+ GstSample *sample = gst_app_sink_pull_sample (appsink);
+ GstCaps *caps;
+ GstBuffer *buffer;
+ GstVideoInfo video_info;
+ GstMemory *mem;
+ GstD3D11Memory *dmem;
+ ComPtr < ID3D11VideoProcessorInputView > piv;
+ D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC desc;
+ guint subresource_index;
+ HRESULT hr;
+ GstMapInfo info;
+ GstMapFlags map_flags;
+ ID3D11Texture2D *texture;
+ RECT src_rect, dest_rect;
+ D3D11_VIDEO_PROCESSOR_STREAM stream = { 0, };
+ GstVideoRectangle s, d, r;
+
+ if (!sample)
+ return GST_FLOW_ERROR;
+
+ buffer = gst_sample_get_buffer (sample);
+ if (!buffer) {
+ gst_sample_unref (sample);
+ return GST_FLOW_OK;
+ }
+
+ caps = gst_sample_get_caps (sample);
+ if (!caps) {
+ gst_sample_unref (sample);
+ return GST_FLOW_OK;
+ }
+
+ if (!gst_video_info_from_caps (&video_info, caps)) {
+ gst_printerrln ("Invalid caps");
+ return GST_FLOW_ERROR;
+ }
+
+ mem = gst_buffer_peek_memory (buffer, 0);
+ if (!mem) {
+ gst_printerrln ("Empty buffer");
+ gst_sample_unref (sample);
+ return GST_FLOW_ERROR;
+ }
+
+ /* memory must be d3d11 memory */
+ if (!gst_is_d3d11_memory (mem)) {
+ gst_printerrln ("Not a d3d11 memory");
+ gst_sample_unref (sample);
+ return GST_FLOW_ERROR;
+ }
+
+ dmem = GST_D3D11_MEMORY_CAST (mem);
+ /* decoder output texture may be texture array. Application should check
+ * subresource index */
+ subresource_index = gst_d3d11_memory_get_subresource_index (dmem);
+
+ /* Use GST_MAP_D3D11 flag to indicate that direct Direct3D11 resource
+ * is required instead of system memory access.
+ *
+ * CAUTION: Application must not try to write/modify texture rendered by
+ * video decoder since it's likely a reference frame. If it's modified by
+ * application, then the other decoded frames would be broken.
+ * Only read access is allowed in this case */
+ map_flags = (GstMapFlags) (GST_MAP_READ | GST_MAP_D3D11);
+
+ if (!gst_memory_map (mem, &info, map_flags)) {
+ gst_printerrln ("Couldn't map d3d11 memory");
+ gst_sample_unref (sample);
+ return GST_FLOW_ERROR;
+ }
+
+ texture = (ID3D11Texture2D *) info.data;
+
+ desc.FourCC = 0;
+ desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
+ desc.Texture2D.MipSlice = 0;
+ desc.Texture2D.ArraySlice = subresource_index;
+
+ hr = app_data->video_device->CreateVideoProcessorInputView (texture,
+ app_data->proc_enum, &desc, &piv);
+ if (FAILED (hr)) {
+ gst_printerrln ("Couldn't create PIV");
+ gst_memory_unmap (mem, &info);
+ gst_sample_unref (sample);
+ return GST_FLOW_ERROR;
+ }
+
+ /* DXGI, ID3D11DeviceContext, and ID3D11VideoContext APIs are not thread-safe.
+ * Application should take d3d11 device lock */
+ gst_d3d11_device_lock (app_data->d3d11_device);
+
+ /* calculates destination render rectangle to keep aspect ratio */
+ if (app_data->window_width == 0 || app_data->window_height == 0) {
+ /* No client area to draw */
+ goto out;
+ }
+
+ s.x = 0;
+ s.y = 0;
+ s.w = GST_VIDEO_INFO_WIDTH (&video_info);
+ s.h = GST_VIDEO_INFO_HEIGHT (&video_info);
+
+ d.x = 0;
+ d.y = 0;
+ d.w = app_data->window_width;
+ d.h = app_data->window_height;
+
+ gst_video_center_rect (&s, &d, &r, TRUE);
+
+ src_rect.left = 0;
+ src_rect.top = 0;
+ src_rect.right = GST_VIDEO_INFO_WIDTH (&video_info);
+ src_rect.bottom = GST_VIDEO_INFO_HEIGHT (&video_info);
+
+ dest_rect.left = r.x;
+ dest_rect.top = r.y;
+ dest_rect.right = r.x + r.w;
+ dest_rect.bottom = r.y + r.h;
+
+ /* Converts YUV -> RGBA using processor */
+ stream.Enable = TRUE;
+ stream.pInputSurface = piv.Get ();
+
+ video_context->VideoProcessorSetStreamSourceRect (processor, 0, TRUE,
+ &src_rect);
+ video_context->VideoProcessorSetStreamDestRect (processor,
+ 0, TRUE, &dest_rect);
+ video_context->VideoProcessorSetOutputTargetRect (processor,
+ TRUE, &dest_rect);
+ video_context->VideoProcessorBlt (processor, pov, 0, 1, &stream);
+ app_data->swapchain->Present (0, 0);
+
+out:
+ gst_d3d11_device_unlock (app_data->d3d11_device);
+ gst_memory_unmap (mem, &info);
+ gst_sample_unref (sample);
+
+ return GST_FLOW_OK;
+}
+
+static bool
+create_pipelne (const std::string & decoder_name,
+ const gchar * location, AppData * app_data)
+{
+ GstElement *pipeline;
+ GstElement *sink;
+ std::string pipeline_str;
+ GError *error = nullptr;
+ GstCaps *caps;
+ GstBus *bus;
+ GstAppSinkCallbacks callbacks = { nullptr };
+
+ pipeline_str = "filesrc location=" + std::string (location) +
+ " ! parsebin ! " + decoder_name + " ! queue ! appsink name=sink";
+ gst_println ("Creating pipeline %s", pipeline_str.c_str ());
+
+ pipeline = gst_parse_launch (pipeline_str.c_str (), &error);
+ if (error) {
+ gst_printerrln ("Couldn't create pipeline: %s", error->message);
+ g_clear_error (&error);
+ return false;
+ }
+
+ sink = gst_bin_get_by_name (GST_BIN (pipeline), "sink");
+
+ callbacks.new_sample = on_new_sample;
+ gst_app_sink_set_callbacks (GST_APP_SINK (sink),
+ &callbacks, app_data, nullptr);
+
+ /* Set d3d11 caps to appsink so that d3d11 decoder can decide output
+ * memory type as d3d11, not system memory.
+ * In case that downstream does not support d3d11 memory feature,
+ * d3d11 decoder elements will output system memory
+ */
+ caps = gst_caps_from_string ("video/x-raw(memory:D3D11Memory)");
+ g_object_set (sink, "caps", caps, nullptr);
+ gst_caps_unref (caps);
+ gst_object_unref (sink);
+
+ app_data->pipeline = pipeline;
+
+ bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
+
+ /* Listen need-context message from sync handler in case that application
+ * wants to share application's d3d11 device with pipeline */
+ gst_bus_set_sync_handler (bus, (GstBusSyncHandler) bus_sync_handler, app_data,
+ nullptr);
+ gst_bus_add_watch (bus, (GstBusFunc) bus_handler, app_data);
+ gst_object_unref (bus);
+
+ return true;
+}
+
+static void
+handle_window_resize (AppData * app_data)
+{
+ HRESULT hr;
+ ComPtr < ID3D11Texture2D > backbuffer;
+ D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC pov_desc;
+ D3D11_TEXTURE2D_DESC desc;
+
+ if (!app_data->device || !app_data->swapchain ||
+ !app_data->video_device || !app_data->video_context
+ || !app_data->proc_enum || !app_data->processor)
+ return;
+
+ /* DXGI and ID3D11DeviceContext APIs are not thread-safe.
+ * Application must take gst_d3d11_device_lock() in those case */
+ gst_d3d11_device_lock (app_data->d3d11_device);
+
+ /* Clear previously configured POV if any */
+ if (app_data->pov)
+ app_data->pov->Release ();
+ app_data->pov = nullptr;
+
+ hr = app_data->swapchain->ResizeBuffers (0,
+ 0, 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0);
+ if (FAILED (hr)) {
+ gst_printerrln ("Failed to resize swapchain buffers");
+ gst_d3d11_device_unlock (app_data->d3d11_device);
+ exit (1);
+ }
+
+ hr = app_data->swapchain->GetBuffer (0, IID_PPV_ARGS (&backbuffer));
+ if (FAILED (hr)) {
+ gst_printerrln ("Failed to get swapchain backbuffer");
+ gst_d3d11_device_unlock (app_data->d3d11_device);
+ exit (1);
+ }
+
+ backbuffer->GetDesc (&desc);
+
+ pov_desc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D;
+ pov_desc.Texture2D.MipSlice = 0;
+
+ hr = app_data->video_device->
+ CreateVideoProcessorOutputView (backbuffer.Get (), app_data->proc_enum,
+ &pov_desc, &app_data->pov);
+ if (FAILED (hr)) {
+ gst_printerrln ("Failed to create POV");
+ gst_d3d11_device_unlock (app_data->d3d11_device);
+ exit (1);
+ }
+
+ app_data->window_width = desc.Width;
+ app_data->window_height = desc.Height;
+ gst_d3d11_device_unlock (app_data->d3d11_device);
+}
+
+static LRESULT CALLBACK
+window_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message) {
+ case WM_DESTROY:{
+ AppData *app_data = (AppData *) GetPropA (hwnd, APP_DATA_PROP_NAME);
+ if (app_data) {
+ app_data->hwnd = nullptr;
+ if (app_data->loop)
+ g_main_loop_quit (app_data->loop);
+ }
+ break;
+ }
+ case WM_SIZE:{
+ AppData *app_data = (AppData *) GetPropA (hwnd, APP_DATA_PROP_NAME);
+ if (!app_data)
+ break;
+
+ handle_window_resize (app_data);
+ break;
+ }
+ default:
+ break;
+ }
+
+ return DefWindowProc (hwnd, message, wParam, lParam);
+}
+
+static gboolean
+msg_cb (GIOChannel * source, GIOCondition condition, gpointer data)
+{
+ MSG msg;
+
+ if (!PeekMessage (&msg, nullptr, 0, 0, PM_REMOVE))
+ return G_SOURCE_CONTINUE;
+
+ TranslateMessage (&msg);
+ DispatchMessage (&msg);
+
+ return G_SOURCE_CONTINUE;
+}
+
+static HWND
+create_window (void)
+{
+ RECT wr = { 0, 0, 320, 240 };
+ WNDCLASSEXA wc = { 0, };
+ HINSTANCE hinstance = GetModuleHandle (nullptr);
+
+ wc.cbSize = sizeof (WNDCLASSEXA);
+ wc.style = CS_HREDRAW | CS_VREDRAW;
+ wc.lpfnWndProc = (WNDPROC) window_proc;
+ wc.hInstance = hinstance;
+ wc.hCursor = LoadCursor (nullptr, IDC_ARROW);
+ wc.lpszClassName = "GstD3D11VideoSinkExample";
+ RegisterClassExA (&wc);
+
+ AdjustWindowRect (&wr, WS_OVERLAPPEDWINDOW, FALSE);
+ return CreateWindowExA (0, wc.lpszClassName, "GstD3D11VideoDecodeExample",
+ WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,
+ CW_USEDEFAULT, CW_USEDEFAULT,
+ wr.right - wr.left, wr.bottom - wr.top, (HWND) nullptr, (HMENU) nullptr,
+ hinstance, nullptr);
+}
+
+static bool
+create_swapchain (AppData * data)
+{
+ DXGI_SWAP_CHAIN_DESC1 desc = { 0, };
+ ComPtr < IDXGIFactory2 > factory2;
+ ComPtr < IDXGISwapChain1 > swapchain;
+ HRESULT hr;
+
+ hr = data->factory->QueryInterface (IID_PPV_ARGS (&factory2));
+ if (FAILED (hr))
+ return false;
+
+ desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ desc.SampleDesc.Count = 1;
+ desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ desc.BufferCount = 2;
+ desc.Scaling = DXGI_SCALING_NONE;
+ desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+ desc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;
+
+ hr = factory2->CreateSwapChainForHwnd (data->device, data->hwnd, &desc,
+ nullptr, nullptr, &swapchain);
+ if (FAILED (hr))
+ return false;
+
+ data->swapchain = swapchain.Detach ();
+
+ return true;
+}
+
+gint
+main (gint argc, gchar ** argv)
+{
+ GIOChannel *msg_io_channel = nullptr;
+ GOptionContext *option_ctx;
+ GError *error = nullptr;
+ gboolean ret;
+ gchar *location = nullptr;
+ GOptionEntry options[] = {
+ {"location", 0, 0, G_OPTION_ARG_STRING, &location,
+ "H.264 encoded test file location", nullptr},
+ {nullptr,}
+ };
+ gint64 luid;
+ std::string decoder_name;
+ AppData app_data = { nullptr, };
+
+ option_ctx = g_option_context_new ("Direct3D11 decoding example");
+ g_option_context_add_main_entries (option_ctx, options, nullptr);
+ g_option_context_add_group (option_ctx, gst_init_get_option_group ());
+ ret = g_option_context_parse (option_ctx, &argc, &argv, &error);
+ g_option_context_free (option_ctx);
+
+ if (!ret) {
+ gst_printerrln ("option parsing failed: %s", error->message);
+ g_clear_error (&error);
+ exit (1);
+ }
+
+ if (!location) {
+ gst_printerrln ("File location is unspecified");
+ exit (1);
+ }
+
+ app_data.loop = g_main_loop_new (nullptr, FALSE);
+
+ /* Create D3D11 device */
+ if (!create_device (&app_data)) {
+ gst_printerrln ("No available hardware device");
+ exit (1);
+ }
+
+ /* Creates GstD3D11Device using our device handle.
+ * Note that gst_d3d11_device_new_wrapped() method does not take ownership of
+ * ID3D11Device handle, instead refcount of ID3D11Device handle will be
+ * increased by one */
+ app_data.d3d11_device = gst_d3d11_device_new_wrapped (app_data.device);
+ if (!app_data.d3d11_device) {
+ gst_printerrln ("Couldn't create GstD3D11Device object");
+ exit (1);
+ }
+
+ /* Setup video processor for YUV -> RGBA conversion, since swapchain
+ * used in this example supports only RGBA rendering */
+ if (!create_video_processor (&app_data)) {
+ gst_printerrln ("Couldn't setup video processor for colorspace conversion");
+ exit (1);
+ }
+
+ /* Creates window and swapchain */
+ app_data.hwnd = create_window ();
+ if (!app_data.hwnd) {
+ gst_printerrln ("Couldn't create window handle");
+ exit (1);
+ }
+ SetPropA (app_data.hwnd, APP_DATA_PROP_NAME, &app_data);
+
+ msg_io_channel = g_io_channel_win32_new_messages (0);
+ g_io_add_watch (msg_io_channel, G_IO_IN, msg_cb, NULL);
+
+ if (!create_swapchain (&app_data)) {
+ gst_printerrln ("Couldn't create swapchain");
+ exit (1);
+ }
+
+ /* Calls this manually for POV to be configured */
+ handle_window_resize (&app_data);
+
+ /* All the required preperation for rendering is done.
+ * Setup GStreamer pipeline now */
+ /* converts LUID to int64 and enumerates decoders */
+ luid = gst_d3d11_luid_to_int64 (&app_data.luid);
+ if (!find_decoder (luid, decoder_name)) {
+ gst_printerrln ("Unable to find h264 decoder element to use");
+ exit (1);
+ }
+
+ gst_println ("Target decoder name: %s", decoder_name.c_str ());
+ if (!create_pipelne (decoder_name, location, &app_data))
+ exit (1);
+
+ /* All done! */
+ gst_element_set_state (app_data.pipeline, GST_STATE_PLAYING);
+ ShowWindow (app_data.hwnd, SW_SHOW);
+ g_main_loop_run (app_data.loop);
+
+ gst_element_set_state (app_data.pipeline, GST_STATE_NULL);
+ gst_bus_remove_watch (GST_ELEMENT_BUS (app_data.pipeline));
+
+#define CLEAR_COM(obj) G_STMT_START { \
+ if (obj) { \
+ (obj)->Release (); \
+ } \
+ } G_STMT_END
+
+ CLEAR_COM (app_data.pov);
+ CLEAR_COM (app_data.swapchain);
+ CLEAR_COM (app_data.processor);
+ CLEAR_COM (app_data.proc_enum);
+ CLEAR_COM (app_data.video_context);
+ CLEAR_COM (app_data.video_device);
+ CLEAR_COM (app_data.context);
+ CLEAR_COM (app_data.device);
+ CLEAR_COM (app_data.factory);
+
+ if (app_data.hwnd)
+ DestroyWindow (app_data.hwnd);
+
+ gst_clear_object (&app_data.d3d11_device);
+ gst_clear_object (&app_data.pipeline);
+
+ if (msg_io_channel)
+ g_io_channel_unref (msg_io_channel);
+ g_main_loop_unref (app_data.loop);
+
+ g_free (location);
+
+ return 0;
+}
-if host_system == 'windows'
- executable('d3d11videosink',
- ['d3d11videosink.c', '../key-handler.c'],
- c_args : gst_plugins_bad_args,
- include_directories : [configinc, libsinc],
- dependencies: [gst_dep, gstbase_dep, gstvideo_dep],
- install: false,
- )
+if host_system != 'windows'
+ subdir_done()
+endif
+
+executable('d3d11videosink',
+ ['d3d11videosink.c', '../key-handler.c'],
+ c_args : gst_plugins_bad_args,
+ include_directories : [configinc, libsinc],
+ dependencies: [gst_dep, gstbase_dep, gstvideo_dep],
+ install: false,
+)
+
+executable('d3d11screencapturesrc',
+ ['d3d11screencapturesrc.cpp'],
+ c_args : gst_plugins_bad_args,
+ cpp_args : gst_plugins_bad_args,
+ include_directories : [configinc, libsinc],
+ dependencies: [gst_dep, gstbase_dep, gstvideo_dep],
+ install: false,
+)
+
+d3d11_lib = cc.find_library('d3d11', required : false)
+dxgi_lib = cc.find_library('dxgi', required : false)
+d3dcompiler_lib = cc.find_library('d3dcompiler', required: false)
+have_d3d11_h = cc.has_header('d3d11.h')
+have_dxgi_h = cc.has_header('dxgi1_2.h')
+have_d3d11compiler_h = cc.has_header('d3dcompiler.h')
- executable('d3d11screencapturesrc',
- ['d3d11screencapturesrc.cpp'],
+d3d9_dep = cc.find_library('d3d9', required : false)
+have_d3d9_h = cc.has_header('d3d9.h')
+
+if d3d11_lib.found() and dxgi_lib.found() and d3dcompiler_lib.found() and have_d3d11_h and have_dxgi_h and have_d3d11compiler_h
+ executable('d3d11videosink-shared-texture',
+ ['d3d11videosink-shared-texture.cpp', 'd3d11device.cpp'],
c_args : gst_plugins_bad_args,
+ cpp_args : gst_plugins_bad_args,
include_directories : [configinc, libsinc],
- dependencies: [gst_dep, gstbase_dep, gstvideo_dep],
+ dependencies: [gst_dep, gstbase_dep, gstvideo_dep, d3d11_lib, dxgi_lib, d3dcompiler_lib],
install: false,
)
- d3d11_lib = cc.find_library('d3d11', required : false)
- dxgi_lib = cc.find_library('dxgi', required : false)
- d3dcompiler_lib = cc.find_library('d3dcompiler', required: false)
- have_d3d11_h = cc.has_header('d3d11.h')
- have_dxgi_h = cc.has_header('dxgi1_2.h')
- have_d3d11compiler_h = cc.has_header('d3dcompiler.h')
-
- d3d9_dep = cc.find_library('d3d9', required : false)
- have_d3d9_h = cc.has_header('d3d9.h')
+ if gstd3d11_dep.found ()
+ executable('d3d11decoder-appsink', ['d3d11decoder-appsink.cpp'],
+ c_args : gst_plugins_bad_args + ['-DGST_USE_UNSTABLE_API'],
+ cpp_args : gst_plugins_bad_args + ['-DGST_USE_UNSTABLE_API'],
+ include_directories : [configinc, libsinc],
+ dependencies: [gst_dep, gstbase_dep, gstvideo_dep, d3d11_lib, dxgi_lib, gstd3d11_dep, gstapp_dep],
+ install: false,
+ )
+ endif
- if d3d11_lib.found() and dxgi_lib.found() and d3dcompiler_lib.found() and have_d3d11_h and have_dxgi_h and have_d3d11compiler_h
- executable('d3d11videosink-shared-texture',
- ['d3d11videosink-shared-texture.cpp', 'd3d11device.cpp'],
+ if d3d_dep.found() and have_d3d9_h
+ executable('d3d11videosink-shared-texture-d3d9ex',
+ ['d3d11videosink-shared-texture-d3d9ex.cpp', 'd3d11device.cpp'],
c_args : gst_plugins_bad_args,
+ cpp_args : gst_plugins_bad_args,
include_directories : [configinc, libsinc],
- dependencies: [gst_dep, gstbase_dep, gstvideo_dep, d3d11_lib, dxgi_lib, d3dcompiler_lib],
+ dependencies: [gst_dep, gstbase_dep, gstvideo_dep, d3d11_lib, dxgi_lib, d3dcompiler_lib, d3d9_dep],
install: false,
)
-
- if d3d_dep.found() and have_d3d9_h
- executable('d3d11videosink-shared-texture-d3d9ex',
- ['d3d11videosink-shared-texture-d3d9ex.cpp', 'd3d11device.cpp'],
- c_args : gst_plugins_bad_args,
- include_directories : [configinc, libsinc],
- dependencies: [gst_dep, gstbase_dep, gstvideo_dep, d3d11_lib, dxgi_lib, d3dcompiler_lib, d3d9_dep],
- install: false,
- )
- endif
endif
endif
projects / platform / upstream / gstreamer.git / commitdiff