d3d12decoder: Move common part to helper object

Store device at helper object

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/5356>

subprojects/gst-plugins-bad/sys/d3d12/gstd3d12av1dec.cpp

@@ -56,6 +56,7 @@ gst_d3d12_av1_dec_class_init (GstD3D12AV1DecClass * klass, gpointer data)
   GstDxvaAV1DecoderClass *dxva_class = GST_DXVA_AV1_DECODER_CLASS (klass);
   GstD3D12DecoderClassData *cdata = (GstD3D12DecoderClassData *) data;
 
+  gobject_class->finalize = gst_d3d12_av1_dec_finalize;
   gobject_class->get_property = gst_d3d12_av1_dec_get_property;
 
   element_class->set_context =
@@ -92,6 +93,21 @@ gst_d3d12_av1_dec_class_init (GstD3D12AV1DecClass * klass, gpointer data)
 static void
 gst_d3d12_av1_dec_init (GstD3D12AV1Dec * self)
 {
+  GstD3D12AV1DecClass *klass = GST_D3D12_AV1_DEC_GET_CLASS (self);
+  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
+
+  self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_AV1,
+      cdata->adapter_luid);
+}
+
+static void
+gst_d3d12_av1_dec_finalize (GObject * object)
+{
+  GstD3D12AV1Dec *self = GST_D3D12_AV1_DEC (object);
+
+  gst_object_unref (self->decoder);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
@@ -108,11 +124,8 @@ static void
 gst_d3d12_av1_dec_set_context (GstElement * element, GstContext * context)
 {
   GstD3D12AV1Dec *self = GST_D3D12_AV1_DEC (element);
-  GstD3D12AV1DecClass *klass = GST_D3D12_AV1_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  gst_d3d12_handle_set_context_for_adapter_luid (element,
+  gst_d3d12_decoder_set_context (self->decoder, element, context);
-      context, cdata->adapter_luid, &self->device);
 
   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 }
@@ -121,11 +134,8 @@ static gboolean
 gst_d3d12_av1_dec_open (GstVideoDecoder * decoder)
 {
   GstD3D12AV1Dec *self = GST_D3D12_AV1_DEC (decoder);
-  GstD3D12AV1DecClass *klass = GST_D3D12_AV1_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  return gst_d3d12_decoder_proxy_open (decoder, cdata, &self->device,
+  return gst_d3d12_decoder_open (self->decoder, GST_ELEMENT (self));
-      &self->decoder);
 }
 
 static gboolean
@@ -133,10 +143,7 @@ gst_d3d12_av1_dec_close (GstVideoDecoder * decoder)
 {
   GstD3D12AV1Dec *self = GST_D3D12_AV1_DEC (decoder);
 
-  gst_clear_object (&self->decoder);
+  return gst_d3d12_decoder_close (self->decoder);
-  gst_clear_object (&self->device);
-
-  return TRUE;
 }
 
 static gboolean
@@ -169,16 +176,8 @@ gst_d3d12_av1_dec_sink_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12AV1Dec *self = GST_D3D12_AV1_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_query (decoder, query);
 }
@@ -188,16 +187,8 @@ gst_d3d12_av1_dec_src_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12AV1Dec *self = GST_D3D12_AV1_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->src_query (decoder, query);
 }
@@ -207,7 +198,6 @@ gst_d3d12_av1_dec_sink_event (GstVideoDecoder * decoder, GstEvent * event)
 {
   GstD3D12AV1Dec *self = GST_D3D12_AV1_DEC (decoder);
 
-  if (self->decoder)
   gst_d3d12_decoder_sink_event (self->decoder, event);
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_event (decoder, event);

subprojects/gst-plugins-bad/sys/d3d12/gstd3d12decoder.cpp

@@ -207,15 +207,8 @@ struct GstD3D12DecoderPrivate
       gst_buffer_pool_set_active (output_pool, FALSE);
       gst_object_unref (output_pool);
     }
-
-    if (device)
-      gst_object_unref (device);
   }
 
-  GstD3D12Device *device = nullptr;
-
-  GstDxvaCodec codec = GST_DXVA_CODEC_NONE;
-
   /* reference textures */
   GstBufferPool *dpb_pool = nullptr;
 
@@ -284,6 +277,12 @@ struct _GstD3D12Decoder
 {
   GstObject parent;
 
+  GstDxvaCodec codec;
+  GstD3D12Device *device;
+  gint64 adapter_luid;
+
+  CRITICAL_SECTION context_lock;
+
   GstD3D12DecoderPrivate *priv;
 };
 
@@ -303,9 +302,7 @@ gst_d3d12_decoder_class_init (GstD3D12DecoderClass * klass)
 static void
 gst_d3d12_decoder_init (GstD3D12Decoder * self)
 {
-  GstD3D12DecoderPrivate *priv;
+  InitializeCriticalSection (&self->context_lock);
-
-  self->priv = priv = new GstD3D12DecoderPrivate ();
 }
 
 static void
@@ -313,7 +310,8 @@ gst_d3d12_decoder_finalize (GObject * object)
 {
   GstD3D12Decoder *self = GST_D3D12_DECODER (object);
 
-  delete self->priv;
+  gst_d3d12_decoder_close (self);
+  DeleteCriticalSection (&self->context_lock);
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
@@ -356,9 +354,30 @@ gst_d3d12_decoder_reset (GstD3D12Decoder * self)
 }
 
 GstD3D12Decoder *
