gst/vaapi/gstvaapivideomemory.c

   1 /*
   2  *  gstvaapivideomemory.c - Gstreamer/VA video memory
   3  *
   4  *  Copyright (C) 2013 Intel Corporation
   5  *    Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Lesser General Public License
   9  *  as published by the Free Software Foundation; either version 2.1
  10  *  of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Lesser General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Lesser General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  *  Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "gst/vaapi/sysdeps.h"
  24 #include "gstvaapivideomemory.h"
  25
  26 GST_DEBUG_CATEGORY_STATIC(gst_debug_vaapivideomemory);
  27 #define GST_CAT_DEFAULT gst_debug_vaapivideomemory
  28
  29 #ifndef GST_VIDEO_INFO_FORMAT_STRING
  30 #define GST_VIDEO_INFO_FORMAT_STRING(vip) \
  31     gst_video_format_to_string(GST_VIDEO_INFO_FORMAT(vip))
  32 #endif
  33
  34 /* ------------------------------------------------------------------------ */
  35 /* --- GstVaapiVideoMemory                                              --- */
  36 /* ------------------------------------------------------------------------ */
  37
  38 static guchar *
  39 get_image_data(GstVaapiImage *image)
  40 {
  41     guchar *data;
  42     VAImage va_image;
  43
  44     data = gst_vaapi_image_get_plane(image, 0);
  45     if (!data || !gst_vaapi_image_get_image(image, &va_image))
  46         return NULL;
  47
  48     data -= va_image.offsets[0];
  49     return data;
  50 }
  51
  52 static GstVaapiImage *
  53 new_image(GstVaapiDisplay *display, const GstVideoInfo *vip)
  54 {
  55     return gst_vaapi_image_new(display, GST_VIDEO_INFO_FORMAT(vip),
  56         GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
  57 }
  58
  59 static gboolean
  60 ensure_image(GstVaapiVideoMemory *mem)
  61 {
  62     if (!mem->image && mem->use_direct_rendering) {
  63         mem->image = gst_vaapi_surface_derive_image(mem->surface);
  64         if (!mem->image) {
  65             GST_WARNING("failed to derive image, fallbacking to copy");
  66             mem->use_direct_rendering = FALSE;
  67         }
  68         else if (gst_vaapi_surface_get_format(mem->surface) !=
  69                  GST_VIDEO_INFO_FORMAT(mem->image_info)) {
  70             gst_vaapi_object_replace(&mem->image, NULL);
  71             mem->use_direct_rendering = FALSE;
  72         }
  73     }
  74
  75     if (!mem->image) {
  76         GstVaapiDisplay * const display =
  77             gst_vaapi_video_meta_get_display(mem->meta);
  78
  79         mem->image = new_image(display, mem->image_info);
  80         if (!mem->image)
  81             return FALSE;
  82     }
  83     gst_vaapi_video_meta_set_image(mem->meta, mem->image);
  84     return TRUE;
  85 }
  86
  87 static GstVaapiSurface *
  88 new_surface(GstVaapiDisplay *display, const GstVideoInfo *vip)
  89 {
  90     GstVaapiSurface *surface;
  91     GstVaapiChromaType chroma_type;
  92
  93     /* Try with explicit format first */
  94     if (GST_VIDEO_INFO_FORMAT(vip) != GST_VIDEO_FORMAT_ENCODED) {
  95         surface = gst_vaapi_surface_new_with_format(display,
  96             GST_VIDEO_INFO_FORMAT(vip), GST_VIDEO_INFO_WIDTH(vip),
  97             GST_VIDEO_INFO_HEIGHT(vip));
  98         if (surface)
  99             return surface;
 100     }
 101
 102     /* Try to pick something compatible, i.e. with same chroma type */
 103     chroma_type = gst_vaapi_video_format_get_chroma_type(
 104         GST_VIDEO_INFO_FORMAT(vip));
 105     if (!chroma_type)
 106         return NULL;
 107     return gst_vaapi_surface_new(display, chroma_type,
 108         GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
 109 }
 110
 111 static GstVaapiSurfaceProxy *
 112 new_surface_proxy(GstVaapiVideoMemory *mem)
 113 {
 114     GstVaapiVideoAllocator * const allocator =
 115         GST_VAAPI_VIDEO_ALLOCATOR_CAST(GST_MEMORY_CAST(mem)->allocator);
 116
 117     return gst_vaapi_surface_proxy_new_from_pool(
 118         GST_VAAPI_SURFACE_POOL(allocator->surface_pool));
 119 }
 120
 121 static gboolean
 122 ensure_surface(GstVaapiVideoMemory *mem)
 123 {
 124     if (!mem->proxy) {
 125         gst_vaapi_surface_proxy_replace(&mem->proxy,
 126             gst_vaapi_video_meta_get_surface_proxy(mem->meta));
 127
 128         if (!mem->proxy) {
 129             mem->proxy = new_surface_proxy(mem);
 130             if (!mem->proxy)
 131                 return FALSE;
 132             gst_vaapi_video_meta_set_surface_proxy(mem->meta, mem->proxy);
 133         }
 134     }
 135     mem->surface = GST_VAAPI_SURFACE_PROXY_SURFACE(mem->proxy);
 136     return mem->surface != NULL;
 137 }
 138
 139 gboolean
 140 gst_video_meta_map_vaapi_memory(GstVideoMeta *meta, guint plane,
 141     GstMapInfo *info, gpointer *data, gint *stride, GstMapFlags flags)
 142 {
 143     GstVaapiVideoMemory * const mem =
 144         GST_VAAPI_VIDEO_MEMORY_CAST(gst_buffer_peek_memory(meta->buffer, 0));
 145
 146     g_return_val_if_fail(mem, FALSE);
 147     g_return_val_if_fail(GST_VAAPI_IS_VIDEO_ALLOCATOR(mem->parent_instance.
 148                              allocator), FALSE);
 149     g_return_val_if_fail(mem->meta, FALSE);
 150
 151     if (mem->map_type &&
 152         mem->map_type != GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_PLANAR)
 153         goto error_incompatible_map;
 154
 155     /* Map for writing */
 156     if (++mem->map_count == 1) {
 157         if (!ensure_surface(mem))
 158             goto error_ensure_surface;
 159         if (!ensure_image(mem))
 160             goto error_ensure_image;
 161
 162         // Check that we can actually map the surface, or image
 163         if ((flags & GST_MAP_READWRITE) == GST_MAP_WRITE &&
 164             !mem->use_direct_rendering)
 165             goto error_unsupported_map;
 166
 167         // Load VA image from surface
 168         if ((flags & GST_MAP_READ) && !mem->use_direct_rendering)
 169             gst_vaapi_surface_get_image(mem->surface, mem->image);
 170
 171         if (!gst_vaapi_image_map(mem->image))
 172             goto error_map_image;
 173         mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_PLANAR;
 174     }
 175
 176     *data = gst_vaapi_image_get_plane(mem->image, plane);
 177     *stride = gst_vaapi_image_get_pitch(mem->image, plane);
 178     info->flags = flags;
 179     return TRUE;
 180
 181     /* ERRORS */
 182 error_incompatible_map:
 183     {
 184         GST_ERROR("incompatible map type (%d)", mem->map_type);
 185         return FALSE;
 186     }
 187 error_unsupported_map:
 188     {
 189         GST_ERROR("unsupported map flags (0x%x)", flags);
 190         return FALSE;
 191     }
 192 error_ensure_surface:
 193     {
 194         const GstVideoInfo * const vip = mem->surface_info;
 195         GST_ERROR("failed to create %s surface of size %ux%u",
 196                   GST_VIDEO_INFO_FORMAT_STRING(vip),
 197                   GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
 198         return FALSE;
 199     }
 200 error_ensure_image:
 201     {
 202         const GstVideoInfo * const vip = mem->image_info;
 203         GST_ERROR("failed to create %s image of size %ux%u",
 204                   GST_VIDEO_INFO_FORMAT_STRING(vip),
 205                   GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
 206         return FALSE;
 207     }
 208 error_map_image:
 209     {
 210         GST_ERROR("failed to map image %" GST_VAAPI_ID_FORMAT,
 211                   GST_VAAPI_ID_ARGS(gst_vaapi_image_get_id(mem->image)));
 212         return FALSE;
 213     }
 214 }
 215
 216 gboolean
 217 gst_video_meta_unmap_vaapi_memory(GstVideoMeta *meta, guint plane,
 218     GstMapInfo *info)
 219 {
 220     GstVaapiVideoMemory * const mem =
 221         GST_VAAPI_VIDEO_MEMORY_CAST(gst_buffer_peek_memory(meta->buffer, 0));
 222
 223     g_return_val_if_fail(mem, FALSE);
 224     g_return_val_if_fail(GST_VAAPI_IS_VIDEO_ALLOCATOR(mem->parent_instance.
 225                              allocator), FALSE);
 226     g_return_val_if_fail(mem->meta, FALSE);
 227     g_return_val_if_fail(mem->surface, FALSE);
 228     g_return_val_if_fail(mem->image, FALSE);
 229
 230     if (--mem->map_count == 0) {
 231         mem->map_type = 0;
 232
 233         /* Unmap VA image used for read/writes */
 234         if (info->flags & GST_MAP_READWRITE)
 235             gst_vaapi_image_unmap(mem->image);
 236
 237         /* Commit VA image to surface */
 238         if ((info->flags & GST_MAP_WRITE) && !mem->use_direct_rendering) {
 239             if (!gst_vaapi_surface_put_image(mem->surface, mem->image))
 240                 goto error_upload_image;
 241         }
 242     }
 243     return TRUE;
 244
 245     /* ERRORS */
 246 error_upload_image:
 247     {
 248         GST_ERROR("failed to upload image");
 249         return FALSE;
 250     }
 251 }
 252
 253 GstMemory *
 254 gst_vaapi_video_memory_new(GstAllocator *base_allocator,
 255     GstVaapiVideoMeta *meta)
 256 {
 257     GstVaapiVideoAllocator * const allocator =
 258         GST_VAAPI_VIDEO_ALLOCATOR_CAST(base_allocator);
 259     const GstVideoInfo *vip;
 260     GstVaapiVideoMemory *mem;
 261
 262     mem = g_slice_new(GstVaapiVideoMemory);
 263     if (!mem)
 264         return NULL;
 265
 266     vip = &allocator->image_info;
 267     gst_memory_init(&mem->parent_instance, 0, gst_object_ref(allocator), NULL,
 268         GST_VIDEO_INFO_SIZE(vip), 0, 0, GST_VIDEO_INFO_SIZE(vip));
 269
 270     mem->proxy = NULL;
 271     mem->surface_info = &allocator->surface_info;
 272     mem->surface = NULL;
 273     mem->image_info = &allocator->image_info;
 274     mem->image = NULL;
 275     mem->meta = gst_vaapi_video_meta_ref(meta);
 276     mem->map_type = 0;
 277     mem->map_count = 0;
 278     mem->use_direct_rendering = allocator->has_direct_rendering;
 279     return GST_MEMORY_CAST(mem);
 280 }
 281
 282 static void
 283 gst_vaapi_video_memory_free(GstVaapiVideoMemory *mem)
 284 {
 285     mem->surface = NULL;
 286     gst_vaapi_surface_proxy_replace(&mem->proxy, NULL);
 287     gst_vaapi_object_replace(&mem->image, NULL);
 288     gst_vaapi_video_meta_unref(mem->meta);
 289     gst_object_unref(GST_MEMORY_CAST(mem)->allocator);
 290     g_slice_free(GstVaapiVideoMemory, mem);
 291 }
 292
 293 void
 294 gst_vaapi_video_memory_reset_surface(GstVaapiVideoMemory *mem)
 295 {
 296     mem->surface = NULL;
 297     gst_vaapi_surface_proxy_replace(&mem->proxy, NULL);
 298     if (mem->use_direct_rendering)
 299         gst_vaapi_object_replace(&mem->image, NULL);
 300     gst_vaapi_video_meta_set_surface_proxy(mem->meta, NULL);
 301 }
 302
 303 static gpointer
 304 gst_vaapi_video_memory_map(GstVaapiVideoMemory *mem, gsize maxsize, guint flags)
 305 {
 306     gpointer data;
 307
 308     if (mem->map_count == 0) {
 309         switch (flags & GST_MAP_READWRITE) {
 310         case 0:
 311             // No flags set: return a GstVaapiSurfaceProxy
 312             gst_vaapi_surface_proxy_replace(&mem->proxy,
 313                 gst_vaapi_video_meta_get_surface_proxy(mem->meta));
 314             if (!mem->proxy)
 315                 goto error_no_surface_proxy;
 316             mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE;
 317             break;
 318         case GST_MAP_READ:
 319             // Only read flag set: return raw pixels
 320             if (!ensure_surface(mem))
 321                 goto error_no_surface;
 322             if (!ensure_image(mem))
 323                 goto error_no_image;
 324             if (!mem->use_direct_rendering)
 325                 gst_vaapi_surface_get_image(mem->surface, mem->image);
 326             if (!gst_vaapi_image_map(mem->image))
 327                 goto error_map_image;
 328             mem->map_type = GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_LINEAR;
 329             break;
 330         default:
 331             goto error_unsupported_map;
 332         }
 333     }
 334
 335     switch (mem->map_type) {
 336     case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE:
 337         if (!mem->proxy)
 338             goto error_no_surface_proxy;
 339         data = mem->proxy;
 340         break;
 341     case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_LINEAR:
 342         if (!mem->image)
 343             goto error_no_image;
 344         data = get_image_data(mem->image);
 345         break;
 346     default:
 347         goto error_unsupported_map_type;
 348     }
 349     mem->map_count++;
 350     return data;
 351
 352     /* ERRORS */
 353 error_unsupported_map:
 354     GST_ERROR("unsupported map flags (0x%x)", flags);
 355     return NULL;
 356 error_unsupported_map_type:
 357     GST_ERROR("unsupported map type (%d)", mem->map_type);
 358     return NULL;
 359 error_no_surface_proxy:
 360     GST_ERROR("failed to extract GstVaapiSurfaceProxy from video meta");
 361     return NULL;
 362 error_no_surface:
 363     GST_ERROR("failed to extract VA surface from video buffer");
 364     return NULL;
 365 error_no_image:
 366     GST_ERROR("failed to extract VA image from video buffer");
 367     return NULL;
 368 error_map_image:
 369     GST_ERROR("failed to map VA image");
 370     return NULL;
 371 }
 372
 373 static void
 374 gst_vaapi_video_memory_unmap(GstVaapiVideoMemory *mem)
 375 {
 376     if (mem->map_count == 1) {
 377         switch (mem->map_type) {
 378         case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_SURFACE:
 379             gst_vaapi_surface_proxy_replace(&mem->proxy, NULL);
 380             break;
 381         case GST_VAAPI_VIDEO_MEMORY_MAP_TYPE_LINEAR:
 382             gst_vaapi_image_unmap(mem->image);
 383             break;
 384         default:
 385             goto error_incompatible_map;
 386         }
 387         mem->map_type = 0;
 388     }
 389     mem->map_count--;
 390     return;
 391
 392     /* ERRORS */
 393 error_incompatible_map:
 394     GST_ERROR("incompatible map type (%d)", mem->map_type);
 395     return;
 396 }
 397
 398 static GstVaapiVideoMemory *
 399 gst_vaapi_video_memory_copy(GstVaapiVideoMemory *mem,
 400     gssize offset, gssize size)
 401 {
 402     GstMemory *out_mem;
 403
 404     if (offset != 0 || size != -1)
 405         goto error_unsupported;
 406
 407     out_mem = gst_vaapi_video_memory_new(mem->parent_instance.allocator,
 408         mem->meta);
 409     if (!out_mem)
 410         goto error_allocate_memory;
 411     return GST_VAAPI_VIDEO_MEMORY_CAST(out_mem);
 412
 413     /* ERRORS */
 414 error_unsupported:
 415     GST_ERROR("failed to copy partial memory (unsupported operation)");
 416     return NULL;
 417 error_allocate_memory:
 418     GST_ERROR("failed to allocate GstVaapiVideoMemory copy");
 419     return NULL;
 420 }
 421
 422 static GstVaapiVideoMemory *
 423 gst_vaapi_video_memory_share(GstVaapiVideoMemory *mem,
 424     gssize offset, gssize size)
 425 {
 426     GST_FIXME("unimplemented GstVaapiVideoAllocator::mem_share() hook");
 427     return NULL;
 428 }
 429
 430 static gboolean
 431 gst_vaapi_video_memory_is_span(GstVaapiVideoMemory *mem1,
 432     GstVaapiVideoMemory *mem2, gsize *offset_ptr)
 433 {
 434     GST_FIXME("unimplemented GstVaapiVideoAllocator::mem_is_span() hook");
 435     return FALSE;
 436 }
 437
 438 /* ------------------------------------------------------------------------ */
 439 /* --- GstVaapiVideoAllocator                                           --- */
 440 /* ------------------------------------------------------------------------ */
 441
 442 #define GST_VAAPI_VIDEO_ALLOCATOR_CLASS(klass)  \
 443     (G_TYPE_CHECK_CLASS_CAST((klass),           \
 444         GST_VAAPI_TYPE_VIDEO_ALLOCATOR,         \
 445         GstVaapiVideoAllocatorClass))
 446
 447 #define GST_VAAPI_IS_VIDEO_ALLOCATOR_CLASS(klass) \
 448     (G_TYPE_CHECK_CLASS_TYPE((klass), GST_VAAPI_TYPE_VIDEO_ALLOCATOR))
 449
 450 G_DEFINE_TYPE(GstVaapiVideoAllocator,
 451               gst_vaapi_video_allocator,
 452               GST_TYPE_ALLOCATOR)
 453
 454 static GstMemory *
 455 gst_vaapi_video_allocator_alloc(GstAllocator *allocator, gsize size,
 456     GstAllocationParams *params)
 457 {
 458     g_warning("use gst_vaapi_video_memory_new() to allocate from "
 459         "GstVaapiVideoMemory allocator");
 460
 461     return NULL;
 462 }
 463
 464 static void
 465 gst_vaapi_video_allocator_free(GstAllocator *allocator, GstMemory *mem)
 466 {
 467     gst_vaapi_video_memory_free(GST_VAAPI_VIDEO_MEMORY_CAST(mem));
 468 }
 469
 470 static void
 471 gst_vaapi_video_allocator_finalize(GObject *object)
 472 {
 473     GstVaapiVideoAllocator * const allocator =
 474         GST_VAAPI_VIDEO_ALLOCATOR_CAST(object);
 475
 476     gst_vaapi_video_pool_replace(&allocator->surface_pool, NULL);
 477
 478     G_OBJECT_CLASS(gst_vaapi_video_allocator_parent_class)->finalize(object);
 479 }
 480
 481 static void
 482 gst_vaapi_video_allocator_class_init(GstVaapiVideoAllocatorClass *klass)
 483 {
 484     GObjectClass * const object_class = G_OBJECT_CLASS(klass);
 485     GstAllocatorClass * const allocator_class = GST_ALLOCATOR_CLASS(klass);
 486
 487     GST_DEBUG_CATEGORY_INIT(gst_debug_vaapivideomemory,
 488         "vaapivideomemory", 0, "VA-API video memory allocator");
 489
 490     object_class->finalize      = gst_vaapi_video_allocator_finalize;
 491     allocator_class->alloc      = gst_vaapi_video_allocator_alloc;
 492     allocator_class->free       = gst_vaapi_video_allocator_free;
 493 }
 494
 495 static void
 496 gst_vaapi_video_allocator_init(GstVaapiVideoAllocator *allocator)
 497 {
 498     GstAllocator * const base_allocator = GST_ALLOCATOR_CAST(allocator);
 499
 500     base_allocator->mem_type = GST_VAAPI_VIDEO_MEMORY_NAME;
 501     base_allocator->mem_map = (GstMemoryMapFunction)
 502         gst_vaapi_video_memory_map;
 503     base_allocator->mem_unmap = (GstMemoryUnmapFunction)
 504         gst_vaapi_video_memory_unmap;
 505     base_allocator->mem_copy = (GstMemoryCopyFunction)
 506         gst_vaapi_video_memory_copy;
 507     base_allocator->mem_share = (GstMemoryShareFunction)
 508         gst_vaapi_video_memory_share;
 509     base_allocator->mem_is_span = (GstMemoryIsSpanFunction)
 510         gst_vaapi_video_memory_is_span;
 511 }
 512
 513 static gboolean
 514 gst_video_info_update_from_image(GstVideoInfo *vip, GstVaapiImage *image)
 515 {
 516     GstVideoFormat format;
 517     const guchar *data;
 518     guint i, num_planes, data_size, width, height;
 519
 520     /* Reset format from image */
 521     format = gst_vaapi_image_get_format(image);
 522     gst_vaapi_image_get_size(image, &width, &height);
 523     gst_video_info_set_format(vip, format, width, height);
 524
 525     num_planes = gst_vaapi_image_get_plane_count(image);
 526     g_return_val_if_fail(num_planes == GST_VIDEO_INFO_N_PLANES(vip), FALSE);
 527
 528     /* Determine the base data pointer */
 529     data = get_image_data(image);
 530     g_return_val_if_fail(data != NULL, FALSE);
 531     data_size = gst_vaapi_image_get_data_size(image);
 532
 533     /* Check that we don't have disjoint planes */
 534     for (i = 0; i < num_planes; i++) {
 535         const guchar * const plane = gst_vaapi_image_get_plane(image, i);
 536         if (plane - data > data_size)
 537             return FALSE;
 538     }
 539
 540     /* Update GstVideoInfo structure */
 541     for (i = 0; i < num_planes; i++) {
 542         const guchar * const plane = gst_vaapi_image_get_plane(image, i);
 543         GST_VIDEO_INFO_PLANE_OFFSET(vip, i) = plane - data;
 544         GST_VIDEO_INFO_PLANE_STRIDE(vip, i) =
 545             gst_vaapi_image_get_pitch(image, i);
 546     }
 547     GST_VIDEO_INFO_SIZE(vip) = data_size;
 548     return TRUE;
 549 }
 550
 551 GstAllocator *
 552 gst_vaapi_video_allocator_new(GstVaapiDisplay *display, const GstVideoInfo *vip)
 553 {
 554     GstVaapiVideoAllocator *allocator;
 555     GstVaapiSurface *surface;
 556     GstVaapiImage *image;
 557
 558     g_return_val_if_fail(display != NULL, NULL);
 559     g_return_val_if_fail(vip != NULL, NULL);
 560
 561     allocator = g_object_new(GST_VAAPI_TYPE_VIDEO_ALLOCATOR, NULL);
 562     if (!allocator)
 563         return NULL;
 564
 565     allocator->video_info = *vip;
 566     gst_video_info_set_format(&allocator->surface_info, GST_VIDEO_FORMAT_NV12,
 567         GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
 568
 569     if (GST_VIDEO_INFO_FORMAT(vip) != GST_VIDEO_FORMAT_ENCODED) {
 570         image = NULL;
 571         do {
 572             surface = new_surface(display, vip);
 573             if (!surface)
 574                 break;
 575             image = gst_vaapi_surface_derive_image(surface);
 576             if (!image)
 577                 break;
 578             if (!gst_vaapi_image_map(image))
 579                 break;
 580             allocator->has_direct_rendering = gst_video_info_update_from_image(
 581                 &allocator->surface_info, image);
 582             if (GST_VAAPI_IMAGE_FORMAT(image) != GST_VIDEO_INFO_FORMAT(vip))
 583                allocator->has_direct_rendering = FALSE;
 584             gst_vaapi_image_unmap(image);
 585             GST_INFO("has direct-rendering for %s surfaces: %s",
 586                      GST_VIDEO_INFO_FORMAT_STRING(&allocator->surface_info),
 587                      allocator->has_direct_rendering ? "yes" : "no");
 588         } while (0);
 589         if (surface)
 590             gst_vaapi_object_unref(surface);
 591         if (image)
 592             gst_vaapi_object_unref(image);
 593     }
 594
 595     allocator->surface_pool = gst_vaapi_surface_pool_new(display,
 596         &allocator->surface_info);
 597     if (!allocator->surface_pool)
 598         goto error_create_pool;
 599
 600     allocator->image_info = *vip;
 601     if (GST_VIDEO_INFO_FORMAT(vip) == GST_VIDEO_FORMAT_ENCODED)
 602         gst_video_info_set_format(&allocator->image_info, GST_VIDEO_FORMAT_I420,
 603             GST_VIDEO_INFO_WIDTH(vip), GST_VIDEO_INFO_HEIGHT(vip));
 604
 605     if (allocator->has_direct_rendering)
 606         allocator->image_info = allocator->surface_info;
 607     else {
 608         do {
 609             image = new_image(display, &allocator->image_info);
 610             if (!image)
 611                 break;
 612             if (!gst_vaapi_image_map(image))
 613                 break;
 614             gst_video_info_update_from_image(&allocator->image_info, image);
 615             gst_vaapi_image_unmap(image);
 616         } while (0);
 617         gst_vaapi_object_unref(image);
 618     }
 619     return GST_ALLOCATOR_CAST(allocator);
 620
 621     /* ERRORS */
 622 error_create_pool:
 623     {
 624         GST_ERROR("failed to allocate VA surface pool");
 625         gst_object_unref(allocator);
 626         return NULL;
 627     }
 628 }