/*
 *  gstvaapivideobufferpool.c - Gstreamer/VA video buffer pool
 *
 *  Copyright (C) 2013 Intel Corporation
 *    Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public License
 *  as published by the Free Software Foundation; either version 2.1
 *  of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA 02110-1301 USA
 */

#include "gstcompat.h"
#include "gstvaapivideobufferpool.h"
#include "gstvaapivideobuffer.h"
#include "gstvaapivideomemory.h"
#include "gstvaapipluginutil.h"
#if (GST_VAAPI_USE_GLX || GST_VAAPI_USE_EGL)
#include "gstvaapivideometa_texture.h"
#endif

GST_DEBUG_CATEGORY_STATIC (gst_debug_vaapivideopool);
#define GST_CAT_DEFAULT gst_debug_vaapivideopool

enum
{
  PROP_0,

  PROP_DISPLAY,
};

struct _GstVaapiVideoBufferPoolPrivate
{
  GstAllocator *allocator;
  GstVideoInfo vmeta_vinfo;
  GstVaapiDisplay *display;
  guint options;
  guint use_dmabuf_memory:1;
  guint forced_video_meta:1;
  /* Map between surface and GstMemory, only DMA */
  GHashTable *dma_mem_map;
};

G_DEFINE_TYPE_WITH_PRIVATE (GstVaapiVideoBufferPool,
    gst_vaapi_video_buffer_pool, GST_TYPE_BUFFER_POOL);

static void
gst_vaapi_video_buffer_pool_finalize (GObject * object)
{
  GstVaapiVideoBufferPoolPrivate *const priv =
      GST_VAAPI_VIDEO_BUFFER_POOL (object)->priv;

  gst_vaapi_display_replace (&priv->display, NULL);
  gst_clear_object (&priv->allocator);
  if (priv->dma_mem_map)
    g_hash_table_destroy (priv->dma_mem_map);

  G_OBJECT_CLASS (gst_vaapi_video_buffer_pool_parent_class)->finalize (object);
}