-gst_d3d12_decoder_new (GstD3D12Device * device, GstDxvaCodec codec)
+gst_d3d12_decoder_new (GstDxvaCodec codec, gint64 adapter_luid)
 {
   GstD3D12Decoder *self;
+
+  g_return_val_if_fail (codec > GST_DXVA_CODEC_NONE, nullptr);
+  g_return_val_if_fail (codec < GST_DXVA_CODEC_LAST, nullptr);
+
+  self = (GstD3D12Decoder *) g_object_new (GST_TYPE_D3D12_DECODER, nullptr);
+  self->codec = codec;
+  self->adapter_luid = adapter_luid;
+
+  return self;
+}
+
+gboolean
+gst_d3d12_decoder_open (GstD3D12Decoder * decoder, GstElement * element)
+{
+  if (!gst_d3d12_ensure_element_data_for_adapter_luid (element,
+          decoder->adapter_luid, &decoder->device)) {
+    GST_ERROR_OBJECT (element, "Cannot create d3d12device");
+    return FALSE;
+  }
+
+  if (!decoder->priv) {
     GstD3D12DecoderPrivate *priv;
     ComPtr < ID3D12VideoDevice > video_device;
     ComPtr < ID3D12CommandAllocator > copy_ca;
@@ -370,66 +389,72 @@ gst_d3d12_decoder_new (GstD3D12Device * device, GstDxvaCodec codec)
     D3D12_COMMAND_QUEUE_DESC desc = { };
     HRESULT hr;
 
-  g_return_val_if_fail (GST_IS_D3D12_DEVICE (device), nullptr);
+    device_handle = gst_d3d12_device_get_device_handle (decoder->device);
-  g_return_val_if_fail (codec > GST_DXVA_CODEC_NONE, nullptr);
-  g_return_val_if_fail (codec < GST_DXVA_CODEC_LAST, nullptr);
-
-  device_handle = gst_d3d12_device_get_device_handle (device);
     hr = device_handle->QueryInterface (IID_PPV_ARGS (&video_device));
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
     hr = device_handle->CreateCommandAllocator (D3D12_COMMAND_LIST_TYPE_COPY,
         IID_PPV_ARGS (&copy_ca));
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
     hr = device_handle->CreateCommandList (0, D3D12_COMMAND_LIST_TYPE_COPY,
         copy_ca.Get (), nullptr, IID_PPV_ARGS (&copy_cl));
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
     hr = copy_cl->Close ();
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
     hr = device_handle->CreateCommandAllocator
         (D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE, IID_PPV_ARGS (&ca));
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
     hr = device_handle->CreateCommandList (0,
         D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE, ca.Get (), nullptr,
         IID_PPV_ARGS (&cl));
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
     hr = cl->Close ();
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
     desc.Type = D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE;
     desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
     hr = device_handle->CreateCommandQueue (&desc, IID_PPV_ARGS (&cq));
-  if (!gst_d3d12_result (hr, device))
+    if (!gst_d3d12_result (hr, decoder->device))
-    return nullptr;
+      return FALSE;
 
-  self = (GstD3D12Decoder *) g_object_new (GST_TYPE_D3D12_DECODER, nullptr);
+    priv = new GstD3D12DecoderPrivate ();
-  priv = self->priv;
+    priv->fence = gst_d3d12_fence_new (decoder->device);
-  priv->codec = codec;
-  priv->device = (GstD3D12Device *) gst_object_ref (device);
-  priv->fence = gst_d3d12_fence_new (device);
     priv->video_device = video_device;
     priv->copy_ca = copy_ca;
     priv->copy_cl = copy_cl;
     priv->ca = ca;
     priv->cl = cl;
     priv->cq = cq;
-  g_object_get (priv->device, "adapter-luid", &priv->luid, nullptr);
 
-  gst_object_ref_sink (self);
+    decoder->priv = priv;
+  }
 
-  return self;
+  return TRUE;
+}
+
+gboolean
+gst_d3d12_decoder_close (GstD3D12Decoder * decoder)
+{
+  if (decoder->priv) {
+    delete decoder->priv;
+    decoder->priv = nullptr;
+  }
+
+  gst_clear_object (&decoder->device);
+
+  return TRUE;
 }
 
 GstFlowReturn
