gstreamer/subprojects/gst-plugins-bad/tests/examples/d3d11/d3d11decoder-appsink.cpp

/*
 * 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;
}