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

   1 /* GStreamer
   2  *  Copyright (C) 2020 Intel Corporation
   3  *     Author: He Junyan <junyan.he@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-vaav1dec
  23  * @title: vaav1dec
  24  * @short_description: A VA-API based AV1 video decoder
  25  *
  26  * vaav1dec decodes AV1 bitstreams to VA surfaces using the
  27  * installed and chosen [VA-API](https://01.org/linuxmedia/vaapi)
  28  * driver.
  29  *
  30  * The decoding surfaces can be mapped onto main memory as video
  31  * frames.
  32  *
  33  * ## Example launch line
  34  * ```
  35  * gst-launch-1.0 filesrc location=sample.av1 ! ivfparse ! av1parse ! vaav1dec ! autovideosink
  36  * ```
  37  *
  38  * Since: 1.20
  39  *
  40  */
  41
  42 #ifdef HAVE_CONFIG_H
  43 #include "config.h"
  44 #endif
  45
  46 #include <gst/va/gstva.h>
  47
  48 #include "gstvaav1dec.h"
  49 #include "gstvabasedec.h"
  50
  51 GST_DEBUG_CATEGORY_STATIC (gst_va_av1dec_debug);
  52 #ifndef GST_DISABLE_GST_DEBUG
  53 #define GST_CAT_DEFAULT gst_va_av1dec_debug
  54 #else
  55 #define GST_CAT_DEFAULT NULL
  56 #endif
  57
  58 #define GST_VA_AV1_DEC(obj)           ((GstVaAV1Dec *) obj)
  59 #define GST_VA_AV1_DEC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_FROM_INSTANCE (obj), GstVaAV1DecClass))
  60 #define GST_VA_AV1_DEC_CLASS(klass)   ((GstVaAV1DecClass *) klass)
  61
  62 typedef struct _GstVaAV1Dec GstVaAV1Dec;
  63 typedef struct _GstVaAV1DecClass GstVaAV1DecClass;
  64
  65 struct _GstVaAV1DecClass
  66 {
  67   GstVaBaseDecClass parent_class;
  68 };
  69
  70 struct _GstVaAV1Dec
  71 {
  72   GstVaBaseDec parent;
  73
  74   GstAV1SequenceHeaderOBU seq;
  75   GstVideoFormat preferred_format;
  76   /* Used for layers not output. */
  77   GstBufferPool *internal_pool;
  78 };
  79
  80 static GstElementClass *parent_class = NULL;
  81
  82 /* *INDENT-OFF* */
  83 static const gchar *src_caps_str =
  84     GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_VA,
  85         "{ NV12, P010_10LE }") " ;"
  86     GST_VIDEO_CAPS_MAKE ("{ NV12, P010_10LE }");
  87 /* *INDENT-ON* */
  88
  89 static const gchar *sink_caps_str = "video/x-av1";
  90
  91 static gboolean
  92 gst_va_av1_dec_negotiate (GstVideoDecoder * decoder)
  93 {
  94   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
  95   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
  96
  97   /* Ignore downstream renegotiation request. */
  98   if (!base->need_negotiation)
  99     return TRUE;
 100
 101   base->need_negotiation = FALSE;
 102
 103   /* Do not re-create the context if only the frame size changes */
 104   if (!gst_va_decoder_config_is_equal (base->decoder, base->profile,
 105           base->rt_format, base->width, base->height)) {
 106     if (gst_va_decoder_is_open (base->decoder)
 107         && !gst_va_decoder_close (base->decoder))
 108       return FALSE;
 109
 110     if (!gst_va_decoder_open (base->decoder, base->profile, base->rt_format))
 111       return FALSE;
 112
 113     if (!gst_va_decoder_set_frame_size (base->decoder, base->width,
 114             base->height))
 115       return FALSE;
 116   }
 117
 118   if (!gst_va_base_dec_set_output_state (base))
 119     return FALSE;
 120
 121   if (self->preferred_format != GST_VIDEO_FORMAT_UNKNOWN &&
 122       self->preferred_format !=
 123       GST_VIDEO_INFO_FORMAT (&base->output_state->info)) {
 124     GST_WARNING_OBJECT (self, "The preferred_format is different from"
 125         " the last result");
 126     return FALSE;
 127   }
 128   self->preferred_format = GST_VIDEO_INFO_FORMAT (&base->output_state->info);
 129
 130   return GST_VIDEO_DECODER_CLASS (parent_class)->negotiate (decoder);
 131 }
 132
 133 static GstCaps *
 134 _complete_sink_caps (GstCaps * sinkcaps)
 135 {
 136   GstCaps *caps = gst_caps_copy (sinkcaps);
 137   GValue val = G_VALUE_INIT;
 138
 139   g_value_init (&val, G_TYPE_STRING);
 140   g_value_set_string (&val, "frame");
 141   gst_caps_set_value (caps, "alignment", &val);
 142   g_value_unset (&val);
 143
 144   return caps;
 145 }
 146
 147 static VAProfile
 148 _get_profile (GstVaAV1Dec * self, const GstAV1SequenceHeaderOBU * seq_hdr)
 149 {
 150   GstVaBaseDec *base = GST_VA_BASE_DEC (self);
 151   VAProfile profile = VAProfileNone;
 152
 153   switch (seq_hdr->seq_profile) {
 154     case GST_AV1_PROFILE_0:
 155       profile = VAProfileAV1Profile0;
 156       break;
 157     case GST_AV1_PROFILE_1:
 158       profile = VAProfileAV1Profile1;
 159       break;
 160     default:
 161       GST_ERROR_OBJECT (self, "Unsupported av1 profile value %d",
 162           seq_hdr->seq_profile);
 163       return VAProfileNone;
 164   }
 165
 166   if (!gst_va_decoder_has_profile (base->decoder, profile)) {
 167     GST_ERROR_OBJECT (self, "Profile %s is not supported by HW",
 168         gst_va_profile_name (profile));
 169     return VAProfileNone;
 170   }
 171
 172   return profile;
 173 }
 174
 175 static guint
 176 _get_rtformat (GstVaAV1Dec * self, VAProfile profile,
 177     const GstAV1SequenceHeaderOBU * seq_header)
 178 {
 179   /* 6.4.1:
 180      seq_profile  Bit depth  Monochrome support  Chroma subsampling
 181      0            8 or 10    Yes                 YUV 4:2:0
 182      1            8 or 10    No                  YUV 4:4:4
 183      2            8 or 10    Yes                 YUV 4:2:2
 184      2            12         Yes                 YUV 4:2:0,YUV 4:2:2,YUV 4:4:4
 185    */
 186
 187   /* TODO: consider Monochrome case. Just return 4:2:0 for Monochrome now. */
 188   switch (profile) {
 189     case VAProfileAV1Profile0:
 190       if (seq_header->bit_depth == 8) {
 191         return VA_RT_FORMAT_YUV420;
 192       } else if (seq_header->bit_depth == 10) {
 193         return VA_RT_FORMAT_YUV420_10;
 194       }
 195       break;
 196     case VAProfileAV1Profile1:
 197       if (seq_header->bit_depth == 8) {
 198         return VA_RT_FORMAT_YUV444;
 199       } else if (seq_header->bit_depth == 10) {
 200         return VA_RT_FORMAT_YUV444_10;
 201       }
 202       break;
 203     default:
 204       break;
 205   }
 206
 207   GST_ERROR_OBJECT (self, "Fail to find rtformat for profile:%s, bit_depth:%d",
 208       gst_va_profile_name (profile), seq_header->bit_depth);
 209   return 0;
 210 }
 211
 212 static GstCaps *
 213 gst_va_av1_dec_getcaps (GstVideoDecoder * decoder, GstCaps * filter)
 214 {
 215   GstCaps *sinkcaps, *caps = NULL, *tmp;
 216   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 217
 218   if (base->decoder)
 219     caps = gst_va_decoder_get_sinkpad_caps (base->decoder);
 220
 221   if (caps) {
 222     sinkcaps = _complete_sink_caps (caps);
 223     gst_caps_unref (caps);
 224     if (filter) {
 225       tmp = gst_caps_intersect_full (filter, sinkcaps,
 226           GST_CAPS_INTERSECT_FIRST);
 227       gst_caps_unref (sinkcaps);
 228       caps = tmp;
 229     } else {
 230       caps = sinkcaps;
 231     }
 232     GST_LOG_OBJECT (base, "Returning caps %" GST_PTR_FORMAT, caps);
 233   } else if (!caps) {
 234     caps = gst_video_decoder_proxy_getcaps (decoder, NULL, filter);
 235   }
 236
 237   return caps;
 238 }
 239
 240 static void
 241 _clear_internal_pool (GstVaAV1Dec * self)
 242 {
 243   if (self->internal_pool)
 244     gst_buffer_pool_set_active (self->internal_pool, FALSE);
 245
 246   gst_clear_object (&self->internal_pool);
 247 }
 248
 249 static GstBufferPool *
 250 _create_internal_pool (GstVaAV1Dec * self, gint width, gint height)
 251 {
 252   GstVaBaseDec *base = GST_VA_BASE_DEC (self);
 253   GstVideoInfo info;
 254   GArray *surface_formats;
 255   GstAllocator *allocator;
 256   GstCaps *caps = NULL;
 257   GstBufferPool *pool;
 258   GstAllocationParams params = { 0, };
 259
 260   gst_allocation_params_init (&params);
 261
 262   /* We may come here before the negotiation, make sure all pools
 263      use the same video format. */
 264   if (self->preferred_format == GST_VIDEO_FORMAT_UNKNOWN) {
 265     GstVideoFormat format;
 266
 267     gst_va_base_dec_get_preferred_format_and_caps_features (base,
 268         &format, NULL);
 269     if (format == GST_VIDEO_FORMAT_UNKNOWN) {
 270       GST_WARNING_OBJECT (self, "Failed to get format for internal pool");
 271       return NULL;
 272     }
 273
 274     self->preferred_format = format;
 275   }
 276
 277   gst_video_info_set_format (&info, self->preferred_format, width, height);
 278
 279   caps = gst_video_info_to_caps (&info);
 280   if (!caps) {
 281     GST_WARNING_OBJECT (self, "Failed to create caps for internal pool");
 282     return NULL;
 283   }
 284
 285   gst_caps_set_features_simple (caps,
 286       gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_VA));
 287
 288   surface_formats = gst_va_decoder_get_surface_formats (base->decoder);
 289   allocator = gst_va_allocator_new (base->display, surface_formats);
 290
 291   pool = gst_va_pool_new_with_config (caps, GST_VIDEO_INFO_SIZE (&info),
 292       1, 0, VA_SURFACE_ATTRIB_USAGE_HINT_DECODER, GST_VA_FEATURE_AUTO,
 293       allocator, &params);
 294
 295   gst_clear_caps (&caps);
 296   gst_object_unref (allocator);
 297
 298   if (!pool) {
 299     GST_WARNING_OBJECT (self, "Failed to create internal pool");
 300     return NULL;
 301   }
 302
 303   if (!gst_buffer_pool_set_active (pool, TRUE)) {
 304     GST_WARNING_OBJECT (self, "Failed to activate internal pool");
 305     gst_object_unref (pool);
 306     return NULL;
 307   }
 308
 309   return pool;
 310 }
 311
 312 static GstFlowReturn
 313 gst_va_av1_dec_new_sequence (GstAV1Decoder * decoder,
 314     const GstAV1SequenceHeaderOBU * seq_hdr, gint max_dpb_size)
 315 {
 316   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 317   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 318   GstVideoInfo *info = &base->output_info;
 319   VAProfile profile;
 320   guint rt_format;
 321   gint width, height;
 322
 323   GST_LOG_OBJECT (self, "new sequence");
 324
 325   profile = _get_profile (self, seq_hdr);
 326   if (profile == VAProfileNone)
 327     return GST_FLOW_NOT_NEGOTIATED;
 328
 329   rt_format = _get_rtformat (self, profile, seq_hdr);
 330   if (!rt_format)
 331     return GST_FLOW_NOT_NEGOTIATED;
 332
 333   self->seq = *seq_hdr;
 334
 335   width = seq_hdr->max_frame_width_minus_1 + 1;
 336   height = seq_hdr->max_frame_height_minus_1 + 1;
 337
 338   if (!gst_va_decoder_config_is_equal (base->decoder, profile,
 339           rt_format, width, height)) {
 340     _clear_internal_pool (self);
 341     self->preferred_format = GST_VIDEO_FORMAT_UNKNOWN;
 342
 343     base->profile = profile;
 344     base->rt_format = rt_format;
 345     GST_VIDEO_INFO_WIDTH (info) = base->width = width;
 346     GST_VIDEO_INFO_HEIGHT (info) = base->height = height;
 347     base->need_negotiation = TRUE;
 348     base->min_buffers = 7 + 4;  /* dpb size + scratch surfaces */
 349     base->need_valign = FALSE;
 350   }
 351
 352   g_clear_pointer (&base->input_state, gst_video_codec_state_unref);
 353   base->input_state = gst_video_codec_state_ref (decoder->input_state);
 354
 355   return GST_FLOW_OK;
 356 }
 357
 358 static inline GstFlowReturn
 359 _acquire_internal_buffer (GstVaAV1Dec * self, GstVideoCodecFrame * frame)
 360 {
 361   GstVaBaseDec *base = GST_VA_BASE_DEC (self);
 362   GstFlowReturn ret;
 363
 364   if (!self->internal_pool) {
 365     self->internal_pool =
 366         _create_internal_pool (self, base->width, base->height);
 367     if (!self->internal_pool)
 368       return GST_FLOW_ERROR;
 369   }
 370
 371   if (base->need_negotiation) {
 372     if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (self)))
 373       return GST_FLOW_NOT_NEGOTIATED;
 374   }
 375
 376   ret = gst_buffer_pool_acquire_buffer (self->internal_pool,
 377       &frame->output_buffer, NULL);
 378   if (ret != GST_FLOW_OK) {
 379     GST_WARNING_OBJECT (self,
 380         "Failed to allocated output buffer from internal pool, return %s",
 381         gst_flow_get_name (ret));
 382   }
 383
 384   return ret;
 385 }
 386
 387 static GstFlowReturn
 388 gst_va_av1_dec_new_picture (GstAV1Decoder * decoder,
 389     GstVideoCodecFrame * frame, GstAV1Picture * picture)
 390 {
 391   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 392   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 393   GstAV1FrameHeaderOBU *frame_hdr = &picture->frame_hdr;
 394   GstVaDecodePicture *pic;
 395   GstVideoInfo *info = &base->output_info;
 396   GstFlowReturn ret;
 397
 398   /* Only output the highest spatial layer. For non output pictures,
 399      we just use internal pool, then no negotiation needed. */
 400   if (picture->spatial_id < decoder->highest_spatial_layer) {
 401     ret = _acquire_internal_buffer (self, frame);
 402     if (ret != GST_FLOW_OK)
 403       return ret;
 404   } else {
 405     if (frame_hdr->upscaled_width != GST_VIDEO_INFO_WIDTH (info)
 406         || frame_hdr->frame_height != GST_VIDEO_INFO_HEIGHT (info)) {
 407       GST_VIDEO_INFO_WIDTH (info) = frame_hdr->upscaled_width;
 408       GST_VIDEO_INFO_HEIGHT (info) = frame_hdr->frame_height;
 409
 410       if (GST_VIDEO_INFO_WIDTH (info) < base->width
 411           || GST_VIDEO_INFO_HEIGHT (info) < base->height) {
 412         base->need_valign = TRUE;
 413         /* *INDENT-OFF* */
 414         base->valign = (GstVideoAlignment) {
 415           .padding_bottom = base->height - GST_VIDEO_INFO_HEIGHT (info),
 416           .padding_right = base->width - GST_VIDEO_INFO_WIDTH (info),
 417         };
 418         /* *INDENT-ON* */
 419       }
 420
 421       base->need_negotiation = TRUE;
 422     }
 423
 424     ret = gst_va_base_dec_prepare_output_frame (base, frame);
 425     if (ret != GST_FLOW_OK) {
 426       GST_WARNING_OBJECT (self, "Failed to allocated output buffer, return %s",
 427           gst_flow_get_name (ret));
 428       return ret;
 429     }
 430   }
 431
 432   if (picture->apply_grain) {
 433     if (!gst_va_buffer_create_aux_surface (frame->output_buffer)) {
 434       GST_WARNING_OBJECT (self,
 435           "Failed to allocated aux surface for buffer %p",
 436           frame->output_buffer);
 437       return GST_FLOW_ERROR;
 438     }
 439   }
 440
 441   pic = gst_va_decode_picture_new (base->decoder, frame->output_buffer);
 442
 443   gst_av1_picture_set_user_data (picture, pic,
 444       (GDestroyNotify) gst_va_decode_picture_free);
 445
 446   if (picture->apply_grain) {
 447     GST_LOG_OBJECT (self, "New va decode picture %p - %#x(aux: %#x)", pic,
 448         gst_va_decode_picture_get_surface (pic),
 449         gst_va_decode_picture_get_aux_surface (pic));
 450   } else {
 451     GST_LOG_OBJECT (self, "New va decode picture %p - %#x", pic,
 452         gst_va_decode_picture_get_surface (pic));
 453   }
 454
 455   return GST_FLOW_OK;
 456 }
 457
 458 static GstAV1Picture *
 459 gst_va_av1_dec_duplicate_picture (GstAV1Decoder * decoder,
 460     GstVideoCodecFrame * frame, GstAV1Picture * picture)
 461 {
 462   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 463   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 464   GstVaDecodePicture *pic;
 465   GstVaDecodePicture *new_pic;
 466   GstAV1Picture *new_picture;
 467
 468   pic = gst_av1_picture_get_user_data (picture);
 469   if (!pic) {
 470     GST_ERROR_OBJECT (self, "Parent picture does not have a va picture");
 471     return NULL;
 472   }
 473
 474   new_picture = gst_av1_picture_new ();
 475   g_assert (pic->gstbuffer);
 476   new_pic = gst_va_decode_picture_new (base->decoder, pic->gstbuffer);
 477
 478   GST_LOG_OBJECT (self, "Duplicate output with buffer %" GST_PTR_FORMAT
 479       " (surface %#x)", pic, gst_va_decode_picture_get_surface (pic));
 480
 481   gst_av1_picture_set_user_data (new_picture, new_pic,
 482       (GDestroyNotify) gst_va_decode_picture_free);
 483
 484   return new_picture;
 485 }
 486
 487 static void
 488 _setup_segment_info (VADecPictureParameterBufferAV1 * pic_param,
 489     GstAV1FrameHeaderOBU * frame_header)
 490 {
 491   guint i, j;
 492   uint8_t feature_mask;
 493
 494   for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++)
 495     for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++)
 496       pic_param->seg_info.feature_data[i][j] =
 497           frame_header->segmentation_params.feature_data[i][j];
 498
 499   for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
 500     feature_mask = 0;
 501     for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
 502       if (frame_header->segmentation_params.feature_enabled[i][j])
 503         feature_mask |= 1 << j;
 504     }
 505     pic_param->seg_info.feature_mask[i] = feature_mask;
 506   }
 507 }
 508
 509 static void
 510 _setup_film_grain_info (VADecPictureParameterBufferAV1 * pic_param,
 511     GstAV1FrameHeaderOBU * frame_header)
 512 {
 513   guint i;
 514
 515   if (!frame_header->film_grain_params.apply_grain)
 516     return;
 517
 518   pic_param->film_grain_info.num_y_points =
 519       frame_header->film_grain_params.num_y_points;
 520   for (i = 0; i < frame_header->film_grain_params.num_y_points; i++) {
 521     pic_param->film_grain_info.point_y_value[i] =
 522         frame_header->film_grain_params.point_y_value[i];
 523     pic_param->film_grain_info.point_y_scaling[i] =
 524         frame_header->film_grain_params.point_y_scaling[i];
 525   }
 526
 527   pic_param->film_grain_info.num_cb_points =
 528       frame_header->film_grain_params.num_cb_points;
 529   for (i = 0; i < frame_header->film_grain_params.num_cb_points; i++) {
 530     pic_param->film_grain_info.point_cb_value[i] =
 531         frame_header->film_grain_params.point_cb_value[i];
 532     pic_param->film_grain_info.point_cb_scaling[i] =
 533         frame_header->film_grain_params.point_cb_scaling[i];
 534   }
 535
 536   pic_param->film_grain_info.num_cr_points =
 537       frame_header->film_grain_params.num_cr_points;
 538   for (i = 0; i < frame_header->film_grain_params.num_cr_points; i++) {
 539     pic_param->film_grain_info.point_cr_value[i] =
 540         frame_header->film_grain_params.point_cr_value[i];
 541     pic_param->film_grain_info.point_cr_scaling[i] =
 542         frame_header->film_grain_params.point_cr_scaling[i];
 543   }
 544
 545
 546   if (pic_param->film_grain_info.num_y_points) {
 547     for (i = 0; i < 24; i++) {
 548       pic_param->film_grain_info.ar_coeffs_y[i] =
 549           frame_header->film_grain_params.ar_coeffs_y_plus_128[i] - 128;
 550     }
 551   }
 552   if (frame_header->film_grain_params.chroma_scaling_from_luma
 553       || pic_param->film_grain_info.num_cb_points) {
 554     for (i = 0; i < GST_AV1_MAX_NUM_POS_LUMA; i++) {
 555       pic_param->film_grain_info.ar_coeffs_cb[i] =
 556           frame_header->film_grain_params.ar_coeffs_cb_plus_128[i] - 128;
 557     }
 558   }
 559   if (frame_header->film_grain_params.chroma_scaling_from_luma
 560       || pic_param->film_grain_info.num_cr_points) {
 561     for (i = 0; i < GST_AV1_MAX_NUM_POS_LUMA; i++) {
 562       pic_param->film_grain_info.ar_coeffs_cr[i] =
 563           frame_header->film_grain_params.ar_coeffs_cr_plus_128[i] - 128;
 564     }
 565   }
 566 }
 567
 568 static void
 569 _setup_loop_filter_info (VADecPictureParameterBufferAV1 * pic_param,
 570     GstAV1FrameHeaderOBU * frame_header)
 571 {
 572   guint i;
 573
 574   pic_param->filter_level[0] =
 575       frame_header->loop_filter_params.loop_filter_level[0];
 576   pic_param->filter_level[1] =
 577       frame_header->loop_filter_params.loop_filter_level[1];
 578   pic_param->filter_level_u =
 579       frame_header->loop_filter_params.loop_filter_level[2];
 580   pic_param->filter_level_v =
 581       frame_header->loop_filter_params.loop_filter_level[3];
 582
 583   for (i = 0; i < GST_AV1_TOTAL_REFS_PER_FRAME; i++)
 584     pic_param->ref_deltas[i] =
 585         frame_header->loop_filter_params.loop_filter_ref_deltas[i];
 586   for (i = 0; i < 2; i++)
 587     pic_param->mode_deltas[i] =
 588         frame_header->loop_filter_params.loop_filter_mode_deltas[i];
 589 }
 590
 591 static void
 592 _setup_quantization_info (VADecPictureParameterBufferAV1 * pic_param,
 593     GstAV1FrameHeaderOBU * frame_header)
 594 {
 595   pic_param->qmatrix_fields.bits.using_qmatrix =
 596       frame_header->quantization_params.using_qmatrix;
 597   if (frame_header->quantization_params.using_qmatrix) {
 598     pic_param->qmatrix_fields.bits.qm_y =
 599         frame_header->quantization_params.qm_y;
 600     pic_param->qmatrix_fields.bits.qm_u =
 601         frame_header->quantization_params.qm_u;
 602     pic_param->qmatrix_fields.bits.qm_v =
 603         frame_header->quantization_params.qm_v;
 604   } else {
 605     pic_param->qmatrix_fields.bits.qm_y = 0;
 606     pic_param->qmatrix_fields.bits.qm_u = 0;
 607     pic_param->qmatrix_fields.bits.qm_v = 0;
 608   }
 609 }
 610
 611 static void
 612 _setup_cdef_info (VADecPictureParameterBufferAV1 * pic_param,
 613     GstAV1FrameHeaderOBU * frame_header, guint8 num_planes)
 614 {
 615   guint8 sec_strength;
 616   guint i;
 617
 618   pic_param->cdef_damping_minus_3 = frame_header->cdef_params.cdef_damping - 3;
 619   pic_param->cdef_bits = frame_header->cdef_params.cdef_bits;
 620   for (i = 0; i < GST_AV1_CDEF_MAX; i++) {
 621     sec_strength = frame_header->cdef_params.cdef_y_sec_strength[i];
 622     g_assert (sec_strength <= 4);
 623     /* may need to minus 1 in order to merge with primary value. */
 624     if (sec_strength == 4)
 625       sec_strength--;
 626
 627     pic_param->cdef_y_strengths[i] =
 628         ((frame_header->cdef_params.cdef_y_pri_strength[i] & 0xf) << 2) |
 629         (sec_strength & 0x03);
 630   }
 631   if (num_planes > 1) {
 632     for (i = 0; i < GST_AV1_CDEF_MAX; i++) {
 633       sec_strength = frame_header->cdef_params.cdef_uv_sec_strength[i];
 634       g_assert (sec_strength <= 4);
 635       /* may need to minus 1 in order to merge with primary value. */
 636       if (sec_strength == 4)
 637         sec_strength--;
 638
 639       pic_param->cdef_uv_strengths[i] =
 640           ((frame_header->cdef_params.cdef_uv_pri_strength[i] & 0xf) << 2) |
 641           (sec_strength & 0x03);
 642     }
 643   } else {
 644     for (i = 0; i < GST_AV1_CDEF_MAX; i++) {
 645       pic_param->cdef_uv_strengths[i] = 0;
 646     }
 647   }
 648 }
 649
 650 static void
 651 _setup_global_motion_info (VADecPictureParameterBufferAV1 * pic_param,
 652     GstAV1FrameHeaderOBU * frame_header)
 653 {
 654   guint i, j;
 655
 656   for (i = 0; i < 7; i++) {
 657     /* assuming VAAV1TransformationType and GstAV1WarpModelType are
 658      * equivalent */
 659     pic_param->wm[i].wmtype = (VAAV1TransformationType)
 660         frame_header->global_motion_params.gm_type[GST_AV1_REF_LAST_FRAME + i];
 661
 662     for (j = 0; j < 6; j++)
 663       pic_param->wm[i].wmmat[j] =
 664           frame_header->global_motion_params.gm_params
 665           [GST_AV1_REF_LAST_FRAME + i][j];
 666
 667     pic_param->wm[i].wmmat[6] = 0;
 668     pic_param->wm[i].wmmat[7] = 0;
 669
 670     pic_param->wm[i].invalid =
 671         frame_header->global_motion_params.invalid[GST_AV1_REF_LAST_FRAME + i];
 672   }
 673 }
 674
 675 static GstFlowReturn
 676 gst_va_av1_dec_start_picture (GstAV1Decoder * decoder, GstAV1Picture * picture,
 677     GstAV1Dpb * dpb)
 678 {
 679   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 680   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 681   GstAV1FrameHeaderOBU *frame_header = &picture->frame_hdr;
 682   GstAV1SequenceHeaderOBU *seq_header = &self->seq;
 683   VADecPictureParameterBufferAV1 pic_param = { };
 684   GstVaDecodePicture *va_pic;
 685   guint i;
 686
 687   va_pic = gst_av1_picture_get_user_data (picture);
 688   g_assert (va_pic);
 689
 690   /* *INDENT-OFF* */
 691   pic_param = (VADecPictureParameterBufferAV1){
 692     .profile = seq_header->seq_profile,
 693     .order_hint_bits_minus_1 = seq_header->order_hint_bits_minus_1,
 694     .matrix_coefficients = seq_header->color_config.matrix_coefficients,
 695     .seq_info_fields.fields = {
 696       .still_picture = seq_header->still_picture,
 697       .use_128x128_superblock = seq_header->use_128x128_superblock,
 698       .enable_filter_intra = seq_header->enable_filter_intra,
 699       .enable_intra_edge_filter = seq_header->enable_intra_edge_filter,
 700       .enable_interintra_compound = seq_header->enable_interintra_compound,
 701       .enable_masked_compound = seq_header->enable_masked_compound,
 702       .enable_dual_filter = seq_header->enable_dual_filter,
 703       .enable_order_hint = seq_header->enable_order_hint,
 704       .enable_jnt_comp = seq_header->enable_jnt_comp,
 705       .enable_cdef = seq_header->enable_cdef,
 706       .mono_chrome = seq_header->color_config.mono_chrome,
 707       .color_range = seq_header->color_config.color_range,
 708       .subsampling_x = seq_header->color_config.subsampling_x,
 709       .subsampling_y = seq_header->color_config.subsampling_y,
 710       .film_grain_params_present = seq_header->film_grain_params_present,
 711     },
 712     .anchor_frames_num = 0,
 713     .anchor_frames_list = NULL,
 714     .frame_width_minus1 = frame_header->upscaled_width - 1,
 715     .frame_height_minus1 = frame_header->frame_height - 1,
 716     .output_frame_width_in_tiles_minus_1 = 0,
 717     .output_frame_height_in_tiles_minus_1 = 0,
 718     .order_hint = frame_header->order_hint,
 719     /* Segmentation */
 720     .seg_info.segment_info_fields.bits = {
 721       .enabled = frame_header->segmentation_params.segmentation_enabled,
 722       .update_map = frame_header->segmentation_params.segmentation_update_map,
 723       .temporal_update =
 724         frame_header->segmentation_params.segmentation_temporal_update,
 725       .update_data =
 726         frame_header->segmentation_params.segmentation_update_data,
 727     },
 728     /* FilmGrain */
 729     .film_grain_info = {
 730       .film_grain_info_fields.bits = {
 731         .apply_grain = frame_header->film_grain_params.apply_grain,
 732         .chroma_scaling_from_luma =
 733           frame_header->film_grain_params.chroma_scaling_from_luma,
 734         .grain_scaling_minus_8 =
 735           frame_header->film_grain_params.grain_scaling_minus_8,
 736         .ar_coeff_lag = frame_header->film_grain_params.ar_coeff_lag,
 737         .ar_coeff_shift_minus_6 =
 738           frame_header->film_grain_params.ar_coeff_shift_minus_6,
 739         .grain_scale_shift = frame_header->film_grain_params.grain_scale_shift,
 740         .overlap_flag = frame_header->film_grain_params.overlap_flag,
 741         .clip_to_restricted_range =
 742           frame_header->film_grain_params.clip_to_restricted_range,
 743       },
 744       .grain_seed = frame_header->film_grain_params.grain_seed,
 745       .cb_mult = frame_header->film_grain_params.cb_mult,
 746       .cb_luma_mult = frame_header->film_grain_params.cb_luma_mult,
 747       .cb_offset = frame_header->film_grain_params.cb_offset,
 748       .cr_mult = frame_header->film_grain_params.cr_mult,
 749       .cr_luma_mult = frame_header->film_grain_params.cr_luma_mult,
 750       .cr_offset = frame_header->film_grain_params.cr_offset,
 751     },
 752     .tile_cols = frame_header->tile_info.tile_cols,
 753     .tile_rows = frame_header->tile_info.tile_rows,
 754     .context_update_tile_id = frame_header->tile_info.context_update_tile_id,
 755     .pic_info_fields.bits = {
 756       .frame_type = frame_header->frame_type,
 757       .show_frame = frame_header->show_frame,
 758       .showable_frame = frame_header->showable_frame,
 759       .error_resilient_mode = frame_header->error_resilient_mode,
 760       .disable_cdf_update = frame_header->disable_cdf_update,
 761       .allow_screen_content_tools = frame_header->allow_screen_content_tools,
 762       .force_integer_mv = frame_header->force_integer_mv,
 763       .allow_intrabc = frame_header->allow_intrabc,
 764       .use_superres = frame_header->use_superres,
 765       .allow_high_precision_mv = frame_header->allow_high_precision_mv,
 766       .is_motion_mode_switchable = frame_header->is_motion_mode_switchable,
 767       .use_ref_frame_mvs = frame_header->use_ref_frame_mvs,
 768       .disable_frame_end_update_cdf =
 769         frame_header->disable_frame_end_update_cdf,
 770       .uniform_tile_spacing_flag =
 771         frame_header->tile_info.uniform_tile_spacing_flag,
 772       .allow_warped_motion = frame_header->allow_warped_motion,
 773     },
 774     .superres_scale_denominator = frame_header->superres_denom,
 775     .interp_filter = frame_header->interpolation_filter,
 776     /* loop filter */
 777     .loop_filter_info_fields.bits = {
 778       .sharpness_level =
 779         frame_header->loop_filter_params.loop_filter_sharpness,
 780       .mode_ref_delta_enabled =
 781         frame_header->loop_filter_params.loop_filter_delta_enabled,
 782       .mode_ref_delta_update =
 783         frame_header->loop_filter_params.loop_filter_delta_update,
 784     },
 785     .mode_control_fields.bits = {
 786       .delta_lf_present_flag =
 787         frame_header->loop_filter_params.delta_lf_present,
 788       .log2_delta_lf_res = frame_header->loop_filter_params.delta_lf_res,
 789       .delta_lf_multi = frame_header->loop_filter_params.delta_lf_multi,
 790       .delta_q_present_flag =
 791         frame_header->quantization_params.delta_q_present,
 792       .log2_delta_q_res = frame_header->quantization_params.delta_q_res,
 793       .tx_mode = frame_header->tx_mode,
 794       .reference_select = frame_header->reference_select,
 795       .reduced_tx_set_used = frame_header->reduced_tx_set,
 796       .skip_mode_present = frame_header->skip_mode_present,
 797     },
 798     /* quantization */
 799     .base_qindex = frame_header->quantization_params.base_q_idx,
 800     .y_dc_delta_q = frame_header->quantization_params.delta_q_y_dc,
 801     .u_dc_delta_q = frame_header->quantization_params.delta_q_u_dc,
 802     .u_ac_delta_q = frame_header->quantization_params.delta_q_u_ac,
 803     .v_dc_delta_q = frame_header->quantization_params.delta_q_v_dc,
 804     .v_ac_delta_q = frame_header->quantization_params.delta_q_v_ac,
 805     /* loop restoration */
 806     .loop_restoration_fields.bits = {
 807       .yframe_restoration_type =
 808         frame_header->loop_restoration_params.frame_restoration_type[0],
 809       .cbframe_restoration_type =
 810         frame_header->loop_restoration_params.frame_restoration_type[1],
 811       .crframe_restoration_type =
 812         frame_header->loop_restoration_params.frame_restoration_type[2],
 813       .lr_unit_shift = frame_header->loop_restoration_params.lr_unit_shift,
 814       .lr_uv_shift = frame_header->loop_restoration_params.lr_uv_shift,
 815     },
 816   };
 817   /* *INDENT-ON* */
 818
 819   if (seq_header->bit_depth == 8) {
 820     pic_param.bit_depth_idx = 0;
 821   } else if (seq_header->bit_depth == 10) {
 822     pic_param.bit_depth_idx = 1;
 823   } else if (seq_header->bit_depth == 12) {
 824     pic_param.bit_depth_idx = 2;
 825   } else {
 826     g_assert_not_reached ();
 827   }
 828
 829   if (frame_header->film_grain_params.apply_grain) {
 830     pic_param.current_frame = gst_va_decode_picture_get_aux_surface (va_pic);
 831     pic_param.current_display_picture =
 832         gst_va_decode_picture_get_surface (va_pic);
 833   } else {
 834     pic_param.current_frame = gst_va_decode_picture_get_surface (va_pic);
 835     pic_param.current_display_picture = VA_INVALID_SURFACE;
 836   }
 837
 838   for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
 839     if (dpb->pic_list[i]) {
 840       if (dpb->pic_list[i]->apply_grain) {
 841         pic_param.ref_frame_map[i] = gst_va_decode_picture_get_aux_surface
 842             (gst_av1_picture_get_user_data (dpb->pic_list[i]));
 843       } else {
 844         pic_param.ref_frame_map[i] = gst_va_decode_picture_get_surface
 845             (gst_av1_picture_get_user_data (dpb->pic_list[i]));
 846       }
 847     } else {
 848       pic_param.ref_frame_map[i] = VA_INVALID_SURFACE;
 849     }
 850   }
 851   for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
 852     pic_param.ref_frame_idx[i] = frame_header->ref_frame_idx[i];
 853   }
 854   pic_param.primary_ref_frame = frame_header->primary_ref_frame;
 855
 856   _setup_segment_info (&pic_param, frame_header);
 857   _setup_film_grain_info (&pic_param, frame_header);
 858
 859   for (i = 0; i < 63; i++) {
 860     pic_param.width_in_sbs_minus_1[i] =
 861         frame_header->tile_info.width_in_sbs_minus_1[i];
 862     pic_param.height_in_sbs_minus_1[i] =
 863         frame_header->tile_info.height_in_sbs_minus_1[i];
 864   }
 865
 866   _setup_loop_filter_info (&pic_param, frame_header);
 867   _setup_quantization_info (&pic_param, frame_header);
 868   _setup_cdef_info (&pic_param, frame_header, seq_header->num_planes);
 869   _setup_global_motion_info (&pic_param, frame_header);
 870
 871   if (!gst_va_decoder_add_param_buffer (base->decoder, va_pic,
 872           VAPictureParameterBufferType, &pic_param, sizeof (pic_param)))
 873     return GST_FLOW_ERROR;
 874
 875   return GST_FLOW_OK;
 876 }
 877
 878 static GstFlowReturn
 879 gst_va_av1_dec_decode_tile (GstAV1Decoder * decoder, GstAV1Picture * picture,
 880     GstAV1Tile * tile)
 881 {
 882   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 883   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 884   GstAV1TileGroupOBU *tile_group = &tile->tile_group;
 885   GstVaDecodePicture *va_pic;
 886   guint i;
 887   VASliceParameterBufferAV1 slice_param[GST_AV1_MAX_TILE_COUNT];
 888
 889   GST_TRACE_OBJECT (self, "-");
 890
 891   for (i = 0; i < tile_group->tg_end - tile_group->tg_start + 1; i++) {
 892     slice_param[i] = (VASliceParameterBufferAV1) {
 893     };
 894     slice_param[i].slice_data_size =
 895         tile_group->entry[tile_group->tg_start + i].tile_size;
 896     slice_param[i].slice_data_offset =
 897         tile_group->entry[tile_group->tg_start + i].tile_offset;
 898     slice_param[i].tile_row =
 899         tile_group->entry[tile_group->tg_start + i].tile_row;
 900     slice_param[i].tile_column =
 901         tile_group->entry[tile_group->tg_start + i].tile_col;
 902     slice_param[i].slice_data_flag = 0;
 903   }
 904
 905   va_pic = gst_av1_picture_get_user_data (picture);
 906
 907   if (!gst_va_decoder_add_slice_buffer_with_n_params (base->decoder, va_pic,
 908           slice_param, sizeof (VASliceParameterBufferAV1), i, tile->obu.data,
 909           tile->obu.obu_size)) {
 910     return GST_FLOW_ERROR;
 911   }
 912
 913   return GST_FLOW_OK;
 914 }
 915
 916 static GstFlowReturn
 917 gst_va_av1_dec_end_picture (GstAV1Decoder * decoder, GstAV1Picture * picture)
 918 {
 919   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 920   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 921   GstVaDecodePicture *va_pic;
 922
 923   GST_LOG_OBJECT (self, "end picture %p, (system_frame_number %d)",
 924       picture, picture->system_frame_number);
 925
 926   va_pic = gst_av1_picture_get_user_data (picture);
 927
 928   if (!gst_va_decoder_decode_with_aux_surface (base->decoder, va_pic,
 929           picture->apply_grain)) {
 930     return GST_FLOW_ERROR;
 931   }
 932
 933   return GST_FLOW_OK;
 934 }
 935
 936 static GstFlowReturn
 937 gst_va_av1_dec_output_picture (GstAV1Decoder * decoder,
 938     GstVideoCodecFrame * frame, GstAV1Picture * picture)
 939 {
 940   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 941   GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
 942   GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
 943   gboolean ret;
 944
 945   g_assert (picture->frame_hdr.show_frame ||
 946       picture->frame_hdr.show_existing_frame);
 947
 948   GST_LOG_OBJECT (self,
 949       "Outputting picture %p (system_frame_number %d)",
 950       picture, picture->system_frame_number);
 951
 952   if (picture->frame_hdr.show_existing_frame) {
 953     GstVaDecodePicture *pic;
 954
 955     g_assert (!frame->output_buffer);
 956     pic = gst_av1_picture_get_user_data (picture);
 957     frame->output_buffer = gst_buffer_ref (pic->gstbuffer);
 958   }
 959
 960   ret = gst_va_base_dec_process_output (base, frame, picture->discont_state, 0);
 961   gst_av1_picture_unref (picture);
 962
 963   if (ret)
 964     return gst_video_decoder_finish_frame (vdec, frame);
 965   return GST_FLOW_ERROR;
 966 }
 967
 968 static gboolean
 969 gst_va_av1_dec_start (GstVideoDecoder * decoder)
 970 {
 971   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 972
 973   self->preferred_format = GST_VIDEO_FORMAT_UNKNOWN;
 974
 975   return GST_VIDEO_DECODER_CLASS (parent_class)->start (decoder);
 976 }
 977
 978 static gboolean
 979 gst_va_av1_dec_close (GstVideoDecoder * decoder)
 980 {
 981   GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
 982
 983   _clear_internal_pool (self);
 984
 985   return gst_va_base_dec_close (GST_VIDEO_DECODER (decoder));
 986 }
 987
 988 static void
 989 gst_va_av1_dec_init (GTypeInstance * instance, gpointer g_class)
 990 {
 991   gst_va_base_dec_init (GST_VA_BASE_DEC (instance), GST_CAT_DEFAULT);
 992 }
 993
 994 static void
 995 gst_va_av1_dec_dispose (GObject * object)
 996 {
 997   gst_va_base_dec_close (GST_VIDEO_DECODER (object));
 998   G_OBJECT_CLASS (parent_class)->dispose (object);
 999 }