@@ -450,9 +475,14 @@ gst_d3d12_decoder_configure (GstD3D12Decoder * decoder,
   GstD3D12DecoderPrivate *priv = decoder->priv;
   GstD3D12Format device_format;
 
+  if (!priv) {
+    GST_ERROR_OBJECT (decoder, "Device is not configured");
+    return GST_FLOW_ERROR;
+  }
+
   gst_d3d12_decoder_reset (decoder);
 
-  if (!gst_d3d12_device_get_format (priv->device,
+  if (!gst_d3d12_device_get_format (decoder->device,
           GST_VIDEO_INFO_FORMAT (info), &device_format) ||
       device_format.dxgi_format == DXGI_FORMAT_UNKNOWN) {
     GST_ERROR_OBJECT (decoder, "Could not determine dxgi format from %s",
@@ -460,7 +490,7 @@ gst_d3d12_decoder_configure (GstD3D12Decoder * decoder,
     return GST_FLOW_ERROR;
   }
 
-  if (priv->codec == GST_DXVA_CODEC_H264)
+  if (decoder->codec == GST_DXVA_CODEC_H264)
     dpb_size += 1;
 
   priv->input_state = gst_video_codec_state_ref (input_state);
@@ -529,7 +559,7 @@ gst_d3d12_decoder_prepare_pool (GstD3D12Decoder * self)
     max_buffers = 0;
   }
 
-  params = gst_d3d12_allocation_params_new (priv->device, info, alloc_flags,
+  params = gst_d3d12_allocation_params_new (self->device, info, alloc_flags,
       resource_flags);
 
   gst_video_alignment_reset (&align);
@@ -540,7 +570,7 @@ gst_d3d12_decoder_prepare_pool (GstD3D12Decoder * self)
   if (!priv->use_array_of_texture)
     params->desc[0].DepthOrArraySize = (UINT16) max_buffers;
 
-  priv->dpb_pool = gst_d3d12_buffer_pool_new (priv->device);
+  priv->dpb_pool = gst_d3d12_buffer_pool_new (self->device);
   config = gst_buffer_pool_get_config (priv->dpb_pool);
   caps = gst_video_info_to_caps (info);
 
@@ -560,10 +590,10 @@ gst_d3d12_decoder_prepare_pool (GstD3D12Decoder * self)
    * texture pool for outputting without VIDEO_DECODE_REFERENCE_ONLY flag */
   if (priv->reference_only) {
     GST_DEBUG_OBJECT (self, "Creating output only allocator");
-    priv->output_pool = gst_d3d12_buffer_pool_new (priv->device);
+    priv->output_pool = gst_d3d12_buffer_pool_new (self->device);
     config = gst_buffer_pool_get_config (priv->output_pool);
 
-    params = gst_d3d12_allocation_params_new (priv->device, info, alloc_flags,
+    params = gst_d3d12_allocation_params_new (self->device, info, alloc_flags,
         D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS);
     gst_d3d12_allocation_params_alignment (params, &align);
     gst_buffer_pool_config_set_d3d12_allocation_params (config, params);
@@ -739,7 +769,7 @@ gst_d3d12_decoder_upload_bitstream (GstD3D12Decoder * self, gpointer data,
 
   if (!priv->bitstream) {
     ID3D12Device *device_handle =
-        gst_d3d12_device_get_device_handle (priv->device);
+        gst_d3d12_device_get_device_handle (self->device);
     ComPtr < ID3D12Resource > bitstream;
     size_t alloc_size = GST_ROUND_UP_128 (size) + 1024;
 
@@ -749,7 +779,7 @@ gst_d3d12_decoder_upload_bitstream (GstD3D12Decoder * self, gpointer data,
     hr = device_handle->CreateCommittedResource (&heap_prop,
         D3D12_HEAP_FLAG_NONE, &desc,
         D3D12_RESOURCE_STATE_COMMON, nullptr, IID_PPV_ARGS (&bitstream));
-    if (!gst_d3d12_result (hr, priv->device)) {
+    if (!gst_d3d12_result (hr, self->device)) {
       GST_ERROR_OBJECT (self, "Failed to create bitstream buffer");
       return FALSE;
     }
@@ -762,7 +792,7 @@ gst_d3d12_decoder_upload_bitstream (GstD3D12Decoder * self, gpointer data,
   }
 
   hr = priv->bitstream->Map (0, nullptr, &map_data);
-  if (!gst_d3d12_result (hr, priv->device)) {
+  if (!gst_d3d12_result (hr, self->device)) {
     GST_ERROR_OBJECT (self, "Couldn't map bitstream buffer");
     return FALSE;
   }
@@ -819,13 +849,13 @@ gst_d3d12_decoder_end_picture (GstD3D12Decoder * decoder,
   memset (&out_args, 0, sizeof (D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS));
 
   hr = priv->ca->Reset ();
-  if (!gst_d3d12_result (hr, priv->device)) {
+  if (!gst_d3d12_result (hr, decoder->device)) {
     GST_ERROR_OBJECT (decoder, "Couldn't reset command allocator");
     return GST_FLOW_ERROR;
   }
 
   hr = priv->cl->Reset (priv->ca.Get ());
-  if (!gst_d3d12_result (hr, priv->device)) {
+  if (!gst_d3d12_result (hr, decoder->device)) {
     GST_ERROR_OBJECT (decoder, "Couldn't reset command list");
     return GST_FLOW_ERROR;
   }
@@ -959,7 +989,7 @@ gst_d3d12_decoder_end_picture (GstD3D12Decoder * decoder,
   priv->cl->ResourceBarrier (post_barriers.size (), &post_barriers[0]);
 
   hr = priv->cl->Close ();
-  if (!gst_d3d12_result (hr, priv->device)) {
+  if (!gst_d3d12_result (hr, decoder->device)) {
     GST_ERROR_OBJECT (decoder, "Couldn't record decoding command");
     return GST_FLOW_ERROR;
   }
@@ -968,9 +998,9 @@ gst_d3d12_decoder_end_picture (GstD3D12Decoder * decoder,
   priv->cq->ExecuteCommandLists (1, cl);
 
   fence_handle = gst_d3d12_fence_get_handle (priv->fence);
-  fence_value = gst_d3d12_device_get_fence_value (priv->device);
+  fence_value = gst_d3d12_device_get_fence_value (decoder->device);
   hr = priv->cq->Signal (fence_handle, fence_value);
-  if (!gst_d3d12_result (hr, priv->device)) {
+  if (!gst_d3d12_result (hr, decoder->device)) {
     GST_DEBUG_OBJECT (decoder, "Couldn't signal fence value");
     return GST_FLOW_ERROR;
   }
@@ -992,7 +1022,7 @@ gst_d3d12_decoder_ensure_staging_texture (GstD3D12Decoder * self)
   ComPtr < ID3D12Resource > staging;
   HRESULT hr;
   UINT64 size;
-  ID3D12Device *device = gst_d3d12_device_get_device_handle (priv->device);
+  ID3D12Device *device = gst_d3d12_device_get_device_handle (self->device);
   D3D12_RESOURCE_DESC tex_desc =
       CD3D12_RESOURCE_DESC::Tex2D (priv->decoder_format,
       priv->aligned_width, priv->aligned_height);
@@ -1006,7 +1036,7 @@ gst_d3d12_decoder_ensure_staging_texture (GstD3D12Decoder * self)
 
   hr = device->CreateCommittedResource (&heap_prop, D3D12_HEAP_FLAG_NONE,
       &desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS (&staging));
-  if (!gst_d3d12_result (hr, priv->device))
+  if (!gst_d3d12_result (hr, self->device))
     return FALSE;
 
   priv->staging = staging;
@@ -1088,7 +1118,7 @@ gst_d3d12_decoder_output_picture (GstD3D12Decoder * decoder,
 
   priv = decoder->priv;
 
-  copy_queue = gst_d3d12_device_get_copy_queue (priv->device);
+  copy_queue = gst_d3d12_device_get_copy_queue (decoder->device);
   if (!copy_queue) {
     ret = GST_FLOW_ERROR;
     goto error;
@@ -1168,7 +1198,7 @@ gst_d3d12_decoder_output_picture (GstD3D12Decoder * decoder,
     mem = gst_buffer_peek_memory (frame->output_buffer, 0);
     if (gst_is_d3d12_memory (mem)) {
       dmem = GST_D3D12_MEMORY_CAST (mem);
-      if (dmem->device == priv->device) {
+      if (dmem->device == decoder->device) {
         out_resource = gst_d3d12_memory_get_resource_handle (dmem);
         gst_d3d12_memory_get_subresource_index (dmem, 0, &out_subresource[0]);
         gst_d3d12_memory_get_subresource_index (dmem, 1, &out_subresource[1]);
@@ -1194,13 +1224,13 @@ gst_d3d12_decoder_output_picture (GstD3D12Decoder * decoder,
 
     /* Copy texture to staging */
     hr = priv->copy_ca->Reset ();
-    if (!gst_d3d12_result (hr, priv->device)) {
+    if (!gst_d3d12_result (hr, decoder->device)) {
       ret = GST_FLOW_ERROR;
       goto error;
     }
 
     hr = priv->copy_cl->Reset (priv->copy_ca.Get (), nullptr);
-    if (!gst_d3d12_result (hr, priv->device)) {
+    if (!gst_d3d12_result (hr, decoder->device)) {
       ret = GST_FLOW_ERROR;
       goto error;
     }
@@ -1243,7 +1273,7 @@ gst_d3d12_decoder_output_picture (GstD3D12Decoder * decoder,
     }
 
     hr = priv->copy_cl->Close ();
-    if (!gst_d3d12_result (hr, priv->device)) {
+    if (!gst_d3d12_result (hr, decoder->device)) {
       GST_ERROR_OBJECT (videodec, "Couldn't record copy command");
       ret = GST_FLOW_ERROR;
       goto error;
@@ -1252,10 +1282,10 @@ gst_d3d12_decoder_output_picture (GstD3D12Decoder * decoder,
     list[0] = priv->copy_cl.Get ();
     copy_queue->ExecuteCommandLists (1, list);
 
-    fence_value = gst_d3d12_device_get_fence_value (priv->device);
+    fence_value = gst_d3d12_device_get_fence_value (decoder->device);
     hr = copy_queue->Signal (gst_d3d12_fence_get_handle (out_fence),
         fence_value);
-    if (!gst_d3d12_result (hr, priv->device)) {
+    if (!gst_d3d12_result (hr, decoder->device)) {
       ret = GST_FLOW_ERROR;
       goto error;
     }
@@ -1266,7 +1296,7 @@ gst_d3d12_decoder_output_picture (GstD3D12Decoder * decoder,
       gst_d3d12_fence_wait (out_fence);
 
       hr = priv->staging->Map (0, nullptr, &map_data);
-      if (!gst_d3d12_result (hr, priv->device)) {
+      if (!gst_d3d12_result (hr, decoder->device)) {
         ret = GST_FLOW_ERROR;
         goto error;
       }
@@ -1303,7 +1333,7 @@ error:
 }
 
 static gboolean
-gst_d3d12_decoder_open (GstD3D12Decoder * self)
+gst_d3d12_decoder_create (GstD3D12Decoder * self)
 {
   GstD3D12DecoderPrivate *priv = self->priv;
   HRESULT hr;
@@ -1327,7 +1357,7 @@ gst_d3d12_decoder_open (GstD3D12Decoder * self)
   for (guint i = 0; i < G_N_ELEMENTS (format_list); i++) {
     decoder_foramt = nullptr;
 
-    if (format_list[i].codec != priv->codec)
+    if (format_list[i].codec != self->codec)
       continue;
 
     for (guint j = 0; j < G_N_ELEMENTS (format_list[i].format); j++) {
@@ -1415,7 +1445,7 @@ gst_d3d12_decoder_open (GstD3D12Decoder * self)
     desc.NodeMask = 0;
     desc.Configuration = support.Configuration;
     hr = video_device->CreateVideoDecoder (&desc, IID_PPV_ARGS (&decoder));
-    if (!gst_d3d12_result (hr, priv->device)) {
+    if (!gst_d3d12_result (hr, self->device)) {
       GST_ERROR_OBJECT (self, "Failed to create decoder");
       return FALSE;
     }
@@ -1433,7 +1463,7 @@ gst_d3d12_decoder_open (GstD3D12Decoder * self)
   heap_desc.BitRate = 0;
   heap_desc.MaxDecodePictureBufferCount = priv->dpb_size;
   hr = video_device->CreateVideoDecoderHeap (&heap_desc, IID_PPV_ARGS (&heap));
-  if (!gst_d3d12_result (hr, priv->device)) {
+  if (!gst_d3d12_result (hr, self->device)) {
     GST_ERROR_OBJECT (self, "Failed to create decoder heap");
     return FALSE;
   }
@@ -1525,7 +1555,7 @@ gst_d3d12_decoder_negotiate (GstD3D12Decoder * decoder,
 
   priv->downstream_supports_d3d12 = d3d12_supported;
 
-  return gst_d3d12_decoder_open (decoder);
+  return gst_d3d12_decoder_create (decoder);
 }
 
 gboolean
@@ -1577,7 +1607,7 @@ gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder,
       gst_clear_object (&pool);
     } else {
       GstD3D12BufferPool *dpool = GST_D3D12_BUFFER_POOL (pool);
-      if (dpool->device != priv->device) {
+      if (dpool->device != decoder->device) {
         GST_DEBUG_OBJECT (videodec, "Different device, will create new one");
         gst_clear_object (&pool);
       }
@@ -1586,7 +1616,7 @@ gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder,
 
   if (!pool) {
     if (use_d3d12_pool)
-      pool = gst_d3d12_buffer_pool_new (priv->device);
+      pool = gst_d3d12_buffer_pool_new (decoder->device);
     else
       pool = gst_video_buffer_pool_new ();
 
@@ -1606,7 +1636,7 @@ gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder,
 
     params = gst_buffer_pool_config_get_d3d12_allocation_params (config);
     if (!params) {
-      params = gst_d3d12_allocation_params_new (priv->device, &vinfo,
+      params = gst_d3d12_allocation_params_new (decoder->device, &vinfo,
           GST_D3D12_ALLOCATION_FLAG_DEFAULT,
           D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS);
     } else {
@@ -1706,6 +1736,27 @@ gst_d3d12_decoder_sink_event (GstD3D12Decoder * decoder, GstEvent * event)
   }
 }
 
+void
+gst_d3d12_decoder_set_context (GstD3D12Decoder * decoder, GstElement * element,
+    GstContext * context)
+{
+  GstD3D12CSLockGuard lk (&decoder->context_lock);
+
+  gst_d3d12_handle_set_context_for_adapter_luid (element,
+      context, decoder->adapter_luid, &decoder->device);
+}
+
+gboolean
+gst_d3d12_decoder_handle_query (GstD3D12Decoder * decoder, GstElement * element,
+    GstQuery * query)
+{
+  if (GST_QUERY_TYPE (query) != GST_QUERY_CONTEXT)
+    return FALSE;
+
+  GstD3D12CSLockGuard lk (&decoder->context_lock);
+  return gst_d3d12_handle_context_query (element, query, decoder->device);
+}
+
 enum
 {
   PROP_DECODER_ADAPTER_LUID = 1,
@@ -2033,27 +2084,3 @@ gst_d3d12_decoder_proxy_get_property (GObject * object, guint prop_id,
       break;
   }
 }
-
-gboolean
-gst_d3d12_decoder_proxy_open (GstVideoDecoder * videodec,
-    GstD3D12DecoderSubClassData * subclass_data, GstD3D12Device ** device,
-    GstD3D12Decoder ** decoder)
-{
-  GstElement *elem = GST_ELEMENT (videodec);
-
-  if (!gst_d3d12_ensure_element_data_for_adapter_luid (elem,
-          subclass_data->adapter_luid, device)) {
-    GST_ERROR_OBJECT (elem, "Cannot create d3d12device");
-    return FALSE;
-  }
-
-  *decoder = gst_d3d12_decoder_new (*device, subclass_data->codec);
-
-  if (*decoder == nullptr) {
-    GST_ERROR_OBJECT (elem, "Cannot create d3d12 decoder");
-    gst_clear_object (device);
-    return FALSE;
-  }
-
-  return TRUE;
-}

subprojects/gst-plugins-bad/sys/d3d12/gstd3d12decoder.h

@@ -45,7 +45,6 @@ struct GstD3D12DecoderSubClassData
   static GstElementClass *parent_class = NULL; \
   typedef struct _##ModuleObjName { \
     ParentName parent; \
-    GstD3D12Device *device; \
     GstD3D12Decoder *decoder; \
   } ModuleObjName;\
   typedef struct _##ModuleObjName##Class { \
@@ -58,6 +57,7 @@ struct GstD3D12DecoderSubClassData
   static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_GET_CLASS (gpointer ptr) { \
     return G_TYPE_INSTANCE_GET_CLASS ((ptr),G_TYPE_FROM_INSTANCE(ptr),ModuleObjName##Class); \
   } \
+  static void module_obj_name##_finalize (GObject * object); \
   static void module_obj_name##_get_property (GObject * object, \
       guint prop_id, GValue * value, GParamSpec * pspec); \
   static void module_obj_name##_set_context (GstElement * element, \
@@ -96,8 +96,13 @@ struct GstD3D12DecoderSubClassData
   static GstFlowReturn  module_obj_name##_duplicate_picture (ParentName * decoder, \
       GstCodecPicture * src, GstCodecPicture * dst);
 
-GstD3D12Decoder * gst_d3d12_decoder_new               (GstD3D12Device * device,
+GstD3D12Decoder * gst_d3d12_decoder_new               (GstDxvaCodec codec,
-                                                       GstDxvaCodec codec);
+                                                       gint64 adapter_luid);
+
+gboolean          gst_d3d12_decoder_open              (GstD3D12Decoder * decoder,
+                                                       GstElement * element);
+
+gboolean          gst_d3d12_decoder_close             (GstD3D12Decoder * decoder);
 
 GstFlowReturn     gst_d3d12_decoder_configure         (GstD3D12Decoder * decoder,
                                                        GstVideoCodecState * input_state,
@@ -146,6 +151,14 @@ gboolean          gst_d3d12_decoder_decide_allocation (GstD3D12Decoder * decoder
 void              gst_d3d12_decoder_sink_event        (GstD3D12Decoder * decoder,
                                                        GstEvent * event);
 
+void              gst_d3d12_decoder_set_context       (GstD3D12Decoder * decoder,
+                                                       GstElement * element,
+                                                       GstContext * context);
+
+gboolean          gst_d3d12_decoder_handle_query      (GstD3D12Decoder * decoder,
+                                                       GstElement * element,
+                                                       GstQuery * query);
+
 /* Utils for element registration */
 GstD3D12DecoderClassData * gst_d3d12_decoder_check_feature_support   (GstD3D12Device * device,
                                                                       ID3D12VideoDevice * video_device,
@@ -164,9 +177,4 @@ void  gst_d3d12_decoder_proxy_get_property            (GObject * object,
                                                        GParamSpec * pspec,
                                                        GstD3D12DecoderSubClassData * subclass_data);
 
-gboolean gst_d3d12_decoder_proxy_open                 (GstVideoDecoder * videodec,
-                                                       GstD3D12DecoderSubClassData * subclass_data,
-                                                       GstD3D12Device ** device,
-                                                       GstD3D12Decoder ** decoder);
-
 G_END_DECLS

subprojects/gst-plugins-bad/sys/d3d12/gstd3d12h264dec.cpp

@@ -56,6 +56,7 @@ gst_d3d12_h264_dec_class_init (GstD3D12H264DecClass * klass, gpointer data)
   GstDxvaH264DecoderClass *dxva_class = GST_DXVA_H264_DECODER_CLASS (klass);
   GstD3D12DecoderClassData *cdata = (GstD3D12DecoderClassData *) data;
 
+  gobject_class->finalize = gst_d3d12_h264_dec_finalize;
   gobject_class->get_property = gst_d3d12_h264_dec_get_property;
 
   element_class->set_context =
@@ -92,6 +93,21 @@ gst_d3d12_h264_dec_class_init (GstD3D12H264DecClass * klass, gpointer data)
 static void
 gst_d3d12_h264_dec_init (GstD3D12H264Dec * self)
 {
+  GstD3D12H264DecClass *klass = GST_D3D12_H264_DEC_GET_CLASS (self);
+  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
+
+  self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_H264,
+      cdata->adapter_luid);
+}
+
+static void
+gst_d3d12_h264_dec_finalize (GObject * object)
+{
+  GstD3D12H264Dec *self = GST_D3D12_H264_DEC (object);
+
+  gst_object_unref (self->decoder);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
@@ -108,11 +124,8 @@ static void
 gst_d3d12_h264_dec_set_context (GstElement * element, GstContext * context)
 {
   GstD3D12H264Dec *self = GST_D3D12_H264_DEC (element);
-  GstD3D12H264DecClass *klass = GST_D3D12_H264_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  gst_d3d12_handle_set_context_for_adapter_luid (element,
+  gst_d3d12_decoder_set_context (self->decoder, element, context);
-      context, cdata->adapter_luid, &self->device);
 
   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 }
@@ -121,11 +134,8 @@ static gboolean
 gst_d3d12_h264_dec_open (GstVideoDecoder * decoder)
 {
   GstD3D12H264Dec *self = GST_D3D12_H264_DEC (decoder);
-  GstD3D12H264DecClass *klass = GST_D3D12_H264_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  return gst_d3d12_decoder_proxy_open (decoder, cdata, &self->device,
+  return gst_d3d12_decoder_open (self->decoder, GST_ELEMENT (self));
-      &self->decoder);
 }
 
 static gboolean
@@ -133,10 +143,7 @@ gst_d3d12_h264_dec_close (GstVideoDecoder * decoder)
 {
   GstD3D12H264Dec *self = GST_D3D12_H264_DEC (decoder);
 
-  gst_clear_object (&self->decoder);
+  return gst_d3d12_decoder_close (self->decoder);
-  gst_clear_object (&self->device);
-
-  return TRUE;
 }
 
 static gboolean
@@ -169,16 +176,8 @@ gst_d3d12_h264_dec_sink_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12H264Dec *self = GST_D3D12_H264_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_query (decoder, query);
 }
@@ -188,16 +187,8 @@ gst_d3d12_h264_dec_src_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12H264Dec *self = GST_D3D12_H264_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->src_query (decoder, query);
 }
@@ -207,7 +198,6 @@ gst_d3d12_h264_dec_sink_event (GstVideoDecoder * decoder, GstEvent * event)
 {
   GstD3D12H264Dec *self = GST_D3D12_H264_DEC (decoder);
 
-  if (self->decoder)
   gst_d3d12_decoder_sink_event (self->decoder, event);
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_event (decoder, event);

subprojects/gst-plugins-bad/sys/d3d12/gstd3d12h265dec.cpp

@@ -56,6 +56,7 @@ gst_d3d12_h265_dec_class_init (GstD3D12H265DecClass * klass, gpointer data)
   GstDxvaH265DecoderClass *dxva_class = GST_DXVA_H265_DECODER_CLASS (klass);
   GstD3D12DecoderClassData *cdata = (GstD3D12DecoderClassData *) data;
 
+  gobject_class->finalize = gst_d3d12_h265_dec_finalize;
   gobject_class->get_property = gst_d3d12_h265_dec_get_property;
 
   element_class->set_context =
@@ -90,6 +91,21 @@ gst_d3d12_h265_dec_class_init (GstD3D12H265DecClass * klass, gpointer data)
 static void
 gst_d3d12_h265_dec_init (GstD3D12H265Dec * self)
 {
+  GstD3D12H265DecClass *klass = GST_D3D12_H265_DEC_GET_CLASS (self);
+  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
+
+  self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_H265,
+      cdata->adapter_luid);
+}
+
+static void
+gst_d3d12_h265_dec_finalize (GObject * object)
+{
+  GstD3D12H265Dec *self = GST_D3D12_H265_DEC (object);
+
+  gst_object_unref (self->decoder);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
@@ -106,11 +122,8 @@ static void
 gst_d3d12_h265_dec_set_context (GstElement * element, GstContext * context)
 {
   GstD3D12H265Dec *self = GST_D3D12_H265_DEC (element);
-  GstD3D12H265DecClass *klass = GST_D3D12_H265_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  gst_d3d12_handle_set_context_for_adapter_luid (element,
+  gst_d3d12_decoder_set_context (self->decoder, element, context);
-      context, cdata->adapter_luid, &self->device);
 
   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 }
@@ -119,11 +132,8 @@ static gboolean
 gst_d3d12_h265_dec_open (GstVideoDecoder * decoder)
 {
   GstD3D12H265Dec *self = GST_D3D12_H265_DEC (decoder);
-  GstD3D12H265DecClass *klass = GST_D3D12_H265_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  return gst_d3d12_decoder_proxy_open (decoder, cdata, &self->device,
+  return gst_d3d12_decoder_open (self->decoder, GST_ELEMENT (self));
-      &self->decoder);
 }
 
 static gboolean
@@ -131,10 +141,7 @@ gst_d3d12_h265_dec_close (GstVideoDecoder * decoder)
 {
   GstD3D12H265Dec *self = GST_D3D12_H265_DEC (decoder);
 
-  gst_clear_object (&self->decoder);
+  return gst_d3d12_decoder_close (self->decoder);
-  gst_clear_object (&self->device);
-
-  return TRUE;
 }
 
 static gboolean
@@ -167,16 +174,8 @@ gst_d3d12_h265_dec_sink_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12H265Dec *self = GST_D3D12_H265_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_query (decoder, query);
 }
@@ -186,16 +185,8 @@ gst_d3d12_h265_dec_src_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12H265Dec *self = GST_D3D12_H265_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->src_query (decoder, query);
 }
@@ -205,7 +196,6 @@ gst_d3d12_h265_dec_sink_event (GstVideoDecoder * decoder, GstEvent * event)
 {
   GstD3D12H265Dec *self = GST_D3D12_H265_DEC (decoder);
 
-  if (self->decoder)
   gst_d3d12_decoder_sink_event (self->decoder, event);
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_event (decoder, event);

subprojects/gst-plugins-bad/sys/d3d12/gstd3d12utils.h

@@ -210,6 +210,26 @@ struct CD3D12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION
 
 #include <mutex>
 
+class GstD3D12CSLockGuard
+{
+public:
+  explicit GstD3D12CSLockGuard(CRITICAL_SECTION * cs) : cs_ (cs)
+  {
+    EnterCriticalSection (cs_);
+  }
+
+  ~GstD3D12CSLockGuard()
+  {
+    LeaveCriticalSection (cs_);
+  }
+
+  GstD3D12CSLockGuard(const GstD3D12CSLockGuard&) = delete;
+  GstD3D12CSLockGuard& operator=(const GstD3D12CSLockGuard&) = delete;
+
+private:
+  CRITICAL_SECTION *cs_;
+};
+
 #define GST_D3D12_CALL_ONCE_BEGIN \
     static std::once_flag __once_flag; \
     std::call_once (__once_flag, [&]()

subprojects/gst-plugins-bad/sys/d3d12/gstd3d12vp9dec.cpp

@@ -56,6 +56,7 @@ gst_d3d12_vp9_dec_class_init (GstD3D12Vp9DecClass * klass, gpointer data)
   GstDxvaVp9DecoderClass *dxva_class = GST_DXVA_VP9_DECODER_CLASS (klass);
   GstD3D12DecoderClassData *cdata = (GstD3D12DecoderClassData *) data;
 
+  gobject_class->finalize = gst_d3d12_vp9_dec_finalize;
   gobject_class->get_property = gst_d3d12_vp9_dec_get_property;
 
   element_class->set_context =
@@ -92,6 +93,21 @@ gst_d3d12_vp9_dec_class_init (GstD3D12Vp9DecClass * klass, gpointer data)
 static void
 gst_d3d12_vp9_dec_init (GstD3D12Vp9Dec * self)
 {
+  GstD3D12Vp9DecClass *klass = GST_D3D12_VP9_DEC_GET_CLASS (self);
+  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
+
+  self->decoder = gst_d3d12_decoder_new (GST_DXVA_CODEC_VP9,
+      cdata->adapter_luid);
+}
+
+static void
+gst_d3d12_vp9_dec_finalize (GObject * object)
+{
+  GstD3D12Vp9Dec *self = GST_D3D12_VP9_DEC (object);
+
+  gst_object_unref (self->decoder);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
@@ -108,11 +124,8 @@ static void
 gst_d3d12_vp9_dec_set_context (GstElement * element, GstContext * context)
 {
   GstD3D12Vp9Dec *self = GST_D3D12_VP9_DEC (element);
-  GstD3D12Vp9DecClass *klass = GST_D3D12_VP9_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  gst_d3d12_handle_set_context_for_adapter_luid (element,
+  gst_d3d12_decoder_set_context (self->decoder, element, context);
-      context, cdata->adapter_luid, &self->device);
 
   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 }
@@ -121,11 +134,8 @@ static gboolean
 gst_d3d12_vp9_dec_open (GstVideoDecoder * decoder)
 {
   GstD3D12Vp9Dec *self = GST_D3D12_VP9_DEC (decoder);
-  GstD3D12Vp9DecClass *klass = GST_D3D12_VP9_DEC_GET_CLASS (self);
-  GstD3D12DecoderSubClassData *cdata = &klass->class_data;
 
-  return gst_d3d12_decoder_proxy_open (decoder, cdata, &self->device,
+  return gst_d3d12_decoder_open (self->decoder, GST_ELEMENT (self));
-      &self->decoder);
 }
 
 static gboolean
@@ -133,10 +143,7 @@ gst_d3d12_vp9_dec_close (GstVideoDecoder * decoder)
 {
   GstD3D12Vp9Dec *self = GST_D3D12_VP9_DEC (decoder);
 
-  gst_clear_object (&self->decoder);
+  return gst_d3d12_decoder_close (self->decoder);
-  gst_clear_object (&self->device);
-
-  return TRUE;
 }
 
 static gboolean
@@ -169,16 +176,8 @@ gst_d3d12_vp9_dec_sink_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12Vp9Dec *self = GST_D3D12_VP9_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_query (decoder, query);
 }
@@ -188,16 +187,8 @@ gst_d3d12_vp9_dec_src_query (GstVideoDecoder * decoder, GstQuery * query)
 {
   GstD3D12Vp9Dec *self = GST_D3D12_VP9_DEC (decoder);
 
-  switch (GST_QUERY_TYPE (query)) {
+  if (gst_d3d12_decoder_handle_query (self->decoder, GST_ELEMENT (self), query))
-    case GST_QUERY_CONTEXT:
-      if (gst_d3d12_handle_context_query (GST_ELEMENT (decoder),
-              query, self->device)) {
     return TRUE;
-      }
-      break;
-    default:
-      break;
-  }
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->src_query (decoder, query);
 }
@@ -207,7 +198,6 @@ gst_d3d12_vp9_dec_sink_event (GstVideoDecoder * decoder, GstEvent * event)
 {
   GstD3D12Vp9Dec *self = GST_D3D12_VP9_DEC (decoder);
 
-  if (self->decoder)
   gst_d3d12_decoder_sink_event (self->decoder, event);
 
   return GST_VIDEO_DECODER_CLASS (parent_class)->sink_event (decoder, event);