subprojects/gst-plugins-bad/sys/va/gstvacompositor.c

   1 /* GStreamer
   2  * Copyright (C) 2022 Intel Corporation
   3  *     Author: U. Artie Eoff <ullysses.a.eoff@intel.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 the0
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-vacompositor
  23  * @title: vacompositor
  24  * @short_description: A VA-API based video compositing element
  25  *
  26  * A video compositing element that uses VA-API VPP to accelerate the compose,
  27  * blending, and scaling of multiple inputs into one output.
  28  *
  29  * ## Example launch line
  30  * ```
  31  *  gst-launch-1.0 videotestsrc                                 \
  32  *    ! "video/x-raw,format=(string)NV12,width=640,height=480"  \
  33  *    ! tee name=testsrc ! queue ! vacompositor name=comp       \
  34  *      sink_1::width=160 sink_1::height=120 sink_1::xpos=480   \
  35  *      sink_1::ypos=360 sink_1::alpha=0.75                     \
  36  *    ! autovideosink testsrc. ! queue ! comp.
  37  * ```
  38  *
  39  * Since: 1.22
  40  *
  41  */
  42
  43 #ifdef HAVE_CONFIG_H
  44 #include "config.h"
  45 #endif
  46
  47 #include "gstvacompositor.h"
  48
  49 #include <gst/va/gstva.h>
  50 #include <gst/video/video.h>
  51 #include <va/va_drmcommon.h>
  52
  53 #include "gstvacaps.h"
  54 #include "gstvadisplay_priv.h"
  55 #include "gstvafilter.h"
  56
  57 GST_DEBUG_CATEGORY_STATIC (gst_va_compositor_debug);
  58 #define GST_CAT_DEFAULT gst_va_compositor_debug
  59
  60 struct _GstVaCompositorPad
  61 {
  62   GstVideoAggregatorPad parent;
  63
  64   GstBufferPool *pool;
  65
  66   gint xpos;
  67   gint ypos;
  68   gint width;
  69   gint height;
  70   gdouble alpha;
  71 };
  72
  73 enum
  74 {
  75   PROP_PAD_0,
  76   PROP_PAD_XPOS,
  77   PROP_PAD_YPOS,
  78   PROP_PAD_WIDTH,
  79   PROP_PAD_HEIGHT,
  80   PROP_PAD_ALPHA,
  81 };
  82
  83 #define DEFAULT_PAD_XPOS    0
  84 #define DEFAULT_PAD_YPOS    0
  85 #define DEFAULT_PAD_WIDTH   0
  86 #define DEFAULT_PAD_HEIGHT  0
  87 #define DEFAULT_PAD_ALPHA   1.0
  88
  89 G_DEFINE_TYPE (GstVaCompositorPad, gst_va_compositor_pad,
  90     GST_TYPE_VIDEO_AGGREGATOR_PAD);
  91
  92 static void
  93 gst_va_compositor_pad_get_property (GObject * object, guint prop_id,
  94     GValue * value, GParamSpec * pspec)
  95 {
  96   GstVaCompositorPad *self = GST_VA_COMPOSITOR_PAD (object);
  97
  98   switch (prop_id) {
  99     case PROP_PAD_XPOS:
 100       g_value_set_int (value, self->xpos);
 101       break;
 102     case PROP_PAD_YPOS:
 103       g_value_set_int (value, self->ypos);
 104       break;
 105     case PROP_PAD_WIDTH:
 106       g_value_set_int (value, self->width);
 107       break;
 108     case PROP_PAD_HEIGHT:
 109       g_value_set_int (value, self->height);
 110       break;
 111     case PROP_PAD_ALPHA:
 112       g_value_set_double (value, self->alpha);
 113       break;
 114     default:
 115       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 116       break;
 117   }
 118 }
 119
 120 static void
 121 gst_va_compositor_pad_set_property (GObject * object, guint prop_id,
 122     const GValue * value, GParamSpec * pspec)
 123 {
 124   GstVaCompositorPad *self = GST_VA_COMPOSITOR_PAD (object);
 125
 126   GST_OBJECT_LOCK (object);
 127   switch (prop_id) {
 128     case PROP_PAD_XPOS:
 129       self->xpos = g_value_get_int (value);
 130       break;
 131     case PROP_PAD_YPOS:
 132       self->ypos = g_value_get_int (value);
 133       break;
 134     case PROP_PAD_WIDTH:
 135       self->width = g_value_get_int (value);
 136       break;
 137     case PROP_PAD_HEIGHT:
 138       self->height = g_value_get_int (value);
 139       break;
 140     case PROP_PAD_ALPHA:
 141       self->alpha = g_value_get_double (value);
 142       break;
 143     default:
 144       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 145       break;
 146   }
 147   GST_OBJECT_UNLOCK (object);
 148 }
 149
 150 static void
 151 gst_va_compositor_pad_finalize (GObject * object)
 152 {
 153   GstVaCompositorPad *self = GST_VA_COMPOSITOR_PAD (object);
 154
 155   if (self->pool) {
 156     gst_buffer_pool_set_active (self->pool, FALSE);
 157     gst_clear_object (&self->pool);
 158   }
 159
 160   G_OBJECT_CLASS (gst_va_compositor_pad_parent_class)->finalize (object);
 161 }
 162
 163 static void
 164 gst_va_compositor_pad_init (GstVaCompositorPad * self)
 165 {
 166   self->pool = NULL;
 167   self->xpos = DEFAULT_PAD_XPOS;
 168   self->ypos = DEFAULT_PAD_YPOS;
 169   self->width = DEFAULT_PAD_WIDTH;
 170   self->height = DEFAULT_PAD_HEIGHT;
 171   self->alpha = DEFAULT_PAD_ALPHA;
 172 }
 173
 174 static void
 175 gst_va_compositor_pad_class_init (GstVaCompositorPadClass * klass)
 176 {
 177   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 178   GstVideoAggregatorPadClass *vaggpad_class =
 179       GST_VIDEO_AGGREGATOR_PAD_CLASS (klass);
 180
 181   gobject_class->finalize = gst_va_compositor_pad_finalize;
 182   gobject_class->get_property = gst_va_compositor_pad_get_property;
 183   gobject_class->set_property = gst_va_compositor_pad_set_property;
 184
 185   g_object_class_install_property (gobject_class, PROP_PAD_XPOS,
 186       g_param_spec_int ("xpos", "X Position", "X Position of the picture",
 187           G_MININT, G_MAXINT, DEFAULT_PAD_XPOS,
 188           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 189   g_object_class_install_property (gobject_class, PROP_PAD_YPOS,
 190       g_param_spec_int ("ypos", "Y Position", "Y Position of the picture",
 191           G_MININT, G_MAXINT, DEFAULT_PAD_YPOS,
 192           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 193   g_object_class_install_property (gobject_class, PROP_PAD_WIDTH,
 194       g_param_spec_int ("width", "Width",
 195           "Width of the picture (0, to use the width of the input frame)",
 196           0, G_MAXINT, DEFAULT_PAD_WIDTH,
 197           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 198   g_object_class_install_property (gobject_class, PROP_PAD_HEIGHT,
 199       g_param_spec_int ("height", "Height",
 200           "Height of the picture (0, to use the height of the input frame)",
 201           0, G_MAXINT, DEFAULT_PAD_HEIGHT,
 202           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 203   g_object_class_install_property (gobject_class, PROP_PAD_ALPHA,
 204       g_param_spec_double ("alpha", "Alpha", "Alpha of the picture", 0.0, 1.0,
 205           DEFAULT_PAD_ALPHA,
 206           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 207
 208   /* Don't use mapped video frames.  Handle video buffers directly */
 209   vaggpad_class->prepare_frame = NULL;
 210   vaggpad_class->clean_frame = NULL;
 211 }
 212
 213 #define GST_VA_COMPOSITOR(obj) ((GstVaCompositor *) obj)
 214 #define GST_VA_COMPOSITOR_CLASS(klass) ((GstVaCompositorClass *) klass)
 215 #define GST_VA_COMPOSITOR_GET_CLASS(obj) \
 216     (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_FROM_INSTANCE (obj), GstVaCompositorClass))
 217
 218 typedef struct _GstVaCompositor GstVaCompositor;
 219 typedef struct _GstVaCompositorClass GstVaCompositorClass;
 220
 221 struct _GstVaCompositorClass
 222 {
 223   GstVideoAggregatorClass parent_class;
 224
 225   /*< private > */
 226   gchar *render_device_path;
 227 };
 228
 229 struct _GstVaCompositor
 230 {
 231   GstVideoAggregator parent;
 232
 233   GstVaDisplay *display;
 234   GstVaFilter *filter;
 235
 236   GstVideoInfo other_info;      /* downstream info */
 237   GstBufferPool *other_pool;    /* downstream pool */
 238
 239   guint32 scale_method;
 240 };
 241
 242 struct CData
 243 {
 244   gchar *render_device_path;
 245   gchar *description;
 246 };
 247
 248 enum
 249 {
 250   PROP_DEVICE_PATH = 1,
 251   PROP_SCALE_METHOD,
 252   N_PROPERTIES
 253 };
 254
 255 static GParamSpec *properties[N_PROPERTIES];
 256 static GstElementClass *parent_class = NULL;
 257
 258 static void
 259 gst_va_compositor_set_property (GObject * object, guint prop_id,
 260     const GValue * value, GParamSpec * pspec)
 261 {
 262   GstVaCompositor *self = GST_VA_COMPOSITOR (object);
 263
 264   switch (prop_id) {
 265     case PROP_SCALE_METHOD:
 266     {
 267       GST_OBJECT_LOCK (object);
 268       self->scale_method = g_value_get_enum (value);
 269       GST_OBJECT_UNLOCK (object);
 270       break;
 271     }
 272     default:
 273       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 274   }
 275 }
 276
 277 static void
 278 gst_va_compositor_get_property (GObject * object, guint prop_id,
 279     GValue * value, GParamSpec * pspec)
 280 {
 281   GstVaCompositor *self = GST_VA_COMPOSITOR (object);
 282
 283   switch (prop_id) {
 284     case PROP_DEVICE_PATH:
 285     {
 286       if (!(self->display && GST_IS_VA_DISPLAY_DRM (self->display))) {
 287         g_value_set_string (value, NULL);
 288         return;
 289       }
 290       g_object_get_property (G_OBJECT (self->display), "path", value);
 291       break;
 292     }
 293     case PROP_SCALE_METHOD:
 294     {
 295       GST_OBJECT_LOCK (object);
 296       g_value_set_enum (value, self->scale_method);
 297       GST_OBJECT_UNLOCK (object);
 298       break;
 299     }
 300     default:
 301       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 302   }
 303 }
 304
 305 static gboolean
 306 gst_va_compositor_start (GstAggregator * agg)
 307 {
 308   GstElement *element = GST_ELEMENT (agg);
 309   GstVaCompositor *self = GST_VA_COMPOSITOR (agg);
 310   GstVaCompositorClass *klass = GST_VA_COMPOSITOR_GET_CLASS (agg);
 311
 312   if (!gst_va_ensure_element_data (element, klass->render_device_path,
 313           &self->display))
 314     return FALSE;
 315   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DEVICE_PATH]);
 316
 317   self->filter = gst_va_filter_new (self->display);
 318   if (!gst_va_filter_open (self->filter))
 319     return FALSE;
 320
 321   return GST_AGGREGATOR_CLASS (parent_class)->start (agg);
 322 }
 323
 324 static gboolean
 325 gst_va_compositor_stop (GstAggregator * agg)
 326 {
 327   GstVaCompositor *self = GST_VA_COMPOSITOR (agg);
 328
 329   gst_va_filter_close (self->filter);
 330   gst_clear_object (&self->filter);
 331   gst_clear_object (&self->display);
 332   g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DEVICE_PATH]);
 333
 334   return GST_AGGREGATOR_CLASS (parent_class)->stop (agg);
 335 }
 336
 337 static void
 338 gst_va_compositor_dispose (GObject * object)
 339 {
 340   GstVaCompositor *self = GST_VA_COMPOSITOR (object);
 341
 342   if (self->other_pool) {
 343     gst_buffer_pool_set_active (self->other_pool, FALSE);
 344     gst_clear_object (&self->other_pool);
 345   }
 346
 347   gst_clear_object (&self->display);
 348
 349   G_OBJECT_CLASS (parent_class)->dispose (object);
 350 }
 351
 352 static GstPad *
 353 gst_va_compositor_request_new_pad (GstElement * element, GstPadTemplate * templ,
 354     const gchar * req_name, const GstCaps * caps)
 355 {
 356   GstPad *newpad = GST_PAD (GST_ELEMENT_CLASS
 357       (parent_class)->request_new_pad (element, templ, req_name, caps));
 358
 359   if (!newpad)
 360     GST_DEBUG_OBJECT (element, "could not create/add pad");
 361   else
 362     gst_child_proxy_child_added (GST_CHILD_PROXY (element), G_OBJECT (newpad),
 363         GST_OBJECT_NAME (newpad));
 364
 365   return newpad;
 366 }
 367
 368 static void
 369 gst_va_compositor_release_pad (GstElement * element, GstPad * pad)
 370 {
 371   GstVaCompositor *self = GST_VA_COMPOSITOR (element);
 372
 373   gst_child_proxy_child_removed (GST_CHILD_PROXY (self), G_OBJECT (pad),
 374       GST_OBJECT_NAME (pad));
 375
 376   GST_ELEMENT_CLASS (parent_class)->release_pad (element, pad);
 377 }
 378
 379 static void
 380 gst_va_compositor_set_context (GstElement * element, GstContext * context)
 381 {
 382   GstVaDisplay *old_display, *new_display;
 383   GstVaCompositor *self = GST_VA_COMPOSITOR (element);
 384   GstVaCompositorClass *klass = GST_VA_COMPOSITOR_GET_CLASS (self);
 385   gboolean ret;
 386
 387   old_display = self->display ? gst_object_ref (self->display) : NULL;
 388   ret = gst_va_handle_set_context (element, context, klass->render_device_path,
 389       &self->display);
 390   new_display = self->display ? gst_object_ref (self->display) : NULL;
 391
 392   if (!ret
 393       || (old_display && new_display && old_display != new_display
 394           && self->filter)) {
 395     GST_ELEMENT_WARNING (element, RESOURCE, BUSY,
 396         ("Can't replace VA display while operating"), (NULL));
 397   }
 398
 399   gst_clear_object (&old_display);
 400   gst_clear_object (&new_display);
 401
 402   GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
 403 }
 404
 405 static gboolean
 406 _handle_context_query (GstVaCompositor * self, GstQuery * query)
 407 {
 408   GstVaDisplay *display = NULL;
 409   gboolean ret = FALSE;
 410
 411   gst_object_replace ((GstObject **) & display, (GstObject *) self->display);
 412   ret = gst_va_handle_context_query (GST_ELEMENT_CAST (self), query, display);
 413   gst_clear_object (&display);
 414
 415   return ret;
 416 }
 417
 418 static GstCaps *
 419 gst_va_compositor_sink_getcaps (GstPad * pad, GstCaps * filter)
 420 {
 421   GstCaps *sinkcaps;
 422   GstCaps *template_caps;
 423   GstCaps *filtered_caps;
 424   GstCaps *returned_caps;
 425
 426   template_caps = gst_pad_get_pad_template_caps (pad);
 427
 428   sinkcaps = gst_pad_get_current_caps (pad);
 429   if (!sinkcaps) {
 430     sinkcaps = gst_caps_ref (template_caps);
 431   } else {
 432     sinkcaps = gst_caps_merge (sinkcaps, gst_caps_ref (template_caps));
 433   }
 434
 435   if (filter) {
 436     filtered_caps = gst_caps_intersect (sinkcaps, filter);
 437     gst_caps_unref (sinkcaps);
 438   } else {
 439     filtered_caps = sinkcaps;
 440   }
 441
 442   returned_caps = gst_caps_intersect (filtered_caps, template_caps);
 443
 444   gst_caps_unref (template_caps);
 445   gst_caps_unref (filtered_caps);
 446
 447   GST_DEBUG_OBJECT (pad, "returning %" GST_PTR_FORMAT, returned_caps);
 448
 449   return returned_caps;
 450 }
 451
 452 static gboolean
 453 gst_va_compositor_sink_acceptcaps (GstPad * pad, GstCaps * caps)
 454 {
 455   gboolean ret;
 456   GstCaps *template_caps;
 457
 458   template_caps = gst_pad_get_pad_template_caps (pad);
 459   template_caps = gst_caps_make_writable (template_caps);
 460
 461   ret = gst_caps_can_intersect (caps, template_caps);
 462   GST_DEBUG_OBJECT (pad, "%saccepted caps %" GST_PTR_FORMAT,
 463       (ret ? "" : "not "), caps);
 464   gst_caps_unref (template_caps);
 465
 466   return ret;
 467 }
 468
 469 static gboolean
 470 gst_va_compositor_sink_query (GstAggregator * agg, GstAggregatorPad * pad,
 471     GstQuery * query)
 472 {
 473   GstVaCompositor *self = GST_VA_COMPOSITOR (agg);
 474
 475   switch (GST_QUERY_TYPE (query)) {
 476     case GST_QUERY_CONTEXT:
 477     {
 478       if (_handle_context_query (self, query))
 479         return TRUE;
 480       break;
 481     }
 482     case GST_QUERY_CAPS:
 483     {
 484       GstCaps *filter, *caps;
 485
 486       gst_query_parse_caps (query, &filter);
 487       caps = gst_va_compositor_sink_getcaps (GST_PAD (pad), filter);
 488       gst_query_set_caps_result (query, caps);
 489       gst_caps_unref (caps);
 490       return TRUE;
 491     }
 492     case GST_QUERY_ACCEPT_CAPS:
 493     {
 494       GstCaps *caps;
 495       gboolean ret;
 496
 497       gst_query_parse_accept_caps (query, &caps);
 498       ret = gst_va_compositor_sink_acceptcaps (GST_PAD (pad), caps);
 499       gst_query_set_accept_caps_result (query, ret);
 500       return TRUE;
 501     }
 502     default:
 503       break;
 504   }
 505
 506   return GST_AGGREGATOR_CLASS (parent_class)->sink_query (agg, pad, query);
 507 }
 508
 509 static gboolean
 510 gst_va_compositor_src_query (GstAggregator * agg, GstQuery * query)
 511 {
 512   GstVaCompositor *self = GST_VA_COMPOSITOR (agg);
 513
 514   switch (GST_QUERY_TYPE (query)) {
 515     case GST_QUERY_CONTEXT:
 516       if (_handle_context_query (self, query))
 517         return TRUE;
 518       break;
 519     default:
 520       break;
 521   }
 522
 523   return GST_AGGREGATOR_CLASS (parent_class)->src_query (agg, query);
 524 }
 525
 526 static GstAllocator *
 527 gst_va_compositor_allocator_from_caps (GstVaCompositor * self, GstCaps * caps)
 528 {
 529   GstAllocator *allocator = NULL;
 530
 531   if (gst_caps_is_dmabuf (caps)) {
 532     allocator = gst_va_dmabuf_allocator_new (self->display);
 533   } else {
 534     GArray *surface_formats = gst_va_filter_get_surface_formats (self->filter);
 535     allocator = gst_va_allocator_new (self->display, surface_formats);
 536   }
 537
 538   return allocator;
 539 }
 540
 541 /* Answer upstream allocation query. */
 542 static gboolean
 543 gst_va_compositor_propose_allocation (GstAggregator * agg,
 544     GstAggregatorPad * aggpad, GstQuery * decide_query, GstQuery * query)
 545 {
 546   GstVaCompositor *self = GST_VA_COMPOSITOR (agg);
 547   GstAllocator *allocator = NULL;
 548   GstAllocationParams params = { 0, };
 549   GstBufferPool *pool;
 550   GstCaps *caps;
 551   GstVideoInfo info;
 552   gboolean update_allocator = FALSE;
 553   guint size, usage_hint = VA_SURFACE_ATTRIB_USAGE_HINT_GENERIC;
 554
 555   gst_query_parse_allocation (query, &caps, NULL);
 556
 557   if (!caps)
 558     return FALSE;
 559
 560   if (!gst_video_info_from_caps (&info, caps))
 561     return FALSE;
 562
 563   if (gst_query_get_n_allocation_pools (query) > 0)
 564     return TRUE;
 565
 566   size = GST_VIDEO_INFO_SIZE (&info);
 567
 568   if (gst_query_get_n_allocation_params (query) > 0) {
 569     gst_query_parse_nth_allocation_param (query, 0, &allocator, &params);
 570     if (!GST_IS_VA_DMABUF_ALLOCATOR (allocator)
 571         && !GST_IS_VA_ALLOCATOR (allocator))
 572       gst_clear_object (&allocator);
 573     update_allocator = TRUE;
 574   } else {
 575     gst_allocation_params_init (&params);
 576   }
 577
 578   if (!allocator) {
 579     if (!(allocator = gst_va_compositor_allocator_from_caps (self, caps)))
 580       return FALSE;
 581   }
 582
 583   /* Now we have a VA-based allocator */
 584
 585   pool = gst_va_pool_new_with_config (caps, size, 1, 0, usage_hint,
 586       GST_VA_FEATURE_AUTO, allocator, &params);
 587   if (!pool) {
 588     gst_object_unref (allocator);
 589     goto config_failed;
 590   }
 591
 592   if (update_allocator)
 593     gst_query_set_nth_allocation_param (query, 0, allocator, &params);
 594   else
 595     gst_query_add_allocation_param (query, allocator, &params);
 596
 597   gst_query_add_allocation_pool (query, pool, size, 1, 0);
 598
 599   GST_DEBUG_OBJECT (self,
 600       "proposing %" GST_PTR_FORMAT " with allocator %" GST_PTR_FORMAT,
 601       pool, allocator);
 602
 603   gst_object_unref (allocator);
 604   gst_object_unref (pool);
 605
 606   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
 607
 608   return TRUE;
 609
 610 config_failed:
 611   {
 612     GST_ERROR_OBJECT (self, "failed to set config");
 613     return FALSE;
 614   }
 615 }
 616
 617 static GstBufferPool *
 618 _create_other_pool (GstAllocator * allocator, GstAllocationParams * params,
 619     GstCaps * caps, guint size)
 620 {
 621   GstBufferPool *pool = NULL;
 622   GstStructure *config;
 623
 624   pool = gst_video_buffer_pool_new ();
 625   config = gst_buffer_pool_get_config (pool);
 626
 627   gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
 628   gst_buffer_pool_config_set_allocator (config, allocator, params);
 629   if (!gst_buffer_pool_set_config (pool, config)) {
 630     gst_clear_object (&pool);
 631   }
 632
 633   return pool;
 634 }
 635
 636 /* configure the allocation query that was answered downstream */
 637 static gboolean
 638 gst_va_compositor_decide_allocation (GstAggregator * agg, GstQuery * query)
 639 {
 640   GstVaCompositor *self = GST_VA_COMPOSITOR (agg);
 641   GstVideoAggregator *vagg = GST_VIDEO_AGGREGATOR (agg);
 642
 643   GstAllocator *allocator = NULL, *other_allocator = NULL;
 644   GstAllocationParams params, other_params;
 645   GstBufferPool *pool = NULL, *other_pool = NULL;
 646   GstCaps *caps = NULL;
 647   GstStructure *config;
 648   GstVideoInfo info;
 649   guint min, max, size = 0, usage_hint = VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE;
 650   gboolean update_pool, update_allocator, has_videometa, copy_frames;
 651
 652   gst_query_parse_allocation (query, &caps, NULL);
 653
 654   gst_allocation_params_init (&other_params);
 655   gst_allocation_params_init (&params);
 656
 657   if (!gst_video_info_from_caps (&info, caps)) {
 658     GST_ERROR_OBJECT (self, "Cannot parse caps %" GST_PTR_FORMAT, caps);
 659     return FALSE;
 660   }
 661
 662   if (gst_query_get_n_allocation_params (query) > 0) {
 663     gst_query_parse_nth_allocation_param (query, 0, &allocator, &other_params);
 664     if (allocator && !(GST_IS_VA_DMABUF_ALLOCATOR (allocator)
 665             || GST_IS_VA_ALLOCATOR (allocator))) {
 666       /* save the allocator for the other pool */
 667       other_allocator = allocator;
 668       allocator = NULL;
 669     }
 670     update_allocator = TRUE;
 671   } else {
 672     update_allocator = FALSE;
 673   }
 674
 675   if (gst_query_get_n_allocation_pools (query) > 0) {
 676     gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
 677
 678     if (pool) {
 679       if (!GST_IS_VA_POOL (pool)) {
 680         GST_DEBUG_OBJECT (self,
 681             "may need other pool for copy frames %" GST_PTR_FORMAT, pool);
 682         other_pool = pool;
 683         pool = NULL;
 684       }
 685     }
 686
 687     update_pool = TRUE;
 688   } else {
 689     size = GST_VIDEO_INFO_SIZE (&info);
 690     min = 1;
 691     max = 0;
 692     update_pool = FALSE;
 693   }
 694
 695   if (!allocator) {
 696     if (gst_caps_is_dmabuf (caps) && GST_VIDEO_INFO_IS_RGB (&info))
 697       usage_hint = VA_SURFACE_ATTRIB_USAGE_HINT_GENERIC;
 698     if (!(allocator = gst_va_compositor_allocator_from_caps (self, caps)))
 699       return FALSE;
 700   }
 701
 702   if (!pool)
 703     pool = gst_va_pool_new ();
 704
 705   config = gst_buffer_pool_get_config (pool);
 706   gst_buffer_pool_config_set_allocator (config, allocator, &params);
 707   gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
 708   gst_buffer_pool_config_set_params (config, caps, size, min, max);
 709   gst_buffer_pool_config_set_va_allocation_params (config, usage_hint,
 710       GST_VA_FEATURE_AUTO);
 711   if (!gst_buffer_pool_set_config (pool, config)) {
 712     gst_object_unref (allocator);
 713     gst_object_unref (pool);
 714     return FALSE;
 715   }
 716
 717   if (GST_IS_VA_DMABUF_ALLOCATOR (allocator)) {
 718     gst_va_dmabuf_allocator_get_format (allocator, &vagg->info, NULL);
 719   } else if (GST_IS_VA_ALLOCATOR (allocator)) {
 720     gst_va_allocator_get_format (allocator, &vagg->info, NULL, NULL);
 721   }
 722
 723   if (update_allocator)
 724     gst_query_set_nth_allocation_param (query, 0, allocator, &params);
 725   else
 726     gst_query_add_allocation_param (query, allocator, &params);
 727
 728   if (update_pool)
 729     gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
 730   else
 731     gst_query_add_allocation_pool (query, pool, size, min, max);
 732
 733   has_videometa = gst_query_find_allocation_meta (query,
 734       GST_VIDEO_META_API_TYPE, NULL);
 735
 736   copy_frames = (!has_videometa && gst_va_pool_requires_video_meta (pool)
 737       && gst_caps_is_raw (caps));
 738   if (copy_frames) {
 739     if (other_pool) {
 740       gst_object_replace ((GstObject **) & self->other_pool,
 741           (GstObject *) other_pool);
 742     } else {
 743       self->other_pool =
 744           _create_other_pool (other_allocator, &other_params, caps, size);
 745     }
 746     GST_DEBUG_OBJECT (self, "Use the other pool for copy %" GST_PTR_FORMAT,
 747         self->other_pool);
 748   } else {
 749     gst_clear_object (&self->other_pool);
 750   }
 751
 752   GST_DEBUG_OBJECT (self,
 753       "decided pool %" GST_PTR_FORMAT " with allocator %" GST_PTR_FORMAT,
 754       pool, allocator);
 755
 756   gst_object_unref (allocator);
 757   gst_object_unref (pool);
 758   gst_clear_object (&other_allocator);
 759   gst_clear_object (&other_pool);
 760
 761   return TRUE;
 762 }
 763
 764 static GstBufferPool *
 765 _get_sinkpad_pool (GstVaCompositor * self, GstVaCompositorPad * pad)
 766 {
 767   GstAllocator *allocator;
 768   GstAllocationParams params = { 0, };
 769   GstCaps *caps;
 770   GstVideoInfo info;
 771   guint size, usage_hint = VA_SURFACE_ATTRIB_USAGE_HINT_VPP_READ;
 772
 773   if (pad->pool)
 774     return pad->pool;
 775
 776   gst_allocation_params_init (&params);
 777
 778   caps = gst_pad_get_current_caps (GST_PAD (pad));
 779   if (!caps)
 780     return NULL;
 781   if (!gst_video_info_from_caps (&info, caps)) {
 782     GST_ERROR_OBJECT (self, "Cannot parse caps %" GST_PTR_FORMAT, caps);
 783     gst_caps_unref (caps);
 784     return NULL;
 785   }
 786
 787   size = GST_VIDEO_INFO_SIZE (&info);
 788
 789   allocator = gst_va_compositor_allocator_from_caps (self, caps);
 790   pad->pool = gst_va_pool_new_with_config (caps, size, 1, 0, usage_hint,
 791       GST_VA_FEATURE_AUTO, allocator, &params);
 792   gst_caps_unref (caps);
 793
 794   if (!pad->pool) {
 795     gst_object_unref (allocator);
 796     return NULL;
 797   }
 798
 799   if (GST_IS_VA_DMABUF_ALLOCATOR (allocator)) {
 800     gst_va_dmabuf_allocator_get_format (allocator, &info, NULL);
 801   } else if (GST_IS_VA_ALLOCATOR (allocator)) {
 802     gst_va_allocator_get_format (allocator, &info, NULL, NULL);
 803   }
 804
 805   gst_object_unref (allocator);
 806
 807   if (!gst_buffer_pool_set_active (pad->pool, TRUE)) {
 808     GST_WARNING_OBJECT (self, "failed to active the sinkpad pool %"
 809         GST_PTR_FORMAT, pad->pool);
 810     return NULL;
 811   }
 812
 813   return pad->pool;
 814 }
 815
 816 static inline gsize
 817 _get_plane_data_size (GstVideoInfo * info, guint plane)
 818 {
 819   gint comp[GST_VIDEO_MAX_COMPONENTS];
 820   gint height, padded_height;
 821
 822   gst_video_format_info_component (info->finfo, plane, comp);
 823
 824   height = GST_VIDEO_INFO_HEIGHT (info);
 825   padded_height =
 826       GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (info->finfo, comp[0], height);
 827
 828   return GST_VIDEO_INFO_PLANE_STRIDE (info, plane) * padded_height;
 829 }
 830
 831 static gboolean
 832 _try_import_dmabuf_unlocked (GstVaCompositor * self, GstVideoInfo * info,
 833     GstBuffer * inbuf)
 834 {
 835   GstVideoMeta *meta;
 836   GstMemory *mems[GST_VIDEO_MAX_PLANES];
 837   guint i, n_mem, n_planes;
 838   gsize offset[GST_VIDEO_MAX_PLANES];
 839   uintptr_t fd[GST_VIDEO_MAX_PLANES];
 840
 841   n_planes = GST_VIDEO_INFO_N_PLANES (info);
 842   n_mem = gst_buffer_n_memory (inbuf);
 843   meta = gst_buffer_get_video_meta (inbuf);
 844
 845   /* This will eliminate most non-dmabuf out there */
 846   if (!gst_is_dmabuf_memory (gst_buffer_peek_memory (inbuf, 0)))
 847     return FALSE;
 848
 849   /* We cannot have multiple dmabuf per plane */
 850   if (n_mem > n_planes)
 851     return FALSE;
 852
 853   /* Update video info based on video meta */
 854   if (meta) {
 855     GST_VIDEO_INFO_WIDTH (info) = meta->width;
 856     GST_VIDEO_INFO_HEIGHT (info) = meta->height;
 857
 858     for (i = 0; i < meta->n_planes; i++) {
 859       GST_VIDEO_INFO_PLANE_OFFSET (info, i) = meta->offset[i];
 860       GST_VIDEO_INFO_PLANE_STRIDE (info, i) = meta->stride[i];
 861     }
 862   }
 863
 864   /* Find and validate all memories */
 865   for (i = 0; i < n_planes; i++) {
 866     guint plane_size;
 867     guint length;
 868     guint mem_idx;
 869     gsize mem_skip;
 870
 871     plane_size = _get_plane_data_size (info, i);
 872
 873     if (!gst_buffer_find_memory (inbuf, info->offset[i], plane_size,
 874             &mem_idx, &length, &mem_skip))
 875       return FALSE;
 876
 877     /* We can't have more then one dmabuf per plane */
 878     if (length != 1)
 879       return FALSE;
 880
 881     mems[i] = gst_buffer_peek_memory (inbuf, mem_idx);
 882
 883     /* And all memory found must be dmabuf */
 884     if (!gst_is_dmabuf_memory (mems[i]))
 885       return FALSE;
 886
 887     offset[i] = mems[i]->offset + mem_skip;
 888     fd[i] = gst_dmabuf_memory_get_fd (mems[i]);
 889   }
 890
 891   /* Now create a VASurfaceID for the buffer */
 892   return gst_va_dmabuf_memories_setup (self->display, info, n_planes,
 893       mems, fd, offset, VA_SURFACE_ATTRIB_USAGE_HINT_VPP_READ);
 894 }
 895
 896 extern GRecMutex GST_VA_SHARED_LOCK;
 897
 898 static gboolean
 899 _try_import_buffer (GstVaCompositor * self, GstVideoInfo info,
 900     GstBuffer * inbuf)
 901 {
 902   VASurfaceID surface;
 903   gboolean ret;
 904
 905   surface = gst_va_buffer_get_surface (inbuf);
 906   if (surface != VA_INVALID_ID)
 907     return TRUE;
 908
 909   g_rec_mutex_lock (&GST_VA_SHARED_LOCK);
 910   ret = _try_import_dmabuf_unlocked (self, &info, inbuf);
 911   g_rec_mutex_unlock (&GST_VA_SHARED_LOCK);
 912
 913   return ret;
 914 }
 915
 916 static GstFlowReturn
 917 gst_va_compositor_import_buffer (GstVaCompositor * self,
 918     GstVaCompositorPad * pad, GstBuffer * inbuf, GstBuffer ** buf)
 919 {
 920   GstBuffer *buffer = NULL;
 921   GstBufferPool *pool;
 922   GstFlowReturn ret;
 923   GstCaps *caps;
 924   GstVideoInfo info;
 925   GstVideoFrame in_frame, out_frame;
 926   gboolean imported, copied;
 927
 928   caps = gst_pad_get_current_caps (GST_PAD (pad));
 929   if (!caps)
 930     return GST_FLOW_ERROR;
 931   if (!gst_video_info_from_caps (&info, caps)) {
 932     GST_ERROR_OBJECT (self, "Cannot parse caps %" GST_PTR_FORMAT, caps);
 933     gst_caps_unref (caps);
 934     return GST_FLOW_ERROR;
 935   }
 936   gst_caps_unref (caps);
 937
 938   imported = _try_import_buffer (self, info, inbuf);
 939   if (imported) {
 940     *buf = gst_buffer_ref (inbuf);
 941     return GST_FLOW_OK;
 942   }
 943
 944   GST_LOG_OBJECT (self, "copying input frame");
 945
 946   /* input buffer doesn't come from a vapool, thus it is required to
 947    * have a pool, grab from it a new buffer and copy the input
 948    * buffer to the new one */
 949   if (!(pool = _get_sinkpad_pool (self, pad)))
 950     return GST_FLOW_ERROR;
 951
 952   ret = gst_buffer_pool_acquire_buffer (pool, &buffer, NULL);
 953   if (ret != GST_FLOW_OK)
 954     return ret;
 955
 956   if (!gst_video_frame_map (&in_frame, &info, inbuf, GST_MAP_READ))
 957     goto invalid_buffer;
 958
 959   if (!gst_video_frame_map (&out_frame, &info, buffer, GST_MAP_WRITE)) {
 960     gst_video_frame_unmap (&in_frame);
 961     goto invalid_buffer;
 962   }
 963
 964   copied = gst_video_frame_copy (&out_frame, &in_frame);
 965
 966   gst_video_frame_unmap (&out_frame);
 967   gst_video_frame_unmap (&in_frame);
 968
 969   if (!copied)
 970     goto invalid_buffer;
 971
 972   *buf = buffer;
 973
 974   return GST_FLOW_OK;
 975
 976 invalid_buffer:
 977   {
 978     GST_ELEMENT_WARNING (self, CORE, NOT_IMPLEMENTED, (NULL),
 979         ("invalid video buffer received"));
 980     if (buffer)
 981       gst_buffer_unref (buffer);
 982     return GST_FLOW_OK;
 983   }
 984 }
 985
 986 typedef struct _GstVaCompositorSampleGenerator GstVaCompositorSampleGenerator;
 987 struct _GstVaCompositorSampleGenerator
 988 {
 989   GstVaCompositor *comp;
 990   GList *current;
 991   GstVaComposeSample sample;
 992 };
 993
 994 static GstVaComposeSample *
 995 gst_va_compositor_sample_next (gpointer data)
 996 {
 997   GstVaCompositorSampleGenerator *generator;
 998   GstVideoAggregatorPad *vaggpad;
 999   GstVaCompositorPad *pad;
1000   GstBuffer *inbuf;
1001   GstBuffer *buf;
1002   GstFlowReturn res;
1003   GstVideoCropMeta *crop = NULL;
1004
1005   generator = (GstVaCompositorSampleGenerator *) data;
1006
1007   /* at the end of the generator? */
1008   while (generator->current) {
1009     /* get the current sinkpad for processing */
1010     vaggpad = GST_VIDEO_AGGREGATOR_PAD (generator->current->data);
1011
1012     /* increment to next sinkpad */
1013     generator->current = generator->current->next;
1014
1015     /* reset sample */
1016     /* *INDENT-OFF* */
1017     generator->sample = (GstVaComposeSample) { 0, };
1018     /* *INDENT-ON* */
1019
1020     /* current sinkpad may not be queueing buffers yet (e.g. timestamp-offset)
1021      * or it may have reached EOS */
1022     if (!gst_video_aggregator_pad_has_current_buffer (vaggpad))
1023       continue;
1024
1025     inbuf = gst_video_aggregator_pad_get_current_buffer (vaggpad);
1026     pad = GST_VA_COMPOSITOR_PAD (vaggpad);
1027
1028     res = gst_va_compositor_import_buffer (generator->comp, pad, inbuf, &buf);
1029     if (res != GST_FLOW_OK)
1030       return &generator->sample;
1031
1032     crop = gst_buffer_get_video_crop_meta (buf);
1033
1034     GST_OBJECT_LOCK (vaggpad);
1035     /* *INDENT-OFF* */
1036     generator->sample = (GstVaComposeSample) {
1037       .buffer = buf,
1038       .input_region = (VARectangle) {
1039         .x = crop ? crop->x : 0,
1040         .y = crop ? crop->y : 0,
1041         .width = crop ? crop->width : GST_VIDEO_INFO_WIDTH (&vaggpad->info),
1042         .height = crop ? crop->height : GST_VIDEO_INFO_HEIGHT (&vaggpad->info),
1043       },
1044       .output_region = (VARectangle) {
1045         .x = pad->xpos,
1046         .y = pad->ypos,
1047         .width = (pad->width == DEFAULT_PAD_WIDTH)
1048             ? GST_VIDEO_INFO_WIDTH (&vaggpad->info) : pad->width,
1049         .height = (pad->height == DEFAULT_PAD_HEIGHT)
1050             ? GST_VIDEO_INFO_HEIGHT (&vaggpad->info) : pad->height,
1051       },
1052       .flags = generator->comp->scale_method,
1053       .alpha = pad->alpha,
1054     };
1055     /* *INDENT-ON* */
1056     GST_OBJECT_UNLOCK (vaggpad);
1057
1058     return &generator->sample;
1059   }
1060
1061   return NULL;
1062 }
1063
1064 static gboolean
1065 gst_va_compositor_copy_output_buffer (GstVaCompositor * self,
1066     GstBuffer * src_buf, GstBuffer * dst_buf)
1067 {
1068   GstVideoAggregator *vagg = GST_VIDEO_AGGREGATOR (self);
1069   GstVideoFrame src_frame, dst_frame;
1070
1071   GST_LOG_OBJECT (self, "copying output buffer");
1072
1073   if (!gst_video_frame_map (&src_frame, &vagg->info, src_buf, GST_MAP_READ)) {
1074     GST_ERROR_OBJECT (self, "couldn't map source buffer");
1075     return FALSE;
1076   }
1077
1078   if (!gst_video_frame_map (&dst_frame, &self->other_info, dst_buf,
1079           GST_MAP_WRITE)) {
1080     GST_ERROR_OBJECT (self, "couldn't map output buffer");
1081     gst_video_frame_unmap (&src_frame);
1082     return FALSE;
1083   }
1084
1085   if (!gst_video_frame_copy (&dst_frame, &src_frame)) {
1086     GST_ERROR_OBJECT (self, "couldn't copy output buffer");
1087     gst_video_frame_unmap (&src_frame);
1088     gst_video_frame_unmap (&dst_frame);
1089     return FALSE;
1090   }
1091
1092   gst_video_frame_unmap (&src_frame);
1093   gst_video_frame_unmap (&dst_frame);
1094
1095   return TRUE;
1096 }
1097
1098 static GstFlowReturn
1099 gst_va_compositor_aggregate_frames (GstVideoAggregator * vagg,
1100     GstBuffer * outbuf)
1101 {
1102   GstVaCompositor *self = GST_VA_COMPOSITOR (vagg);
1103   GstVaCompositorSampleGenerator generator;
1104   GstVaComposeTransaction tx;
1105   GstBuffer *vabuffer;
1106   gboolean need_copy = FALSE;
1107   GstFlowReturn ret = GST_FLOW_OK;
1108
1109   if (self->other_pool) {
1110     /* create a va buffer for filter */
1111     ret = GST_VIDEO_AGGREGATOR_CLASS (parent_class)->create_output_buffer
1112         (vagg, &vabuffer);
1113     if (ret != GST_FLOW_OK)
1114       return ret;
1115
1116     need_copy = TRUE;
1117   } else {
1118     /* already a va buffer */
1119     vabuffer = gst_buffer_ref (outbuf);
1120   }
1121
1122   /* *INDENT-OFF* */
1123   generator = (GstVaCompositorSampleGenerator) {
1124     .comp = self,
1125     .current = GST_ELEMENT (self)->sinkpads,
1126   };
1127   tx = (GstVaComposeTransaction) {
1128     .next = gst_va_compositor_sample_next,
1129     .output = vabuffer,
1130     .user_data = (gpointer) &generator,
1131   };
1132   /* *INDENT-ON* */
1133
1134   GST_OBJECT_LOCK (self);
1135
1136   if (!gst_va_filter_compose (self->filter, &tx)) {
1137     GST_ERROR_OBJECT (self, "couldn't apply filter");
1138     ret = GST_FLOW_ERROR;
1139   }
1140
1141   GST_OBJECT_UNLOCK (self);
1142
1143   if (ret != GST_FLOW_OK)
1144     goto done;
1145
1146   if (need_copy && !gst_va_compositor_copy_output_buffer (self, vabuffer,
1147           outbuf)) {
1148     GST_ERROR_OBJECT (self, "couldn't copy va buffer to output buffer");
1149     ret = GST_FLOW_ERROR;
1150   }
1151
1152 done:
1153   gst_buffer_unref (vabuffer);
1154   return ret;
1155 }
1156
1157 static GstFlowReturn
1158 gst_va_compositor_create_output_buffer (GstVideoAggregator * vagg,
1159     GstBuffer ** outbuf)
1160 {
1161   GstVaCompositor *self = GST_VA_COMPOSITOR (vagg);
1162   GstFlowReturn ret;
1163
1164   *outbuf = NULL;
1165
1166   if (!self->other_pool)
1167     /* no copy necessary, so use a va buffer directly */
1168     return GST_VIDEO_AGGREGATOR_CLASS (parent_class)->create_output_buffer
1169         (vagg, outbuf);
1170
1171   /* use output buffers from downstream pool for copy */
1172   if (!gst_buffer_pool_is_active (self->other_pool) &&
1173       !gst_buffer_pool_set_active (self->other_pool, TRUE)) {
1174     GST_ERROR_OBJECT (self, "failed to activate other pool %"
1175         GST_PTR_FORMAT, self->other_pool);
1176     return GST_FLOW_ERROR;
1177   }
1178
1179   /* acquire a buffer from downstream pool for copy */
1180   ret = gst_buffer_pool_acquire_buffer (self->other_pool, outbuf, NULL);
1181   if (ret != GST_FLOW_OK || !*outbuf) {
1182     GST_ERROR_OBJECT (self, "failed to acquire output buffer");
1183     return GST_FLOW_ERROR;
1184   }
1185
1186   return GST_FLOW_OK;
1187 }
1188
1189 static gboolean
1190 gst_va_compositor_negotiated_src_caps (GstAggregator * agg, GstCaps * caps)
1191 {
1192   GstVaCompositor *self = GST_VA_COMPOSITOR (agg);
1193
1194   if (!gst_video_info_from_caps (&self->other_info, caps)) {
1195     GST_ERROR_OBJECT (self, "invalid caps");
1196     return FALSE;
1197   }
1198
1199   if (self->other_pool) {
1200     gst_buffer_pool_set_active (self->other_pool, FALSE);
1201     gst_clear_object (&self->other_pool);
1202   }
1203
1204   return GST_AGGREGATOR_CLASS (parent_class)->negotiated_src_caps (agg, caps);
1205 }
1206
1207 static void
1208 gst_va_compositor_pad_get_output_size (GstVaCompositorPad * pad, gint * width,
1209     gint * height)
1210 {
1211   GstVideoAggregatorPad *vaggpad = GST_VIDEO_AGGREGATOR_PAD (pad);
1212   *width = (pad->width == DEFAULT_PAD_WIDTH)
1213       ? GST_VIDEO_INFO_WIDTH (&vaggpad->info) : pad->width;
1214   *height = (pad->height == DEFAULT_PAD_HEIGHT)
1215       ? GST_VIDEO_INFO_HEIGHT (&vaggpad->info) : pad->height;
1216
1217   *width += MAX (pad->xpos, 0);
1218   *height += MAX (pad->ypos, 0);
1219 }
1220
1221 static GstCaps *
1222 gst_va_compositor_fixate_src_caps (GstAggregator * agg, GstCaps * caps)
1223 {
1224   GstVideoAggregator *vagg = GST_VIDEO_AGGREGATOR (agg);
1225   GList *l;
1226   gint best_width = -1, best_height = -1;
1227   gint best_fps_n = -1, best_fps_d = -1;
1228   gdouble best_fps = 0.;
1229   GstCaps *ret = NULL;
1230   GstStructure *s;
1231
1232   ret = gst_caps_make_writable (caps);
1233
1234   GST_OBJECT_LOCK (vagg);
1235   for (l = GST_ELEMENT (vagg)->sinkpads; l; l = l->next) {
1236     GstVideoAggregatorPad *vaggpad = l->data;
1237     GstVaCompositorPad *pad = GST_VA_COMPOSITOR_PAD (vaggpad);
1238     gint this_width, this_height;
1239     gint fps_n, fps_d;
1240     gdouble cur_fps;
1241
1242     fps_n = GST_VIDEO_INFO_FPS_N (&vaggpad->info);
1243     fps_d = GST_VIDEO_INFO_FPS_D (&vaggpad->info);
1244
1245     gst_va_compositor_pad_get_output_size (pad, &this_width, &this_height);
1246
1247     if (best_width < this_width)
1248       best_width = this_width;
1249     if (best_height < this_height)
1250       best_height = this_height;
1251
1252     if (fps_d == 0)
1253       cur_fps = 0.0;
1254     else
1255       gst_util_fraction_to_double (fps_n, fps_d, &cur_fps);
1256
1257     if (best_fps < cur_fps) {
1258       best_fps = cur_fps;
1259       best_fps_n = fps_n;
1260       best_fps_d = fps_d;
1261     }
1262   }
1263   GST_OBJECT_UNLOCK (vagg);
1264
1265   if (best_fps_n <= 0 || best_fps_d <= 0 || best_fps == 0.0) {
1266     best_fps_n = 25;
1267     best_fps_d = 1;
1268     best_fps = 25.0;
1269   }
1270
1271   s = gst_caps_get_structure (ret, 0);
1272   gst_structure_fixate_field_nearest_int (s, "width", best_width);
1273   gst_structure_fixate_field_nearest_int (s, "height", best_height);
1274   if (gst_structure_has_field (s, "framerate")) {
1275     gst_structure_fixate_field_nearest_fraction (s, "framerate", best_fps_n,
1276         best_fps_d);
1277   } else {
1278     gst_structure_set (s, "framerate", GST_TYPE_FRACTION, best_fps_n,
1279         best_fps_d, NULL);
1280   }
1281
1282   return gst_caps_fixate (ret);
1283 }
1284
1285 /* *INDENT-OFF* */
1286 static const gchar *caps_str =
1287     GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_VA,
1288         "{ NV12, I420, YV12, YUY2, RGBA, BGRA, P010_10LE, ARGB, ABGR }") " ;"
1289     GST_VIDEO_CAPS_MAKE ("{ VUYA, GRAY8, NV12, NV21, YUY2, UYVY, YV12, "
1290         "I420, P010_10LE, RGBA, BGRA, ARGB, ABGR  }");
1291 /* *INDENT-ON* */
1292
1293 static void
1294 gst_va_compositor_class_init (gpointer g_class, gpointer class_data)
1295 {
1296   GstCaps *doc_caps, *caps = NULL;
1297   GstPadTemplate *sink_pad_templ, *src_pad_templ;
1298   GObjectClass *object_class = G_OBJECT_CLASS (g_class);
1299   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
1300   GstAggregatorClass *agg_class = GST_AGGREGATOR_CLASS (g_class);
1301   GstVideoAggregatorClass *vagg_class = GST_VIDEO_AGGREGATOR_CLASS (g_class);
1302   GstVaCompositorClass *klass = GST_VA_COMPOSITOR_CLASS (g_class);
1303   GstVaDisplay *display;
1304   GstVaFilter *filter;
1305   struct CData *cdata = class_data;
1306   gchar *long_name;
1307
1308   parent_class = g_type_class_peek_parent (g_class);
1309
1310   klass->render_device_path = g_strdup (cdata->render_device_path);
1311
1312   if (cdata->description) {
1313     long_name = g_strdup_printf ("VA-API Video Compositor in %s",
1314         cdata->description);
1315   } else {
1316     long_name = g_strdup ("VA-API Video Compositor");
1317   }
1318
1319   display = gst_va_display_drm_new_from_path (klass->render_device_path);
1320   filter = gst_va_filter_new (display);
1321
1322   if (gst_va_filter_open (filter)) {
1323     caps = gst_va_filter_get_caps (filter);
1324   } else {
1325     caps = gst_caps_from_string (caps_str);
1326   }
1327
1328   object_class->dispose = GST_DEBUG_FUNCPTR (gst_va_compositor_dispose);
1329   object_class->get_property =
1330       GST_DEBUG_FUNCPTR (gst_va_compositor_get_property);
1331   object_class->set_property =
1332       GST_DEBUG_FUNCPTR (gst_va_compositor_set_property);
1333
1334   gst_element_class_set_static_metadata (element_class, long_name,
1335       "Filter/Editor/Video/Compositor/Hardware",
1336       "VA-API based video compositor",
1337       "U. Artie Eoff <ullysses.a.eoff@intel.com>");
1338
1339   element_class->request_new_pad =
1340       GST_DEBUG_FUNCPTR (gst_va_compositor_request_new_pad);
1341   element_class->release_pad =
1342       GST_DEBUG_FUNCPTR (gst_va_compositor_release_pad);
1343   element_class->set_context =
1344       GST_DEBUG_FUNCPTR (gst_va_compositor_set_context);
1345
1346   doc_caps = gst_caps_from_string (caps_str);
1347
1348   sink_pad_templ = gst_pad_template_new_with_gtype ("sink_%u", GST_PAD_SINK,
1349       GST_PAD_REQUEST, caps, GST_TYPE_VA_COMPOSITOR_PAD);
1350   gst_element_class_add_pad_template (element_class, sink_pad_templ);
1351   gst_pad_template_set_documentation_caps (sink_pad_templ,
1352       gst_caps_ref (doc_caps));
1353
1354   src_pad_templ = gst_pad_template_new_with_gtype ("src", GST_PAD_SRC,
1355       GST_PAD_ALWAYS, caps, GST_TYPE_AGGREGATOR_PAD);
1356   gst_element_class_add_pad_template (element_class, src_pad_templ);
1357   gst_pad_template_set_documentation_caps (src_pad_templ,
1358       gst_caps_ref (doc_caps));
1359
1360   gst_caps_unref (doc_caps);
1361   gst_caps_unref (caps);
1362
1363   agg_class->sink_query = GST_DEBUG_FUNCPTR (gst_va_compositor_sink_query);
1364   agg_class->src_query = GST_DEBUG_FUNCPTR (gst_va_compositor_src_query);
1365   agg_class->start = GST_DEBUG_FUNCPTR (gst_va_compositor_start);
1366   agg_class->stop = GST_DEBUG_FUNCPTR (gst_va_compositor_stop);
1367   agg_class->propose_allocation =
1368       GST_DEBUG_FUNCPTR (gst_va_compositor_propose_allocation);
1369   agg_class->fixate_src_caps =
1370       GST_DEBUG_FUNCPTR (gst_va_compositor_fixate_src_caps);
1371   agg_class->negotiated_src_caps =
1372       GST_DEBUG_FUNCPTR (gst_va_compositor_negotiated_src_caps);
1373   agg_class->decide_allocation =
1374       GST_DEBUG_FUNCPTR (gst_va_compositor_decide_allocation);
1375
1376   vagg_class->aggregate_frames =
1377       GST_DEBUG_FUNCPTR (gst_va_compositor_aggregate_frames);
1378   vagg_class->create_output_buffer =
1379       GST_DEBUG_FUNCPTR (gst_va_compositor_create_output_buffer);
1380
1381   properties[PROP_DEVICE_PATH] = g_param_spec_string ("device-path",
1382       "Device Path", "DRM device path", NULL,
1383       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
1384
1385   properties[PROP_SCALE_METHOD] = g_param_spec_enum ("scale-method",
1386       "Scale Method", "Scale method to use", GST_TYPE_VA_SCALE_METHOD,
1387       VA_FILTER_SCALING_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
1388
1389   g_object_class_install_properties (object_class, N_PROPERTIES, properties);
1390
1391   g_free (long_name);
1392   g_free (cdata->description);
1393   g_free (cdata->render_device_path);
1394   g_free (cdata);
1395   gst_object_unref (filter);
1396   gst_object_unref (display);
1397 }
1398
1399 static GObject *
1400 gst_va_compositor_child_proxy_get_child_by_index (GstChildProxy * proxy,
1401     guint index)
1402 {
1403   GstVaCompositor *self = GST_VA_COMPOSITOR (proxy);
1404   GObject *obj = NULL;
1405
1406   GST_OBJECT_LOCK (self);
1407   obj = g_list_nth_data (GST_ELEMENT_CAST (self)->sinkpads, index);
1408   if (obj)
1409     gst_object_ref (obj);
1410   GST_OBJECT_UNLOCK (self);
1411
1412   return obj;
1413 }
1414
1415 static guint
1416 gst_va_compositor_child_proxy_get_children_count (GstChildProxy * proxy)
1417 {
1418   GstVaCompositor *self = GST_VA_COMPOSITOR (proxy);
1419   guint count = 0;
1420
1421   GST_OBJECT_LOCK (self);
1422   count = GST_ELEMENT_CAST (self)->numsinkpads;
1423   GST_OBJECT_UNLOCK (self);
1424   GST_INFO_OBJECT (self, "Children Count: %d", count);
1425
1426   return count;
1427 }
1428
1429 static void
1430 gst_va_compositor_child_proxy_init (gpointer g_iface, gpointer iface_data)
1431 {
1432   GstChildProxyInterface *iface = (GstChildProxyInterface *) g_iface;
1433
1434   iface->get_child_by_index = gst_va_compositor_child_proxy_get_child_by_index;
1435   iface->get_children_count = gst_va_compositor_child_proxy_get_children_count;
1436 }
1437
1438 static void
1439 gst_va_compositor_init (GTypeInstance * instance, gpointer g_class)
1440 {
1441   GstVaCompositor *self = GST_VA_COMPOSITOR (instance);
1442
1443   self->other_pool = NULL;
1444 }
1445
1446 static gpointer
1447 _register_debug_category (gpointer data)
1448 {
1449   GST_DEBUG_CATEGORY_INIT (gst_va_compositor_debug, "vacompositor", 0,
1450       "VA Video Compositor");
1451
1452   return NULL;
1453 }
1454
1455 gboolean
1456 gst_va_compositor_register (GstPlugin * plugin, GstVaDevice * device,
1457     guint rank)
1458 {
1459   static GOnce debug_once = G_ONCE_INIT;
1460   GType type;
1461   GTypeInfo type_info = {
1462     .class_size = sizeof (GstVaCompositorClass),
1463     .class_init = gst_va_compositor_class_init,
1464     .instance_size = sizeof (GstVaCompositor),
1465     .instance_init = gst_va_compositor_init,
1466   };
1467   GInterfaceInfo interface_info = {
1468     (GInterfaceInitFunc) gst_va_compositor_child_proxy_init,
1469   };
1470   struct CData *cdata;
1471   gboolean ret;
1472   gchar *type_name, *feature_name;
1473
1474   g_return_val_if_fail (GST_IS_PLUGIN (plugin), FALSE);
1475   g_return_val_if_fail (GST_IS_VA_DEVICE (device), FALSE);
1476
1477   cdata = g_new (struct CData, 1);
1478   cdata->description = NULL;
1479   cdata->render_device_path = g_strdup (device->render_device_path);
1480
1481   type_info.class_data = cdata;
1482
1483   type_name = g_strdup ("GstVaCompositor");
1484   feature_name = g_strdup ("vacompositor");
1485
1486   /* The first compositor to be registered should use a constant
1487    * name, like vacompositor, for any additional compositors, we
1488    * create unique names, using the render device name. */
1489   if (g_type_from_name (type_name)) {
1490     gchar *basename = g_path_get_basename (device->render_device_path);
1491     g_free (type_name);
1492     g_free (feature_name);
1493     type_name = g_strdup_printf ("GstVa%sCompositor", basename);
1494     feature_name = g_strdup_printf ("va%scompositor", basename);
1495     cdata->description = basename;
1496
1497     /* lower rank for non-first device */
1498     if (rank > 0)
1499       rank--;
1500   }
1501
1502   g_once (&debug_once, _register_debug_category, NULL);
1503
1504   type = g_type_register_static (GST_TYPE_VIDEO_AGGREGATOR, type_name,
1505       &type_info, 0);
1506   g_type_add_interface_static (type, GST_TYPE_CHILD_PROXY, &interface_info);
1507
1508   ret = gst_element_register (plugin, feature_name, rank, type);
1509
1510   g_free (type_name);
1511   g_free (feature_name);
1512
1513   return ret;
1514 }