subprojects/gst-plugins-bad/gst-libs/gst/d3d11/gstd3d11bufferpool.cpp

   1 /* GStreamer
   2  * Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.com>
   3  * Copyright (C) 2020 Seungha Yang <seungha@centricular.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include "gstd3d11bufferpool.h"
  26 #include "gstd3d11memory.h"
  27 #include "gstd3d11device.h"
  28 #include "gstd3d11utils.h"
  29
  30 #include <string.h>
  31
  32 /**
  33  * SECTION:gstd3d11bufferpool
  34  * @title: GstD3D11BufferPool
  35  * @short_description: buffer pool for #GstD3D11Memory objects
  36  * @see_also: #GstBufferPool, #GstGLMemory
  37  *
  38  * a #GstD3D11BufferPool is an object that allocates buffers with #GstD3D11Memory
  39  *
  40  * A #GstGLBufferPool is created with gst_d3d11_buffer_pool_new()
  41  */
  42
  43 GST_DEBUG_CATEGORY_STATIC (gst_d3d11_buffer_pool_debug);
  44 #define GST_CAT_DEFAULT gst_d3d11_buffer_pool_debug
  45
  46 struct _GstD3D11BufferPoolPrivate
  47 {
  48   GstD3D11Allocator *alloc[GST_VIDEO_MAX_PLANES];
  49
  50   GstD3D11AllocationParams *d3d11_params;
  51   gboolean texture_array_pool;
  52
  53   gint stride[GST_VIDEO_MAX_PLANES];
  54   gsize offset[GST_VIDEO_MAX_PLANES];
  55 };
  56
  57 #define gst_d3d11_buffer_pool_parent_class parent_class
  58 G_DEFINE_TYPE_WITH_PRIVATE (GstD3D11BufferPool,
  59     gst_d3d11_buffer_pool, GST_TYPE_BUFFER_POOL);
  60
  61 static void gst_d3d11_buffer_pool_dispose (GObject * object);
  62 static const gchar **gst_d3d11_buffer_pool_get_options (GstBufferPool * pool);
  63 static gboolean gst_d3d11_buffer_pool_set_config (GstBufferPool * pool,
  64     GstStructure * config);
  65 static GstFlowReturn gst_d3d11_buffer_pool_alloc_buffer (GstBufferPool * pool,
  66     GstBuffer ** buffer, GstBufferPoolAcquireParams * params);
  67 static GstFlowReturn gst_d3d11_buffer_pool_acquire_buffer (GstBufferPool * pool,
  68     GstBuffer ** buffer, GstBufferPoolAcquireParams * params);
  69 static void gst_d3d11_buffer_pool_reset_buffer (GstBufferPool * pool,
  70     GstBuffer * buffer);
  71 static gboolean gst_d3d11_buffer_pool_start (GstBufferPool * pool);
  72 static gboolean gst_d3d11_buffer_pool_stop (GstBufferPool * pool);
  73
  74 static void
  75 gst_d3d11_buffer_pool_class_init (GstD3D11BufferPoolClass * klass)
  76 {
  77   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  78   GstBufferPoolClass *bufferpool_class = GST_BUFFER_POOL_CLASS (klass);
  79
  80   gobject_class->dispose = gst_d3d11_buffer_pool_dispose;
  81
  82   bufferpool_class->get_options = gst_d3d11_buffer_pool_get_options;
  83   bufferpool_class->set_config = gst_d3d11_buffer_pool_set_config;
  84   bufferpool_class->alloc_buffer = gst_d3d11_buffer_pool_alloc_buffer;
  85   bufferpool_class->acquire_buffer = gst_d3d11_buffer_pool_acquire_buffer;
  86   bufferpool_class->reset_buffer = gst_d3d11_buffer_pool_reset_buffer;
  87   bufferpool_class->start = gst_d3d11_buffer_pool_start;
  88   bufferpool_class->stop = gst_d3d11_buffer_pool_stop;
  89
  90   GST_DEBUG_CATEGORY_INIT (gst_d3d11_buffer_pool_debug, "d3d11bufferpool", 0,
  91       "d3d11bufferpool object");
  92 }
  93
  94 static void
  95 gst_d3d11_buffer_pool_init (GstD3D11BufferPool * self)
  96 {
  97   self->priv = (GstD3D11BufferPoolPrivate *)
  98       gst_d3d11_buffer_pool_get_instance_private (self);
  99 }
 100
 101 static void
 102 gst_d3d11_buffer_pool_clear_allocator (GstD3D11BufferPool * self)
 103 {
 104   GstD3D11BufferPoolPrivate *priv = self->priv;
 105   guint i;
 106
 107   for (i = 0; i < G_N_ELEMENTS (priv->alloc); i++) {
 108     if (priv->alloc[i]) {
 109       gst_d3d11_allocator_set_active (priv->alloc[i], FALSE);
 110       gst_clear_object (&priv->alloc[i]);
 111     }
 112   }
 113 }
 114
 115 static void
 116 gst_d3d11_buffer_pool_dispose (GObject * object)
 117 {
 118   GstD3D11BufferPool *self = GST_D3D11_BUFFER_POOL (object);
 119   GstD3D11BufferPoolPrivate *priv = self->priv;
 120
 121   g_clear_pointer (&priv->d3d11_params, gst_d3d11_allocation_params_free);
 122   gst_clear_object (&self->device);
 123   gst_d3d11_buffer_pool_clear_allocator (self);
 124
 125   G_OBJECT_CLASS (parent_class)->dispose (object);
 126 }
 127
 128 static const gchar **
 129 gst_d3d11_buffer_pool_get_options (GstBufferPool * pool)
 130 {
 131   /* NOTE: d3d11 memory does not support alignment */
 132   static const gchar *options[] = { GST_BUFFER_POOL_OPTION_VIDEO_META, NULL };
 133
 134   return options;
 135 }
 136
 137 static gboolean
 138 gst_d3d11_buffer_pool_set_config (GstBufferPool * pool, GstStructure * config)
 139 {
 140   GstD3D11BufferPool *self = GST_D3D11_BUFFER_POOL (pool);
 141   GstD3D11BufferPoolPrivate *priv = self->priv;
 142   GstVideoInfo info;
 143   GstCaps *caps = NULL;
 144   guint min_buffers, max_buffers;
 145   gboolean ret = TRUE;
 146   D3D11_TEXTURE2D_DESC *desc;
 147   const GstD3D11Format *format;
 148   gsize offset = 0;
 149   gint i;
 150
 151   if (!gst_buffer_pool_config_get_params (config, &caps, NULL, &min_buffers,
 152           &max_buffers))
 153     goto wrong_config;
 154
 155   if (caps == NULL)
 156     goto no_caps;
 157
 158   /* now parse the caps from the config */
 159   if (!gst_video_info_from_caps (&info, caps))
 160     goto wrong_caps;
 161
 162   GST_LOG_OBJECT (pool, "%dx%d, caps %" GST_PTR_FORMAT, info.width, info.height,
 163       caps);
 164
 165   gst_d3d11_buffer_pool_clear_allocator (self);
 166
 167   memset (priv->stride, 0, sizeof (priv->stride));
 168   memset (priv->offset, 0, sizeof (priv->offset));
 169
 170   if (priv->d3d11_params)
 171     gst_d3d11_allocation_params_free (priv->d3d11_params);
 172   priv->d3d11_params =
 173       gst_buffer_pool_config_get_d3d11_allocation_params (config);
 174   if (!priv->d3d11_params) {
 175     /* allocate memory with resource format by default */
 176     priv->d3d11_params =
 177         gst_d3d11_allocation_params_new (self->device,
 178         &info, (GstD3D11AllocationFlags) 0, 0);
 179   }
 180
 181   desc = priv->d3d11_params->desc;
 182
 183   /* resolution of semi-planar formats must be multiple of 2 */
 184   if (desc[0].Format == DXGI_FORMAT_NV12 || desc[0].Format == DXGI_FORMAT_P010
 185       || desc[0].Format == DXGI_FORMAT_P016) {
 186     if (desc[0].Width % 2 || desc[0].Height % 2) {
 187       gint width, height;
 188       GstVideoAlignment align;
 189
 190       GST_WARNING_OBJECT (self, "Resolution %dx%d is not mutiple of 2, fixing",
 191           desc[0].Width, desc[0].Height);
 192
 193       width = GST_ROUND_UP_2 (desc[0].Width);
 194       height = GST_ROUND_UP_2 (desc[0].Height);
 195
 196       gst_video_alignment_reset (&align);
 197       align.padding_right = width - desc[0].Width;
 198       align.padding_bottom = height - desc[0].Height;
 199
 200       gst_d3d11_allocation_params_alignment (priv->d3d11_params, &align);
 201     }
 202   }
 203 #ifndef GST_DISABLE_GST_DEBUG
 204   {
 205     GST_LOG_OBJECT (self, "Direct3D11 Allocation params");
 206     GST_LOG_OBJECT (self, "\tD3D11AllocationFlags: 0x%x",
 207         priv->d3d11_params->flags);
 208     for (i = 0; GST_VIDEO_MAX_PLANES; i++) {
 209       if (desc[i].Format == DXGI_FORMAT_UNKNOWN)
 210         break;
 211       GST_LOG_OBJECT (self, "\t[plane %d] %dx%d, DXGI format %d",
 212           i, desc[i].Width, desc[i].Height, desc[i].Format);
 213       GST_LOG_OBJECT (self, "\t[plane %d] MipLevel %d, ArraySize %d",
 214           i, desc[i].MipLevels, desc[i].ArraySize);
 215       GST_LOG_OBJECT (self,
 216           "\t[plane %d] SampleDesc.Count %d, SampleDesc.Quality %d",
 217           i, desc[i].SampleDesc.Count, desc[i].SampleDesc.Quality);
 218       GST_LOG_OBJECT (self, "\t[plane %d] Usage %d", i, desc[i].Usage);
 219       GST_LOG_OBJECT (self,
 220           "\t[plane %d] BindFlags 0x%x", i, desc[i].BindFlags);
 221       GST_LOG_OBJECT (self,
 222           "\t[plane %d] CPUAccessFlags 0x%x", i, desc[i].CPUAccessFlags);
 223       GST_LOG_OBJECT (self,
 224           "\t[plane %d] MiscFlags 0x%x", i, desc[i].MiscFlags);
 225     }
 226   }
 227 #endif
 228
 229   if ((priv->d3d11_params->flags & GST_D3D11_ALLOCATION_FLAG_TEXTURE_ARRAY)) {
 230     guint max_array_size = 0;
 231
 232     for (i = 0; i < GST_VIDEO_MAX_PLANES; i++) {
 233       if (desc[i].Format == DXGI_FORMAT_UNKNOWN)
 234         break;
 235
 236       if (desc[i].ArraySize > max_array_size)
 237         max_array_size = desc[i].ArraySize;
 238     }
 239
 240     if (max_buffers == 0 || max_buffers > max_array_size) {
 241       GST_WARNING_OBJECT (pool,
 242           "Array pool is requested but allowed pool size %d > ArraySize %d",
 243           max_buffers, max_array_size);
 244       max_buffers = max_array_size;
 245     }
 246
 247     priv->texture_array_pool = TRUE;
 248   } else {
 249     priv->texture_array_pool = FALSE;
 250   }
 251
 252   offset = 0;
 253   for (i = 0; i < GST_VIDEO_MAX_PLANES; i++) {
 254     GstD3D11Allocator *alloc;
 255     GstD3D11PoolAllocator *pool_alloc;
 256     GstFlowReturn flow_ret;
 257     GstMemory *mem = NULL;
 258     guint stride = 0;
 259
 260     if (desc[i].Format == DXGI_FORMAT_UNKNOWN)
 261       break;
 262
 263     alloc =
 264         (GstD3D11Allocator *) gst_d3d11_pool_allocator_new (self->device,
 265         &desc[i]);
 266     if (!gst_d3d11_allocator_set_active (alloc, TRUE)) {
 267       GST_ERROR_OBJECT (self, "Failed to activate allocator");
 268       gst_object_unref (alloc);
 269       return FALSE;
 270     }
 271
 272     pool_alloc = GST_D3D11_POOL_ALLOCATOR (alloc);
 273     flow_ret = gst_d3d11_pool_allocator_acquire_memory (pool_alloc, &mem);
 274     if (flow_ret != GST_FLOW_OK) {
 275       GST_ERROR_OBJECT (self, "Failed to allocate initial memory");
 276       gst_d3d11_allocator_set_active (alloc, FALSE);
 277       gst_object_unref (alloc);
 278       return FALSE;
 279     }
 280
 281     if (!gst_d3d11_memory_get_resource_stride (GST_D3D11_MEMORY_CAST (mem),
 282             &stride) || stride < desc[i].Width) {
 283       GST_ERROR_OBJECT (self, "Failed to calculate stride");
 284
 285       gst_d3d11_allocator_set_active (alloc, FALSE);
 286       gst_object_unref (alloc);
 287       gst_memory_unref (mem);
 288
 289       return FALSE;
 290     }
 291
 292     priv->stride[i] = stride;
 293     priv->offset[i] = offset;
 294     offset += mem->size;
 295
 296     priv->alloc[i] = alloc;
 297
 298     gst_memory_unref (mem);
 299   }
 300
 301   g_assert (priv->d3d11_params->d3d11_format != NULL);
 302   format = priv->d3d11_params->d3d11_format;
 303   /* single texture semi-planar formats */
 304   if (format->dxgi_format != DXGI_FORMAT_UNKNOWN &&
 305       GST_VIDEO_INFO_N_PLANES (&info) == 2) {
 306     priv->stride[1] = priv->stride[0];
 307     priv->offset[1] = priv->stride[0] * desc[0].Height;
 308   }
 309
 310   gst_buffer_pool_config_set_params (config,
 311       caps, offset, min_buffers, max_buffers);
 312
 313   return GST_BUFFER_POOL_CLASS (parent_class)->set_config (pool, config) && ret;
 314
 315   /* ERRORS */
 316 wrong_config:
 317   {
 318     GST_WARNING_OBJECT (pool, "invalid config");
 319     return FALSE;
 320   }
 321 no_caps:
 322   {
 323     GST_WARNING_OBJECT (pool, "no caps in config");
 324     return FALSE;
 325   }
 326 wrong_caps:
 327   {
 328     GST_WARNING_OBJECT (pool,
 329         "failed getting geometry from caps %" GST_PTR_FORMAT, caps);
 330     return FALSE;
 331   }
 332 }
 333
 334 static GstFlowReturn
 335 gst_d3d11_buffer_pool_fill_buffer (GstD3D11BufferPool * self, GstBuffer * buf)
 336 {
 337   GstD3D11BufferPoolPrivate *priv = self->priv;
 338   GstFlowReturn ret = GST_FLOW_OK;
 339   guint i;
 340
 341   for (i = 0; i < G_N_ELEMENTS (priv->alloc); i++) {
 342     GstMemory *mem = NULL;
 343     GstD3D11PoolAllocator *alloc = GST_D3D11_POOL_ALLOCATOR (priv->alloc[i]);
 344
 345     if (!alloc)
 346       break;
 347
 348     ret = gst_d3d11_pool_allocator_acquire_memory (alloc, &mem);
 349     if (ret != GST_FLOW_OK) {
 350       GST_WARNING_OBJECT (self, "Failed to acquire memory, ret %s",
 351           gst_flow_get_name (ret));
 352       return ret;
 353     }
 354
 355     gst_buffer_append_memory (buf, mem);
 356   }
 357
 358   return GST_FLOW_OK;
 359 }
 360
 361 static GstFlowReturn
 362 gst_d3d11_buffer_pool_alloc_buffer (GstBufferPool * pool, GstBuffer ** buffer,
 363     GstBufferPoolAcquireParams * params)
 364 {
 365   GstD3D11BufferPool *self = GST_D3D11_BUFFER_POOL (pool);
 366   GstD3D11BufferPoolPrivate *priv = self->priv;
 367   GstD3D11AllocationParams *d3d11_params = priv->d3d11_params;
 368   GstVideoInfo *info = &d3d11_params->info;
 369   GstBuffer *buf;
 370   GstFlowReturn ret = GST_FLOW_OK;
 371
 372   buf = gst_buffer_new ();
 373   /* In case of texture-array, we are releasing memory objects in
 374    * the GstBufferPool::reset_buffer() so that GstD3D11Memory objects can be
 375    * returned to the GstD3D11PoolAllocator. So, underlying GstD3D11Memory
 376    * will be filled in the later GstBufferPool::acquire_buffer() call.
 377    * Don't fill memory here for non-texture-array therefore */
 378   if (!priv->texture_array_pool) {
 379     ret = gst_d3d11_buffer_pool_fill_buffer (self, buf);
 380     if (ret != GST_FLOW_OK) {
 381       gst_buffer_unref (buf);
 382       return ret;
 383     }
 384   }
 385
 386   gst_buffer_add_video_meta_full (buf, GST_VIDEO_FRAME_FLAG_NONE,
 387       GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info),
 388       GST_VIDEO_INFO_HEIGHT (info), GST_VIDEO_INFO_N_PLANES (info),
 389       priv->offset, priv->stride);
 390
 391   *buffer = buf;
 392
 393   return GST_FLOW_OK;
 394 }
 395
 396 static GstFlowReturn
 397 gst_d3d11_buffer_pool_acquire_buffer (GstBufferPool * pool,
 398     GstBuffer ** buffer, GstBufferPoolAcquireParams * params)
 399 {
 400   GstD3D11BufferPool *self = GST_D3D11_BUFFER_POOL (pool);
 401   GstD3D11BufferPoolPrivate *priv = self->priv;
 402   GstFlowReturn ret;
 403
 404   ret = GST_BUFFER_POOL_CLASS (parent_class)->acquire_buffer (pool,
 405       buffer, params);
 406
 407   if (ret != GST_FLOW_OK)
 408     return ret;
 409
 410   /* Don't need special handling for non-texture-array case */
 411   if (!priv->texture_array_pool)
 412     return ret;
 413
 414   /* Baseclass will hold empty buffer in this case, fill GstMemory */
 415   g_assert (gst_buffer_n_memory (*buffer) == 0);
 416
 417   return gst_d3d11_buffer_pool_fill_buffer (self, *buffer);
 418 }
 419
 420 static void
 421 gst_d3d11_buffer_pool_reset_buffer (GstBufferPool * pool, GstBuffer * buffer)
 422 {
 423   GstD3D11BufferPool *self = GST_D3D11_BUFFER_POOL (pool);
 424   GstD3D11BufferPoolPrivate *priv = self->priv;
 425
 426   /* If we are using texture array, we should return GstD3D11Memory to
 427    * to the GstD3D11PoolAllocator, so that the allocator can wake up
 428    * if it's waiting for available memory object */
 429   if (priv->texture_array_pool) {
 430     GST_LOG_OBJECT (self, "Returning memory to allocator");
 431     gst_buffer_remove_all_memory (buffer);
 432   }
 433
 434   GST_BUFFER_POOL_CLASS (parent_class)->reset_buffer (pool, buffer);
 435   GST_BUFFER_FLAGS (buffer) = 0;
 436 }
 437
 438 static gboolean
 439 gst_d3d11_buffer_pool_start (GstBufferPool * pool)
 440 {
 441   GstD3D11BufferPool *self = GST_D3D11_BUFFER_POOL (pool);
 442   GstD3D11BufferPoolPrivate *priv = self->priv;
 443   guint i;
 444   gboolean ret;
 445
 446   GST_DEBUG_OBJECT (self, "Start");
 447
 448   for (i = 0; i < G_N_ELEMENTS (priv->alloc); i++) {
 449     GstD3D11Allocator *alloc = priv->alloc[i];
 450
 451     if (!alloc)
 452       break;
 453
 454     if (!gst_d3d11_allocator_set_active (alloc, TRUE)) {
 455       GST_ERROR_OBJECT (self, "Failed to activate allocator");
 456       return FALSE;
 457     }
 458   }
 459
 460   ret = GST_BUFFER_POOL_CLASS (parent_class)->start (pool);
 461   if (!ret) {
 462     GST_ERROR_OBJECT (self, "Failed to start");
 463
 464     for (i = 0; i < G_N_ELEMENTS (priv->alloc); i++) {
 465       GstD3D11Allocator *alloc = priv->alloc[i];
 466
 467       if (!alloc)
 468         break;
 469
 470       gst_d3d11_allocator_set_active (alloc, FALSE);
 471     }
 472
 473     return FALSE;
 474   }
 475
 476   return TRUE;
 477 }
 478
 479 static gboolean
 480 gst_d3d11_buffer_pool_stop (GstBufferPool * pool)
 481 {
 482   GstD3D11BufferPool *self = GST_D3D11_BUFFER_POOL (pool);
 483   GstD3D11BufferPoolPrivate *priv = self->priv;
 484   guint i;
 485
 486   GST_DEBUG_OBJECT (self, "Stop");
 487
 488   for (i = 0; i < G_N_ELEMENTS (priv->alloc); i++) {
 489     GstD3D11Allocator *alloc = priv->alloc[i];
 490
 491     if (!alloc)
 492       break;
 493
 494     if (!gst_d3d11_allocator_set_active (alloc, FALSE)) {
 495       GST_ERROR_OBJECT (self, "Failed to deactivate allocator");
 496       return FALSE;
 497     }
 498   }
 499
 500   return GST_BUFFER_POOL_CLASS (parent_class)->stop (pool);
 501 }
 502
 503 /**
 504  * gst_d3d11_buffer_pool_new:
 505  * @device: a #GstD3D11Device to use
 506  *
 507  * Returns: a #GstBufferPool that allocates buffers with #GstD3D11Memory
 508  *
 509  * Since: 1.20
 510  */
 511 GstBufferPool *
 512 gst_d3d11_buffer_pool_new (GstD3D11Device * device)
 513 {
 514   GstD3D11BufferPool *pool;
 515
 516   g_return_val_if_fail (GST_IS_D3D11_DEVICE (device), NULL);
 517
 518   pool = (GstD3D11BufferPool *) g_object_new (GST_TYPE_D3D11_BUFFER_POOL, NULL);
 519   gst_object_ref_sink (pool);
 520
 521   pool->device = (GstD3D11Device *) gst_object_ref (device);
 522
 523   return GST_BUFFER_POOL_CAST (pool);
 524 }
 525
 526 /**
 527  * gst_buffer_pool_config_get_d3d11_allocation_params:
 528  * @config: a buffer pool config
 529  *
 530  * Returns: (transfer full) (nullable): the currently configured
 531  * #GstD3D11AllocationParams on @config or %NULL if @config doesn't contain
 532  * #GstD3D11AllocationParams
 533  *
 534  * Since: 1.20
 535  */
 536 GstD3D11AllocationParams *
 537 gst_buffer_pool_config_get_d3d11_allocation_params (GstStructure * config)
 538 {
 539   GstD3D11AllocationParams *ret;
 540
 541   if (!gst_structure_get (config, "d3d11-allocation-params",
 542           GST_TYPE_D3D11_ALLOCATION_PARAMS, &ret, NULL))
 543     ret = NULL;
 544
 545   return ret;
 546 }
 547
 548 /**
 549  * gst_buffer_pool_config_set_d3d11_allocation_params:
 550  * @config: a buffer pool config
 551  * @params: (transfer none): a #GstD3D11AllocationParams
 552  *
 553  * Sets @params on @config
 554  *
 555  * Since: 1.20
 556  */
 557 void
 558 gst_buffer_pool_config_set_d3d11_allocation_params (GstStructure * config,
 559     GstD3D11AllocationParams * params)
 560 {
 561   g_return_if_fail (config != NULL);
 562   g_return_if_fail (params != NULL);
 563
 564   gst_structure_set (config, "d3d11-allocation-params",
 565       GST_TYPE_D3D11_ALLOCATION_PARAMS, params, NULL);
 566 }