1000
1001 static void
1002 gst_va_av1_dec_class_init (gpointer g_class, gpointer class_data)
1003 {
1004   GstCaps *src_doc_caps, *sink_doc_caps;
1005   GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
1006   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
1007   GstAV1DecoderClass *av1decoder_class = GST_AV1_DECODER_CLASS (g_class);
1008   GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_CLASS (g_class);
1009   struct CData *cdata = class_data;
1010   gchar *long_name;
1011
1012   if (cdata->description) {
1013     long_name = g_strdup_printf ("VA-API AV1 Decoder in %s",
1014         cdata->description);
1015   } else {
1016     long_name = g_strdup ("VA-API AV1 Decoder");
1017   }
1018
1019   gst_element_class_set_metadata (element_class, long_name,
1020       "Codec/Decoder/Video/Hardware",
1021       "VA-API based AV1 video decoder", "He Junyan <junyan.he@intel.com>");
1022
1023   sink_doc_caps = gst_caps_from_string (sink_caps_str);
1024   src_doc_caps = gst_caps_from_string (src_caps_str);
1025
1026   parent_class = g_type_class_peek_parent (g_class);
1027
1028   /**
1029    * GstVaAV1Dec:device-path:
1030    *
1031    * It shows the DRM device path used for the VA operation, if any.
1032    *
1033    * Since: 1.22
1034    */
1035   gst_va_base_dec_class_init (GST_VA_BASE_DEC_CLASS (g_class), AV1,
1036       cdata->render_device_path, cdata->sink_caps, cdata->src_caps,
1037       src_doc_caps, sink_doc_caps);
1038
1039   gobject_class->dispose = gst_va_av1_dec_dispose;
1040
1041   decoder_class->getcaps = GST_DEBUG_FUNCPTR (gst_va_av1_dec_getcaps);
1042   decoder_class->negotiate = GST_DEBUG_FUNCPTR (gst_va_av1_dec_negotiate);
1043   decoder_class->close = GST_DEBUG_FUNCPTR (gst_va_av1_dec_close);
1044   decoder_class->start = GST_DEBUG_FUNCPTR (gst_va_av1_dec_start);
1045
1046   av1decoder_class->new_sequence =
1047       GST_DEBUG_FUNCPTR (gst_va_av1_dec_new_sequence);
1048   av1decoder_class->new_picture =
1049       GST_DEBUG_FUNCPTR (gst_va_av1_dec_new_picture);
1050   av1decoder_class->duplicate_picture =
1051       GST_DEBUG_FUNCPTR (gst_va_av1_dec_duplicate_picture);
1052   av1decoder_class->start_picture =
1053       GST_DEBUG_FUNCPTR (gst_va_av1_dec_start_picture);
1054   av1decoder_class->decode_tile =
1055       GST_DEBUG_FUNCPTR (gst_va_av1_dec_decode_tile);
1056   av1decoder_class->end_picture =
1057       GST_DEBUG_FUNCPTR (gst_va_av1_dec_end_picture);
1058   av1decoder_class->output_picture =
1059       GST_DEBUG_FUNCPTR (gst_va_av1_dec_output_picture);
1060
1061   g_free (long_name);
1062   g_free (cdata->description);
1063   g_free (cdata->render_device_path);
1064   gst_caps_unref (cdata->src_caps);
1065   gst_caps_unref (cdata->sink_caps);
1066   g_free (cdata);
1067 }
1068
1069 static gpointer
1070 _register_debug_category (gpointer data)
1071 {
1072   GST_DEBUG_CATEGORY_INIT (gst_va_av1dec_debug, "vaav1dec", 0,
1073       "VA AV1 decoder");
1074
1075   return NULL;
1076 }
1077
1078 gboolean
1079 gst_va_av1_dec_register (GstPlugin * plugin, GstVaDevice * device,
1080     GstCaps * sink_caps, GstCaps * src_caps, guint rank)
1081 {
1082   static GOnce debug_once = G_ONCE_INIT;
1083   GType type;
1084   GTypeInfo type_info = {
1085     .class_size = sizeof (GstVaAV1DecClass),
1086     .class_init = gst_va_av1_dec_class_init,
1087     .instance_size = sizeof (GstVaAV1Dec),
1088     .instance_init = gst_va_av1_dec_init,
1089   };
1090   struct CData *cdata;
1091   gboolean ret;
1092   gchar *type_name, *feature_name;
1093
1094   g_return_val_if_fail (GST_IS_PLUGIN (plugin), FALSE);
1095   g_return_val_if_fail (GST_IS_VA_DEVICE (device), FALSE);
1096   g_return_val_if_fail (GST_IS_CAPS (sink_caps), FALSE);
1097   g_return_val_if_fail (GST_IS_CAPS (src_caps), FALSE);
1098
1099   cdata = g_new (struct CData, 1);
1100   cdata->description = NULL;
1101   cdata->render_device_path = g_strdup (device->render_device_path);
1102   cdata->sink_caps = _complete_sink_caps (sink_caps);
1103   cdata->src_caps = gst_caps_ref (src_caps);
1104
1105   /* class data will be leaked if the element never gets instantiated */
1106   GST_MINI_OBJECT_FLAG_SET (cdata->sink_caps,
1107       GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
1108   GST_MINI_OBJECT_FLAG_SET (src_caps, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
1109
1110   type_info.class_data = cdata;
1111
1112   /* The first decoder to be registered should use a constant name,
1113    * like vaav1dec, for any additional decoders, we create unique
1114    * names, using inserting the render device name. */
1115   if (device->index == 0) {
1116     type_name = g_strdup ("GstVaAV1Dec");
1117     feature_name = g_strdup ("vaav1dec");
1118   } else {
1119     gchar *basename = g_path_get_basename (device->render_device_path);
1120     type_name = g_strdup_printf ("GstVa%sAV1Dec", basename);
1121     feature_name = g_strdup_printf ("va%sav1dec", basename);
1122     cdata->description = basename;
1123
1124     /* lower rank for non-first device */
1125     if (rank > 0)
1126       rank--;
1127   }
1128
1129   g_once (&debug_once, _register_debug_category, NULL);
1130
1131   type = g_type_register_static (GST_TYPE_AV1_DECODER,
1132       type_name, &type_info, 0);
1133
1134   ret = gst_element_register (plugin, feature_name, rank, type);
1135
1136   g_free (type_name);
1137   g_free (feature_name);
1138
1139   return ret;
1140 }