sys/msdk/gstmsdkvideomemory.c

   1 /* GStreamer Intel MSDK plugin
   2  * Copyright (c) 2018, Intel Corporation
   3  * Copyright (c) 2018, Igalia S.L.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright notice,
  10  *    this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright notice,
  13  *    this list of conditions and the following disclaimer in the documentation
  14  *    and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of the copyright holder nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGDECE
  29  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #ifndef _WIN32
  34 #include <unistd.h>
  35 #include <va/va.h>
  36 #endif
  37 #include <stdlib.h>
  38 #include "gstmsdkvideomemory.h"
  39 #include "gstmsdkallocator.h"
  40
  41 #define GST_MSDK_BUFFER_SURFACE gst_msdk_buffer_surface_quark_get ()
  42 static GQuark
  43 gst_msdk_buffer_surface_quark_get (void)
  44 {
  45   static gsize g_quark;
  46
  47   if (g_once_init_enter (&g_quark)) {
  48     gsize quark = (gsize) g_quark_from_static_string ("GstMsdkBufferSurface");
  49     g_once_init_leave (&g_quark, quark);
  50   }
  51   return g_quark;
  52 }
  53
  54 static mfxFrameSurface1 *
  55 gst_msdk_video_allocator_get_surface (GstAllocator * allocator)
  56 {
  57   mfxFrameInfo frame_info = { {0,}, 0, };
  58   mfxFrameSurface1 *surface;
  59   GstMsdkContext *context = NULL;
  60   mfxFrameAllocResponse *resp = NULL;
  61   GstVideoInfo *vinfo = NULL;
  62
  63   if (GST_IS_MSDK_VIDEO_ALLOCATOR (allocator)) {
  64     context = GST_MSDK_VIDEO_ALLOCATOR_CAST (allocator)->context;
  65     resp = GST_MSDK_VIDEO_ALLOCATOR_CAST (allocator)->alloc_response;
  66     vinfo = &GST_MSDK_VIDEO_ALLOCATOR_CAST (allocator)->image_info;
  67   } else if (GST_IS_MSDK_DMABUF_ALLOCATOR (allocator)) {
  68     context = GST_MSDK_DMABUF_ALLOCATOR_CAST (allocator)->context;
  69     resp = GST_MSDK_DMABUF_ALLOCATOR_CAST (allocator)->alloc_response;
  70     vinfo = &GST_MSDK_DMABUF_ALLOCATOR_CAST (allocator)->image_info;
  71   } else {
  72     return NULL;
  73   }
  74
  75   surface = gst_msdk_context_get_surface_available (context, resp);
  76   if (!surface) {
  77     GST_ERROR ("failed to get surface available");
  78     return NULL;
  79   }
  80
  81   gst_msdk_set_mfx_frame_info_from_video_info (&frame_info, vinfo);
  82   surface->Info = frame_info;
  83
  84   return surface;
  85 }
  86
  87 gboolean
  88 gst_msdk_video_memory_get_surface_available (GstMemory * mem)
  89 {
  90   GstAllocator *allocator;
  91   mfxFrameSurface1 *surface;
  92
  93   g_return_val_if_fail (mem, FALSE);
  94
  95   allocator = mem->allocator;
  96   surface = gst_msdk_video_allocator_get_surface (allocator);
  97
  98   if (GST_IS_MSDK_VIDEO_ALLOCATOR (allocator)) {
  99     GST_MSDK_VIDEO_MEMORY_CAST (mem)->surface = surface;
 100   } else if (GST_IS_MSDK_DMABUF_ALLOCATOR (allocator)) {
 101     gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (mem),
 102         GST_MSDK_BUFFER_SURFACE, surface, NULL);
 103   }
 104
 105   return surface ? TRUE : FALSE;
 106 }
 107
 108 /*
 109  * Every time releasing a gst buffer, we need to check the status of surface's lock,
 110  * so that we could manage locked surfaces seperatedly in the context.
 111  * Otherwise, we put the surface to the available list.
 112  */
 113 void
 114 gst_msdk_video_memory_release_surface (GstMemory * mem)
 115 {
 116   mfxFrameSurface1 *surface = NULL;
 117   GstMsdkContext *context = NULL;
 118   mfxFrameAllocResponse *alloc_response = NULL;
 119
 120   g_return_if_fail (mem);
 121
 122   if (GST_IS_MSDK_VIDEO_ALLOCATOR (mem->allocator)) {
 123     surface = GST_MSDK_VIDEO_MEMORY_CAST (mem)->surface;
 124     context = GST_MSDK_VIDEO_ALLOCATOR_CAST (mem->allocator)->context;
 125     alloc_response =
 126         GST_MSDK_VIDEO_ALLOCATOR_CAST (mem->allocator)->alloc_response;
 127   } else if (GST_IS_MSDK_DMABUF_ALLOCATOR (mem->allocator)) {
 128     surface =
 129         gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
 130         GST_MSDK_BUFFER_SURFACE);
 131     context = GST_MSDK_DMABUF_ALLOCATOR_CAST (mem->allocator)->context;
 132     alloc_response =
 133         GST_MSDK_DMABUF_ALLOCATOR_CAST (mem->allocator)->alloc_response;
 134   } else {
 135     return;
 136   }
 137
 138   if (surface->Data.Locked > 0)
 139     gst_msdk_context_put_surface_locked (context, alloc_response, surface);
 140   else
 141     gst_msdk_context_put_surface_available (context, alloc_response, surface);
 142
 143   if (GST_IS_MSDK_VIDEO_ALLOCATOR (mem->allocator))
 144     GST_MSDK_VIDEO_MEMORY_CAST (mem)->surface = NULL;
 145   else if (GST_IS_MSDK_DMABUF_ALLOCATOR (mem->allocator))
 146     gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (mem),
 147         GST_MSDK_BUFFER_SURFACE, NULL, NULL);
 148
 149   return;
 150 }
 151
 152 GstMemory *
 153 gst_msdk_video_memory_new (GstAllocator * base_allocator)
 154 {
 155   GstMsdkVideoAllocator *allocator;
 156   GstVideoInfo *vip;
 157   GstMsdkVideoMemory *mem;
 158
 159   g_return_val_if_fail (base_allocator, NULL);
 160   g_return_val_if_fail (GST_IS_MSDK_VIDEO_ALLOCATOR (base_allocator), NULL);
 161
 162   allocator = GST_MSDK_VIDEO_ALLOCATOR_CAST (base_allocator);
 163
 164   mem = g_slice_new0 (GstMsdkVideoMemory);
 165   if (!mem)
 166     return NULL;
 167
 168   mem->surface = gst_msdk_video_allocator_get_surface (base_allocator);
 169   if (!mem->surface) {
 170     g_slice_free (GstMsdkVideoMemory, mem);
 171     return NULL;
 172   }
 173
 174   vip = &allocator->image_info;
 175   gst_memory_init (&mem->parent_instance, 0,
 176       base_allocator, NULL, GST_VIDEO_INFO_SIZE (vip), 0, 0,
 177       GST_VIDEO_INFO_SIZE (vip));
 178
 179   return GST_MEMORY_CAST (mem);
 180 }
 181
 182 gboolean
 183 gst_video_meta_map_msdk_memory (GstVideoMeta * meta, guint plane,
 184     GstMapInfo * info, gpointer * data, gint * stride, GstMapFlags flags)
 185 {
 186   gboolean ret = FALSE;
 187   GstAllocator *allocator;
 188   GstMsdkVideoAllocator *msdk_video_allocator;
 189   GstMsdkVideoMemory *mem =
 190       GST_MSDK_VIDEO_MEMORY_CAST (gst_buffer_peek_memory (meta->buffer, 0));
 191   GstMsdkMemoryID *mem_id;
 192   guint offset = 0;
 193   gint pitch = 0;
 194   guint plane_id = plane;
 195
 196   g_return_val_if_fail (mem, FALSE);
 197
 198   allocator = GST_MEMORY_CAST (mem)->allocator;
 199   msdk_video_allocator = GST_MSDK_VIDEO_ALLOCATOR_CAST (allocator);
 200
 201   if (!GST_IS_MSDK_VIDEO_ALLOCATOR (allocator)) {
 202     GST_WARNING ("The allocator is not MSDK video allocator");
 203     return FALSE;
 204   }
 205
 206   if (!mem->surface) {
 207     GST_WARNING ("The surface is not allocated");
 208     return FALSE;
 209   }
 210
 211   if ((flags & GST_MAP_WRITE) && mem->surface && mem->surface->Data.Locked) {
 212     GST_WARNING ("The surface in memory %p is not still avaliable", mem);
 213     return FALSE;
 214   }
 215
 216   if (!mem->mapped) {
 217     gst_msdk_frame_lock (msdk_video_allocator->context,
 218         mem->surface->Data.MemId, &mem->surface->Data);
 219   }
 220
 221   mem->mapped++;
 222   mem_id = mem->surface->Data.MemId;
 223
 224   /* msdk doesn't support I420 format and we used YV12 internally
 225    * So we need to swap U/V planes for mapping */
 226   if (meta->format == GST_VIDEO_FORMAT_I420)
 227     plane_id = plane ? (plane == 1 ? 2 : 1) : plane;
 228
 229 #ifndef _WIN32
 230   offset = mem_id->image.offsets[plane_id];
 231   pitch = mem_id->image.pitches[plane_id];
 232 #else
 233   /* TODO: This is just to avoid compile errors on Windows.
 234    * Implement handling Windows-specific video-memory.
 235    */
 236   offset = mem_id->offset;
 237   pitch = mem_id->pitch;
 238 #endif
 239
 240   /* The first channel in memory is V for GST_VIDEO_FORMAT_VUYA */
 241   if (meta->format == GST_VIDEO_FORMAT_VUYA)
 242     *data = mem->surface->Data.V + offset;
 243   else if (meta->format == GST_VIDEO_FORMAT_Y410)
 244     *data = mem->surface->Data.U + offset;      /* Data.Y410 */
 245   else
 246     *data = mem->surface->Data.Y + offset;
 247   *stride = pitch;
 248
 249   info->flags = flags;
 250   ret = (*data != NULL);
 251
 252   return ret;
 253 }
 254
 255 gboolean
 256 gst_video_meta_unmap_msdk_memory (GstVideoMeta * meta, guint plane,
 257     GstMapInfo * info)
 258 {
 259   GstAllocator *allocator;
 260   GstMsdkVideoAllocator *msdk_video_allocator;
 261   GstMsdkVideoMemory *mem =
 262       GST_MSDK_VIDEO_MEMORY_CAST (gst_buffer_peek_memory (meta->buffer, 0));
 263
 264   g_return_val_if_fail (mem, FALSE);
 265
 266   allocator = GST_MEMORY_CAST (mem)->allocator;
 267   msdk_video_allocator = GST_MSDK_VIDEO_ALLOCATOR_CAST (allocator);
 268
 269   if (mem->mapped == 1)
 270     gst_msdk_frame_unlock (msdk_video_allocator->context,
 271         mem->surface->Data.MemId, &mem->surface->Data);
 272
 273   mem->mapped--;
 274
 275   return TRUE;
 276 }
 277
 278
 279 static gpointer
 280 gst_msdk_video_memory_map_full (GstMemory * base_mem, GstMapInfo * info,
 281     gsize maxsize)
 282 {
 283   GstMsdkVideoMemory *const mem = GST_MSDK_VIDEO_MEMORY_CAST (base_mem);
 284   GstAllocator *allocator = base_mem->allocator;
 285   GstMsdkVideoAllocator *msdk_video_allocator =
 286       GST_MSDK_VIDEO_ALLOCATOR_CAST (allocator);
 287
 288   g_return_val_if_fail (mem, NULL);
 289
 290   if (!mem->surface) {
 291     GST_WARNING ("The surface is not allocated");
 292     return NULL;
 293   }
 294
 295   if ((info->flags & GST_MAP_WRITE) && mem->surface
 296       && mem->surface->Data.Locked) {
 297     GST_WARNING ("The surface in memory %p is not still avaliable", mem);
 298     return NULL;
 299   }
 300
 301   gst_msdk_frame_lock (msdk_video_allocator->context, mem->surface->Data.MemId,
 302       &mem->surface->Data);
 303   return mem->surface->Data.Y;
 304 }
 305
 306 static void
 307 gst_msdk_video_memory_unmap (GstMemory * base_mem)
 308 {
 309   GstMsdkVideoMemory *const mem = GST_MSDK_VIDEO_MEMORY_CAST (base_mem);
 310   GstAllocator *allocator = base_mem->allocator;
 311   GstMsdkVideoAllocator *msdk_video_allocator =
 312       GST_MSDK_VIDEO_ALLOCATOR_CAST (allocator);
 313
 314   gst_msdk_frame_unlock (msdk_video_allocator->context,
 315       mem->surface->Data.MemId, &mem->surface->Data);
 316 }
 317
 318 static GstMemory *
 319 gst_msdk_video_memory_copy (GstMemory * base_mem, gssize offset, gssize size)
 320 {
 321   GstMemory *copy;
 322   GstVideoInfo *info;
 323   GstMsdkVideoAllocator *msdk_video_allocator;
 324   gsize mem_size;
 325   GstMapInfo src_map, dst_map;
 326
 327   /* FIXME: can we consider offset and size here ? */
 328   copy = gst_msdk_video_memory_new (base_mem->allocator);
 329
 330   if (!copy) {
 331     GST_ERROR_OBJECT (base_mem->allocator, "Failed to create new video memory");
 332     return NULL;
 333   }
 334
 335   msdk_video_allocator = GST_MSDK_VIDEO_ALLOCATOR_CAST (base_mem->allocator);
 336
 337   info = &msdk_video_allocator->image_info;
 338   mem_size = GST_VIDEO_INFO_SIZE (info);
 339
 340   gst_memory_map (base_mem, &src_map, GST_MAP_READ);
 341   gst_memory_map (copy, &dst_map, GST_MAP_WRITE);
 342
 343   memcpy (dst_map.data, src_map.data, mem_size);
 344   gst_memory_unmap (copy, &dst_map);
 345   gst_memory_unmap (base_mem, &src_map);
 346
 347   return copy;
 348 }
 349
 350 /* GstMsdkVideoAllocator */
 351 G_DEFINE_TYPE (GstMsdkVideoAllocator, gst_msdk_video_allocator,
 352     GST_TYPE_ALLOCATOR);
 353
 354 static GstMemory *
 355 gst_msdk_video_allocator_alloc (GstAllocator * allocator, gsize size,
 356     GstAllocationParams * params)
 357 {
 358   return gst_msdk_video_memory_new (allocator);
 359 }
 360
 361 static void
 362 gst_msdk_video_allocator_finalize (GObject * object)
 363 {
 364   GstMsdkVideoAllocator *allocator = GST_MSDK_VIDEO_ALLOCATOR_CAST (object);
 365
 366   gst_msdk_frame_free (allocator->context, allocator->alloc_response);
 367
 368   gst_object_unref (allocator->context);
 369   G_OBJECT_CLASS (gst_msdk_video_allocator_parent_class)->finalize (object);
 370 }
 371
 372 static void
 373 gst_msdk_video_allocator_free (GstAllocator * allocator, GstMemory * base_mem)
 374 {
 375   GstMsdkVideoMemory *const mem = GST_MSDK_VIDEO_MEMORY_CAST (base_mem);
 376
 377   g_slice_free (GstMsdkVideoMemory, mem);
 378 }
 379
 380 static void
 381 gst_msdk_video_allocator_class_init (GstMsdkVideoAllocatorClass * klass)
 382 {
 383   GObjectClass *const object_class = G_OBJECT_CLASS (klass);
 384   GstAllocatorClass *const allocator_class = GST_ALLOCATOR_CLASS (klass);
 385
 386   object_class->finalize = gst_msdk_video_allocator_finalize;
 387
 388   allocator_class->alloc = gst_msdk_video_allocator_alloc;
 389   allocator_class->free = gst_msdk_video_allocator_free;
 390 }
 391
 392 static void
 393 gst_msdk_video_allocator_init (GstMsdkVideoAllocator * allocator)
 394 {
 395   GstAllocator *const base_allocator = GST_ALLOCATOR_CAST (allocator);
 396
 397   base_allocator->mem_type = GST_MSDK_VIDEO_MEMORY_NAME;
 398   base_allocator->mem_map_full = gst_msdk_video_memory_map_full;
 399   base_allocator->mem_unmap = gst_msdk_video_memory_unmap;
 400   base_allocator->mem_copy = gst_msdk_video_memory_copy;
 401
 402   GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);
 403 }
 404
 405 GstAllocator *
 406 gst_msdk_video_allocator_new (GstMsdkContext * context,
 407     GstVideoInfo * image_info, mfxFrameAllocResponse * alloc_resp)
 408 {
 409   GstMsdkVideoAllocator *allocator;
 410   GstMsdkAllocResponse *cached = NULL;
 411
 412   g_return_val_if_fail (context != NULL, NULL);
 413   g_return_val_if_fail (image_info != NULL, NULL);
 414
 415   cached = gst_msdk_context_get_cached_alloc_responses (context, alloc_resp);
 416
 417   if (!cached) {
 418     GST_ERROR ("Failed to get the cached alloc response");
 419     return NULL;
 420   }
 421
 422   allocator = g_object_new (GST_TYPE_MSDK_VIDEO_ALLOCATOR, NULL);
 423   if (!allocator)
 424     return NULL;
 425
 426   g_atomic_int_inc (&cached->refcount);
 427   allocator->context = gst_object_ref (context);
 428   allocator->image_info = *image_info;
 429   allocator->mfx_response = *alloc_resp;
 430   allocator->alloc_response = &allocator->mfx_response;
 431
 432   return GST_ALLOCATOR_CAST (allocator);
 433 }
 434
 435 /* GstMsdkDmaBufMemory */
 436 GstMemory *
 437 gst_msdk_dmabuf_memory_new (GstAllocator * base_allocator)
 438 {
 439 #ifndef _WIN32
 440   mfxFrameSurface1 *surface;
 441
 442   g_return_val_if_fail (base_allocator, NULL);
 443   g_return_val_if_fail (GST_IS_MSDK_DMABUF_ALLOCATOR (base_allocator), NULL);
 444
 445   surface = gst_msdk_video_allocator_get_surface (base_allocator);
 446   if (!surface)
 447     return NULL;
 448
 449   return gst_msdk_dmabuf_memory_new_with_surface (base_allocator, surface);
 450 #else
 451   return NULL;
 452 #endif
 453 }
 454
 455 GstMemory *
 456 gst_msdk_dmabuf_memory_new_with_surface (GstAllocator * allocator,
 457     mfxFrameSurface1 * surface)
 458 {
 459 #ifndef _WIN32
 460   GstMemory *mem;
 461   GstMsdkMemoryID *mem_id;
 462   gint fd;
 463   gsize size;
 464
 465   g_return_val_if_fail (allocator, NULL);
 466   g_return_val_if_fail (GST_IS_MSDK_DMABUF_ALLOCATOR (allocator), NULL);
 467
 468   mem_id = surface->Data.MemId;
 469   fd = mem_id->info.handle;
 470   size = mem_id->info.mem_size;
 471
 472   if (fd < 0 || (fd = dup (fd)) < 0) {
 473     GST_ERROR ("Failed to get dmabuf handle");
 474     return NULL;
 475   }
 476
 477   mem = gst_dmabuf_allocator_alloc (allocator, fd, size);
 478   if (!mem) {
 479     GST_ERROR ("failed ! dmabuf fd: %d", fd);
 480     close (fd);
 481     return NULL;
 482   }
 483
 484   gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (mem),
 485       GST_MSDK_BUFFER_SURFACE, surface, NULL);
 486
 487   return mem;
 488 #else
 489   return NULL;
 490 #endif
 491 }
 492
 493 /* GstMsdkDmaBufAllocator */
 494 G_DEFINE_TYPE (GstMsdkDmaBufAllocator, gst_msdk_dmabuf_allocator,
 495     GST_TYPE_DMABUF_ALLOCATOR);
 496
 497 static void
 498 gst_msdk_dmabuf_allocator_finalize (GObject * object)
 499 {
 500   GstMsdkDmaBufAllocator *allocator = GST_MSDK_DMABUF_ALLOCATOR_CAST (object);
 501
 502   gst_msdk_frame_free (allocator->context, allocator->alloc_response);
 503
 504   gst_object_unref (allocator->context);
 505   G_OBJECT_CLASS (gst_msdk_dmabuf_allocator_parent_class)->finalize (object);
 506 }
 507
 508 static void
 509 gst_msdk_dmabuf_allocator_class_init (GstMsdkDmaBufAllocatorClass * klass)
 510 {
 511   GObjectClass *const object_class = G_OBJECT_CLASS (klass);
 512
 513   object_class->finalize = gst_msdk_dmabuf_allocator_finalize;
 514 }
 515
 516 static void
 517 gst_msdk_dmabuf_allocator_init (GstMsdkDmaBufAllocator * allocator)
 518 {
 519   GstAllocator *const base_allocator = GST_ALLOCATOR_CAST (allocator);
 520   base_allocator->mem_type = GST_MSDK_DMABUF_MEMORY_NAME;
 521 }
 522
 523 GstAllocator *
 524 gst_msdk_dmabuf_allocator_new (GstMsdkContext * context,
 525     GstVideoInfo * image_info, mfxFrameAllocResponse * alloc_resp)
 526 {
 527   GstMsdkDmaBufAllocator *allocator;
 528   GstMsdkAllocResponse *cached = NULL;
 529
 530   g_return_val_if_fail (context != NULL, NULL);
 531   g_return_val_if_fail (image_info != NULL, NULL);
 532
 533   cached = gst_msdk_context_get_cached_alloc_responses (context, alloc_resp);
 534
 535   if (!cached) {
 536     GST_ERROR ("Failed to get the cached alloc response");
 537     return NULL;
 538   }
 539
 540   allocator = g_object_new (GST_TYPE_MSDK_DMABUF_ALLOCATOR, NULL);
 541   if (!allocator)
 542     return NULL;
 543
 544   g_atomic_int_inc (&cached->refcount);
 545   allocator->context = gst_object_ref (context);
 546   allocator->image_info = *image_info;
 547   allocator->mfx_response = *alloc_resp;
 548   allocator->alloc_response = &allocator->mfx_response;
 549
 550   return GST_ALLOCATOR_CAST (allocator);
 551 }