static void
gst_vaapi_video_buffer_pool_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstVaapiVideoBufferPoolPrivate *const priv =
      GST_VAAPI_VIDEO_BUFFER_POOL (object)->priv;

  switch (prop_id) {
    case PROP_DISPLAY:
      /* G_PARAM_CONSTRUCT_ONLY */
      priv->display = g_value_dup_object (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_vaapi_video_buffer_pool_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstVaapiVideoBufferPoolPrivate *const priv =
      GST_VAAPI_VIDEO_BUFFER_POOL (object)->priv;

  switch (prop_id) {
    case PROP_DISPLAY:
      g_value_set_pointer (value, priv->display);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
fill_video_alignment (GstVaapiVideoBufferPool * pool, GstVideoAlignment * align)
{
  GstVideoInfo *const vip = &pool->priv->vmeta_vinfo;
  guint i;
  gint nth_bit;

  gst_video_alignment_reset (align);
  for (i = 0; i < GST_VIDEO_INFO_N_PLANES (vip); i++) {
    nth_bit = g_bit_nth_lsf (GST_VIDEO_INFO_PLANE_STRIDE (vip, i), 0);
    if (nth_bit >= 0)
      align->stride_align[i] = (1U << nth_bit) - 1;
  }
}

static const gchar **
gst_vaapi_video_buffer_pool_get_options (GstBufferPool * pool)
{
  static const gchar *g_options[] = {
    GST_BUFFER_POOL_OPTION_VIDEO_META,
    GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META,
    GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META,
    GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT,
    NULL,
  };

  return g_options;
}

static gboolean
gst_vaapi_video_buffer_pool_set_config (GstBufferPool * pool,
    GstStructure * config)
{
  GstVaapiVideoBufferPool *const base_pool = GST_VAAPI_VIDEO_BUFFER_POOL (pool);
  GstVaapiVideoBufferPoolPrivate *const priv = base_pool->priv;
  GstCaps *caps;
  GstVideoInfo new_allocation_vinfo;
  const GstVideoInfo *allocator_vinfo;
  const GstVideoInfo *negotiated_vinfo;
  GstVideoAlignment align;
  GstAllocator *allocator;
  gboolean ret;
  guint size, min_buffers, max_buffers;
  guint surface_alloc_flags;

  GST_DEBUG_OBJECT (base_pool, "config %" GST_PTR_FORMAT, config);

  caps = NULL;
  if (!gst_buffer_pool_config_get_params (config, &caps, &size, &min_buffers,
          &max_buffers))
    goto error_invalid_config;
  if (!caps)
    goto error_no_caps;
  if (!gst_video_info_from_caps (&new_allocation_vinfo, caps))
    goto error_invalid_caps;

  if (!gst_buffer_pool_config_has_option (config,
          GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META))
    goto error_no_vaapi_video_meta_option;

  allocator = NULL;
  if (!gst_buffer_pool_config_get_allocator (config, &allocator, NULL))
    goto error_invalid_allocator;

  /* it is a valid allocator? */
  if (allocator
      && (g_strcmp0 (allocator->mem_type, GST_VAAPI_VIDEO_MEMORY_NAME) != 0
          && g_strcmp0 (allocator->mem_type,
              GST_VAAPI_DMABUF_ALLOCATOR_NAME) != 0))
    goto error_invalid_allocator;

  /* get the allocator properties */
  if (allocator) {
    priv->use_dmabuf_memory = gst_vaapi_is_dmabuf_allocator (allocator);
    negotiated_vinfo =
        gst_allocator_get_vaapi_negotiated_video_info (allocator);
    allocator_vinfo =
        gst_allocator_get_vaapi_video_info (allocator, &surface_alloc_flags);
  } else {
    priv->use_dmabuf_memory = FALSE;
    negotiated_vinfo = NULL;
    allocator_vinfo = NULL;
    surface_alloc_flags = 0;
  }

  /* reset or update the allocator if video resolution changed */
  if (allocator_vinfo
      && gst_video_info_changed (allocator_vinfo, &new_allocation_vinfo)) {
    gst_object_replace ((GstObject **) & priv->allocator, NULL);

    /* dmabuf allocator can change its parameters: no need to create a
     * new one */
    if (priv->use_dmabuf_memory) {
      gst_allocator_set_vaapi_video_info (allocator, &new_allocation_vinfo,
          surface_alloc_flags);
    } else {
      allocator = NULL;
    }
  }

  /* create a new allocator if needed */
  if (!allocator) {
    /* if no allocator set, let's create a VAAPI one */
    allocator = gst_vaapi_video_allocator_new (priv->display,
        &new_allocation_vinfo, surface_alloc_flags, 0);
    if (!allocator)
      goto error_no_allocator;

    if (negotiated_vinfo) {
      gst_allocator_set_vaapi_negotiated_video_info (allocator,
          negotiated_vinfo);
    }

    GST_INFO_OBJECT (base_pool, "created new allocator %" GST_PTR_FORMAT,
        allocator);
    gst_buffer_pool_config_set_allocator (config, allocator, NULL);
    gst_object_unref (allocator);
  }

  /* use the allocator and set the video info for the vmeta */
  if (allocator) {
    if (priv->allocator)
      gst_object_unref (priv->allocator);
    if ((priv->allocator = allocator))
      gst_object_ref (allocator);

    negotiated_vinfo =
        gst_allocator_get_vaapi_negotiated_video_info (priv->allocator);
    allocator_vinfo = gst_allocator_get_vaapi_video_info (allocator, NULL);
    priv->vmeta_vinfo = (negotiated_vinfo) ?
        *negotiated_vinfo : *allocator_vinfo;

    /* last resource to set the correct buffer size */
    if (GST_VIDEO_INFO_SIZE (allocator_vinfo) != size) {
      gst_buffer_pool_config_set_params (config, caps,
          GST_VIDEO_INFO_SIZE (allocator_vinfo), min_buffers, max_buffers);
    }
  }
  if (!priv->allocator)
    goto error_no_allocator;

  priv->options = 0;
  if (gst_buffer_pool_config_has_option (config,
          GST_BUFFER_POOL_OPTION_VIDEO_META)) {
    priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META;
  } else if (gst_caps_is_video_raw (caps) && !priv->use_dmabuf_memory) {
    gint i;

    for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&new_allocation_vinfo); i++) {
      if (GST_VIDEO_INFO_PLANE_OFFSET (&new_allocation_vinfo, i) !=
          GST_VIDEO_INFO_PLANE_OFFSET (&priv->vmeta_vinfo, i) ||
          GST_VIDEO_INFO_PLANE_STRIDE (&new_allocation_vinfo, i) !=
          GST_VIDEO_INFO_PLANE_STRIDE (&priv->vmeta_vinfo, i) ||
          GST_VIDEO_INFO_SIZE (&new_allocation_vinfo) !=
          GST_VIDEO_INFO_SIZE (&priv->vmeta_vinfo)) {
        priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META;
        priv->forced_video_meta = TRUE;
        GST_INFO_OBJECT (base_pool, "adding unrequested video meta");
        break;
      }
    }
  }

  if (gst_buffer_pool_config_has_option (config,
          GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT)) {
    fill_video_alignment (GST_VAAPI_VIDEO_BUFFER_POOL (pool), &align);
    gst_buffer_pool_config_set_video_alignment (config, &align);
  }

  if (!priv->use_dmabuf_memory && gst_buffer_pool_config_has_option (config,
          GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META))
    priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD;

  ret =
      GST_BUFFER_POOL_CLASS
      (gst_vaapi_video_buffer_pool_parent_class)->set_config (pool, config);
  return ret;

  /* ERRORS */
error_invalid_config:
  {
    GST_WARNING_OBJECT (base_pool, "invalid config");
    return FALSE;
  }
error_no_caps:
  {
    GST_WARNING_OBJECT (base_pool, "no caps in config");
    return FALSE;
  }
error_invalid_caps:
  {
    GST_WARNING_OBJECT (base_pool, "invalid caps %" GST_PTR_FORMAT, caps);
    return FALSE;
  }
error_invalid_allocator:
  {
    GST_INFO_OBJECT (base_pool, "no allocator in config");
    return FALSE;
  }
error_no_vaapi_video_meta_option:
  {
    GST_WARNING_OBJECT (base_pool, "no GstVaapiVideoMeta option in config");
    return FALSE;
  }
error_no_allocator:
  {
    GST_WARNING_OBJECT (base_pool, "no allocator defined");
    return FALSE;
  }
}

static void
vaapi_buffer_pool_cache_dma_mem (GstVaapiVideoBufferPool * pool,
    GstVaapiSurfaceProxy * proxy, GstMemory * mem)
{
  GstVaapiVideoBufferPoolPrivate *const priv = pool->priv;
  GstVaapiSurface *surface;

  surface = GST_VAAPI_SURFACE_PROXY_SURFACE (proxy);
  g_assert (surface);
  g_assert (gst_vaapi_surface_peek_buffer_proxy (surface));

  if (!priv->dma_mem_map)
    priv->dma_mem_map = g_hash_table_new_full (g_direct_hash,
        g_direct_equal, NULL, (GDestroyNotify) gst_memory_unref);

  if (!g_hash_table_contains (priv->dma_mem_map, surface)) {
    g_hash_table_insert (priv->dma_mem_map, surface, gst_memory_ref (mem));
  } else {
    g_assert (g_hash_table_lookup (priv->dma_mem_map, surface) == mem);
  }
}

static GstMemory *
vaapi_buffer_pool_lookup_dma_mem (GstVaapiVideoBufferPool * pool,
    GstVaapiSurfaceProxy * proxy)
{
  GstVaapiSurface *surface;
  GstVaapiVideoBufferPoolPrivate *const priv = pool->priv;
  GstVaapiBufferProxy *buf_proxy;
  GstMemory *mem;

  g_assert (priv->use_dmabuf_memory);

  if (!priv->dma_mem_map)
    return NULL;

  surface = GST_VAAPI_SURFACE_PROXY_SURFACE (proxy);
  g_assert (surface);

  buf_proxy = gst_vaapi_surface_peek_buffer_proxy (surface);
  /* Have not exported yet */
  if (!buf_proxy) {
    g_assert (!g_hash_table_contains (priv->dma_mem_map, surface));
    return NULL;
  }

  mem = g_hash_table_lookup (priv->dma_mem_map, surface);
  g_assert (mem);

  return gst_memory_ref (mem);
}

static GstFlowReturn
gst_vaapi_video_buffer_pool_alloc_buffer (GstBufferPool * pool,
    GstBuffer ** out_buffer_ptr, GstBufferPoolAcquireParams * params)
{
  GstVaapiVideoBufferPool *const base_pool = GST_VAAPI_VIDEO_BUFFER_POOL (pool);
  GstVaapiVideoBufferPoolPrivate *const priv = base_pool->priv;
  GstVaapiVideoBufferPoolAcquireParams *const priv_params =
      (GstVaapiVideoBufferPoolAcquireParams *) params;
  GstVaapiVideoMeta *meta;
  GstMemory *mem;
  GstBuffer *buffer;

  if (!priv->allocator)
    goto error_no_allocator;

  meta = gst_vaapi_video_meta_new (priv->display);
  if (!meta)
    goto error_create_meta;

  buffer = gst_vaapi_video_buffer_new (meta);

  if (!buffer)
    goto error_create_buffer;

  if (priv_params && priv_params->proxy)
    gst_vaapi_video_meta_set_surface_proxy (meta, priv_params->proxy);

  if (priv->use_dmabuf_memory) {
    mem = NULL;
    if (priv_params && priv_params->proxy) {
      mem = vaapi_buffer_pool_lookup_dma_mem (base_pool, priv_params->proxy);
      if (!mem) {
        mem = gst_vaapi_dmabuf_memory_new (priv->allocator, meta);
        if (!mem)
          goto error_create_memory;

        vaapi_buffer_pool_cache_dma_mem (base_pool, priv_params->proxy, mem);
      }
    } else {
      mem = gst_vaapi_dmabuf_memory_new (priv->allocator, meta);
    }
  } else {
    mem = gst_vaapi_video_memory_new (priv->allocator, meta);
  }
  if (!mem)
    goto error_create_memory;
  gst_vaapi_video_meta_replace (&meta, NULL);
  gst_buffer_append_memory (buffer, mem);

  if (priv->options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META) {
    GstVideoInfo *const vip = &priv->vmeta_vinfo;
    GstVideoMeta *vmeta;

    vmeta = gst_buffer_add_video_meta_full (buffer, 0,
        GST_VIDEO_INFO_FORMAT (vip), GST_VIDEO_INFO_WIDTH (vip),
        GST_VIDEO_INFO_HEIGHT (vip), GST_VIDEO_INFO_N_PLANES (vip),
        &GST_VIDEO_INFO_PLANE_OFFSET (vip, 0),
        &GST_VIDEO_INFO_PLANE_STRIDE (vip, 0));

    if (GST_VAAPI_IS_VIDEO_MEMORY (mem)) {
      vmeta->map = gst_video_meta_map_vaapi_memory;
      vmeta->unmap = gst_video_meta_unmap_vaapi_memory;
    }

    GST_META_FLAG_SET (vmeta, GST_META_FLAG_POOLED);
  }
#if (GST_VAAPI_USE_GLX || GST_VAAPI_USE_EGL)
  if (priv->options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD) {
    GstMeta *tex_meta = gst_buffer_add_texture_upload_meta (buffer);
    if (tex_meta)
      GST_META_FLAG_SET (tex_meta, GST_META_FLAG_POOLED);
  }
#endif

  *out_buffer_ptr = buffer;
  return GST_FLOW_OK;

  /* ERRORS */
error_no_allocator:
  {
    GST_ERROR_OBJECT (base_pool, "no GstAllocator in buffer pool");
    return GST_FLOW_ERROR;
  }
error_create_meta:
  {
    GST_ERROR_OBJECT (base_pool, "failed to allocate vaapi video meta");
    return GST_FLOW_ERROR;
  }
error_create_buffer:
  {
    GST_ERROR_OBJECT (base_pool, "failed to create video buffer");
    gst_vaapi_video_meta_unref (meta);
    return GST_FLOW_ERROR;
  }
error_create_memory:
  {
    GST_ERROR_OBJECT (base_pool, "failed to create video memory");
    gst_buffer_unref (buffer);
    gst_vaapi_video_meta_unref (meta);
    return GST_FLOW_ERROR;
  }
}

static GstFlowReturn
gst_vaapi_video_buffer_pool_acquire_buffer (GstBufferPool * pool,
    GstBuffer ** out_buffer_ptr, GstBufferPoolAcquireParams * params)
{
  GstVaapiVideoBufferPool *const base_pool = GST_VAAPI_VIDEO_BUFFER_POOL (pool);
  GstVaapiVideoBufferPoolPrivate *const priv = base_pool->priv;
  GstVaapiVideoBufferPoolAcquireParams *const priv_params =
      (GstVaapiVideoBufferPoolAcquireParams *) params;
  GstFlowReturn ret;
  GstBuffer *buffer;
  GstMemory *mem;
  GstVaapiVideoMeta *meta;
  GstVaapiSurface *surface;

  ret =
      GST_BUFFER_POOL_CLASS
      (gst_vaapi_video_buffer_pool_parent_class)->acquire_buffer (pool, &buffer,
      params);

  if (!priv->use_dmabuf_memory || !params || !priv_params->proxy
      || ret != GST_FLOW_OK) {
    *out_buffer_ptr = buffer;
    return ret;
  }

  /* Some pool users, such as decode, needs to acquire a buffer for a
   * specified surface (via surface proxy). If not it is a DMABuf, we
   * just replace the underlying surface proxy of buffer's
   * GstVaapiVideoMeta. But in DMABuf case, the thing is a little bit
   * more complicated:
   *
   * For DMABuf, GstMemory is-a GstFdMemory, which doesn't provide a
   * way to change its FD, thus once created it's bound to a
   * surface. On the other side, for performace reason, when the
   * buffer is released, the buffer and its memory are cached in the
   * buffer pool, and at next acquire_buffer() may still reuse a
   * buffer and its memory. But the pushed surface by the decoder may
   * be different from the one popped by the pool, so we need to
   * replace the buffer's memory with the correct one. */
  g_assert (gst_buffer_n_memory (buffer) == 1);

  /* Update the underlying surface proxy */
  meta = gst_buffer_get_vaapi_video_meta (buffer);
  if (!meta) {
    *out_buffer_ptr = buffer;
    return GST_FLOW_ERROR;
  }
  gst_vaapi_video_meta_set_surface_proxy (meta, priv_params->proxy);

  mem = vaapi_buffer_pool_lookup_dma_mem (base_pool, priv_params->proxy);
  if (mem) {
    if (mem == gst_buffer_peek_memory (buffer, 0)) {
      gst_memory_unref (mem);
      *out_buffer_ptr = buffer;
      return GST_FLOW_OK;
    }
  } else {
    /* Should be an unexported surface */
    surface = GST_VAAPI_SURFACE_PROXY_SURFACE (priv_params->proxy);
    g_assert (surface);
    g_assert (gst_vaapi_surface_peek_buffer_proxy (surface) == NULL);
    gst_vaapi_video_meta_set_surface_proxy (meta, priv_params->proxy);
    mem = gst_vaapi_dmabuf_memory_new (priv->allocator, meta);
    if (mem)
      vaapi_buffer_pool_cache_dma_mem (base_pool, priv_params->proxy, mem);
  }

  if (mem) {
    gst_buffer_replace_memory (buffer, 0, mem);
    gst_buffer_unset_flags (buffer, GST_BUFFER_FLAG_TAG_MEMORY);
    *out_buffer_ptr = buffer;
    return GST_FLOW_OK;
  } else {
    gst_buffer_unref (buffer);
    *out_buffer_ptr = NULL;
    return GST_FLOW_ERROR;
  }
}

static void
gst_vaapi_video_buffer_pool_reset_buffer (GstBufferPool * pool,
    GstBuffer * buffer)
{
  GstMemory *const mem = gst_buffer_peek_memory (buffer, 0);
  GstVaapiVideoMeta *meta;

  /* Release the underlying surface proxy */
  if (GST_VAAPI_IS_VIDEO_MEMORY (mem)) {
    gst_vaapi_video_memory_reset_surface (GST_VAAPI_VIDEO_MEMORY_CAST (mem));
  } else if (!gst_vaapi_dmabuf_memory_holds_surface (mem)) {
    /* If mem holds an internally created surface, don't reset it!
     * While surface is passed, we should clear it to avoid wrong
     * reference. */
    meta = gst_buffer_get_vaapi_video_meta (buffer);
    g_assert (meta);
    gst_vaapi_video_meta_set_surface_proxy (meta, NULL);
  }

  GST_BUFFER_POOL_CLASS (gst_vaapi_video_buffer_pool_parent_class)->reset_buffer
      (pool, buffer);
}

static void
gst_vaapi_video_buffer_pool_class_init (GstVaapiVideoBufferPoolClass * klass)
{
  GObjectClass *const object_class = G_OBJECT_CLASS (klass);
  GstBufferPoolClass *const pool_class = GST_BUFFER_POOL_CLASS (klass);

  GST_DEBUG_CATEGORY_INIT (gst_debug_vaapivideopool,
      "vaapivideopool", 0, "VA-API video pool");

  object_class->finalize = gst_vaapi_video_buffer_pool_finalize;
  object_class->set_property = gst_vaapi_video_buffer_pool_set_property;
  object_class->get_property = gst_vaapi_video_buffer_pool_get_property;
  pool_class->get_options = gst_vaapi_video_buffer_pool_get_options;
  pool_class->set_config = gst_vaapi_video_buffer_pool_set_config;
  pool_class->alloc_buffer = gst_vaapi_video_buffer_pool_alloc_buffer;
  pool_class->acquire_buffer = gst_vaapi_video_buffer_pool_acquire_buffer;
  pool_class->reset_buffer = gst_vaapi_video_buffer_pool_reset_buffer;

  /**
   * GstVaapiVideoBufferPool:display:
   *
   * The #GstVaapiDisplay this object is bound to.
   */
  g_object_class_install_property
      (object_class,
      PROP_DISPLAY,
      g_param_spec_object ("display", "Display",
          "The GstVaapiDisplay to use for this video pool",
          GST_TYPE_VAAPI_DISPLAY, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
}

static void
gst_vaapi_video_buffer_pool_init (GstVaapiVideoBufferPool * pool)
{
  pool->priv = gst_vaapi_video_buffer_pool_get_instance_private (pool);
  pool->priv->dma_mem_map = NULL;
}

GstBufferPool *
gst_vaapi_video_buffer_pool_new (GstVaapiDisplay * display)
{
  return g_object_new (GST_VAAPI_TYPE_VIDEO_BUFFER_POOL,
      "display", display, NULL);
}

/**
 * gst_vaapi_video_buffer_pool_copy_buffer:
 * @pool: a #GstVaapiVideoBufferPool
 *
 * Returns if the @pool force set of #GstVideoMeta. If so, the element
 * should copy the generated buffer by the pool to a system allocated
 * buffer. Otherwise, downstream could not display correctly the
 * frame.
 *
 * Returns: %TRUE if #GstVideoMeta is forced.
 **/
gboolean
gst_vaapi_video_buffer_pool_copy_buffer (GstBufferPool * pool)
{
  GstVaapiVideoBufferPool *va_pool = (GstVaapiVideoBufferPool *) pool;

  g_return_val_if_fail (GST_VAAPI_IS_VIDEO_BUFFER_POOL (pool), FALSE);

  return va_pool->priv->forced_video_meta;
}
