gst/vaapi/gstvaapidecode.c

   1 /*
   2  *  gstvaapidecode.c - VA-API video decoder
   3  *
   4  *  Copyright (C) 2010-2011 Splitted-Desktop Systems
   5  *    Author: Gwenole Beauchesne <gwenole.beauchesne@splitted-desktop.com>
   6  *  Copyright (C) 2011-2014 Intel Corporation
   7  *    Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
   8  *
   9  *  This library is free software; you can redistribute it and/or
  10  *  modify it under the terms of the GNU Lesser General Public License
  11  *  as published by the Free Software Foundation; either version 2.1
  12  *  of the License, or (at your option) any later version.
  13  *
  14  *  This library is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  Lesser General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU Lesser General Public
  20  *  License along with this library; if not, write to the Free
  21  *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  *  Boston, MA 02110-1301 USA
  23 */
  24
  25 /**
  26  * SECTION:gstvaapidecode
  27  * @short_description: A VA-API based video decoder
  28  *
  29  * vaapidecode decodes from raw bitstreams to surfaces suitable for
  30  * the vaapisink element.
  31  */
  32
  33 #include "gst/vaapi/sysdeps.h"
  34 #include <gst/vaapi/gstvaapidisplay.h>
  35
  36 #include "gstvaapidecode.h"
  37 #include "gstvaapipluginutil.h"
  38 #include "gstvaapivideobuffer.h"
  39 #if GST_CHECK_VERSION(1,1,0) && USE_GLX
  40 #include "gstvaapivideometa_texture.h"
  41 #endif
  42 #if GST_CHECK_VERSION(1,0,0)
  43 #include "gstvaapivideobufferpool.h"
  44 #include "gstvaapivideomemory.h"
  45 #endif
  46
  47 #include <gst/vaapi/gstvaapidecoder_h264.h>
  48 #include <gst/vaapi/gstvaapidecoder_jpeg.h>
  49 #include <gst/vaapi/gstvaapidecoder_mpeg2.h>
  50 #include <gst/vaapi/gstvaapidecoder_mpeg4.h>
  51 #include <gst/vaapi/gstvaapidecoder_vc1.h>
  52 #include <gst/vaapi/gstvaapidecoder_vp8.h>
  53
  54 #define GST_PLUGIN_NAME "vaapidecode"
  55 #define GST_PLUGIN_DESC "A VA-API based video decoder"
  56
  57 #define GST_VAAPI_DECODE_FLOW_PARSE_DATA        GST_FLOW_CUSTOM_SUCCESS_2
  58
  59 GST_DEBUG_CATEGORY_STATIC(gst_debug_vaapidecode);
  60 #define GST_CAT_DEFAULT gst_debug_vaapidecode
  61
  62 /* Default templates */
  63 #define GST_CAPS_CODEC(CODEC) CODEC "; "
  64
  65 static const char gst_vaapidecode_sink_caps_str[] =
  66     GST_CAPS_CODEC("video/mpeg, mpegversion=2, systemstream=(boolean)false")
  67     GST_CAPS_CODEC("video/mpeg, mpegversion=4")
  68     GST_CAPS_CODEC("video/x-divx")
  69     GST_CAPS_CODEC("video/x-xvid")
  70     GST_CAPS_CODEC("video/x-h263")
  71     GST_CAPS_CODEC("video/x-h264")
  72     GST_CAPS_CODEC("video/x-wmv")
  73     GST_CAPS_CODEC("video/x-vp8")
  74     GST_CAPS_CODEC("image/jpeg")
  75     ;
  76
  77 static const char gst_vaapidecode_src_caps_str[] =
  78 #if GST_CHECK_VERSION(1,1,0)
  79     GST_VIDEO_CAPS_MAKE_WITH_FEATURES(
  80         GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE, "{ ENCODED, I420, YV12, NV12 }") ";"
  81     GST_VIDEO_CAPS_MAKE_WITH_FEATURES(
  82         GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, "RGBA") ";"
  83     GST_VIDEO_CAPS_MAKE("{ I420, YV12, NV12 }");
  84 #else
  85     GST_VAAPI_SURFACE_CAPS;
  86 #endif
  87
  88 static GstStaticPadTemplate gst_vaapidecode_sink_factory =
  89     GST_STATIC_PAD_TEMPLATE(
  90         "sink",
  91         GST_PAD_SINK,
  92         GST_PAD_ALWAYS,
  93         GST_STATIC_CAPS(gst_vaapidecode_sink_caps_str));
  94
  95 static GstStaticPadTemplate gst_vaapidecode_src_factory =
  96     GST_STATIC_PAD_TEMPLATE(
  97         "src",
  98         GST_PAD_SRC,
  99         GST_PAD_ALWAYS,
 100         GST_STATIC_CAPS(gst_vaapidecode_src_caps_str));
 101
 102 G_DEFINE_TYPE_WITH_CODE(
 103     GstVaapiDecode,
 104     gst_vaapidecode,
 105     GST_TYPE_VIDEO_DECODER,
 106     GST_VAAPI_PLUGIN_BASE_INIT_INTERFACES)
 107
 108 static gboolean
 109 gst_vaapidecode_update_src_caps(GstVaapiDecode *decode,
 110     const GstVideoCodecState *ref_state);
 111
 112 static void
 113 gst_vaapi_decoder_state_changed(GstVaapiDecoder *decoder,
 114     const GstVideoCodecState *codec_state, gpointer user_data)
 115 {
 116     GstVaapiDecode * const decode = GST_VAAPIDECODE(user_data);
 117     GstVideoDecoder * const vdec = GST_VIDEO_DECODER(decode);
 118
 119     g_assert(decode->decoder == decoder);
 120
 121     gst_vaapidecode_update_src_caps(decode, codec_state);
 122     gst_video_decoder_negotiate(vdec);
 123 }
 124
 125 static inline gboolean
 126 gst_vaapidecode_update_sink_caps(GstVaapiDecode *decode, GstCaps *caps)
 127 {
 128     gst_caps_replace(&decode->sinkpad_caps, caps);
 129     return TRUE;
 130 }
 131
 132 #if GST_CHECK_VERSION(1,1,0)
 133 static void
 134 gst_vaapidecode_video_info_change_format(GstVideoInfo *info,
 135     GstVideoFormat format, guint width, guint height)
 136 {
 137     GstVideoInfo vi = *info;
 138
 139     gst_video_info_set_format (info, format, width, height);
 140
 141     info->interlace_mode = vi.interlace_mode;
 142     info->flags = vi.flags;
 143     info->views = vi.views;
 144     info->par_n = vi.par_n;
 145     info->par_d = vi.par_d;
 146     info->fps_n = vi.fps_n;
 147     info->fps_d = vi.fps_d;
 148 }
 149 #endif
 150
 151 static gboolean
 152 gst_vaapidecode_update_src_caps(GstVaapiDecode *decode,
 153     const GstVideoCodecState *ref_state)
 154 {
 155     GstVideoDecoder * const vdec = GST_VIDEO_DECODER(decode);
 156     GstVideoCodecState *state;
 157     GstVideoInfo *vi, vis;
 158     GstVideoFormat format, out_format;
 159 #if GST_CHECK_VERSION(1,1,0)
 160     GstCapsFeatures *features = NULL;
 161     GstVaapiCapsFeature feature;
 162
 163     feature = gst_vaapi_find_preferred_caps_feature(
 164         GST_VIDEO_DECODER_SRC_PAD(vdec),
 165         GST_VIDEO_INFO_FORMAT(&ref_state->info));
 166 #endif
 167
 168     format = GST_VIDEO_INFO_FORMAT(&ref_state->info);
 169
 170     state = gst_video_decoder_set_output_state(vdec, format,
 171         ref_state->info.width, ref_state->info.height,
 172         (GstVideoCodecState *)ref_state);
 173     if (!state)
 174         return FALSE;
 175
 176     vi = &state->info;
 177     out_format = format;
 178     if (format == GST_VIDEO_FORMAT_ENCODED) {
 179         out_format = GST_VIDEO_FORMAT_I420;
 180         gst_video_info_init(&vis);
 181         gst_video_info_set_format(&vis, out_format,
 182             GST_VIDEO_INFO_WIDTH(vi), GST_VIDEO_INFO_HEIGHT(vi));
 183         vi->size = vis.size;
 184     }
 185     gst_video_codec_state_unref(state);
 186
 187 #if GST_CHECK_VERSION(1,1,0)
 188     vis = *vi;
 189     switch (feature) {
 190     case GST_VAAPI_CAPS_FEATURE_GL_TEXTURE_UPLOAD_META:
 191         gst_vaapidecode_video_info_change_format(&vis, GST_VIDEO_FORMAT_RGBA,
 192             GST_VIDEO_INFO_WIDTH(vi), GST_VIDEO_INFO_HEIGHT(vi));
 193         features = gst_caps_features_new(
 194             GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, NULL);
 195         break;
 196     default:
 197         if (format == GST_VIDEO_FORMAT_ENCODED) {
 198             /* XXX: this is a workaround until auto-plugging is fixed when
 199             format=ENCODED + memory:VASurface caps feature are provided.
 200             Meanwhile, providing a random format here works but this is
 201             a terribly wrong thing per se. */
 202             gst_vaapidecode_video_info_change_format(&vis, out_format,
 203                 GST_VIDEO_INFO_WIDTH(vi), GST_VIDEO_INFO_HEIGHT(vi));
 204 #if GST_CHECK_VERSION(1,3,0)
 205             if (feature == GST_VAAPI_CAPS_FEATURE_VAAPI_SURFACE)
 206                 features = gst_caps_features_new(
 207                     GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE, NULL);
 208 #endif
 209         }
 210         break;
 211     }
 212     state->caps = gst_video_info_to_caps(&vis);
 213     if (features)
 214         gst_caps_set_features(state->caps, 0, features);
 215 #else
 216     /* XXX: gst_video_info_to_caps() from GStreamer 0.10 does not
 217        reconstruct suitable caps for "encoded" video formats */
 218     state->caps = gst_caps_from_string(GST_VAAPI_SURFACE_CAPS_NAME);
 219     if (!state->caps)
 220         return FALSE;
 221
 222     gst_caps_set_simple(state->caps,
 223         "type", G_TYPE_STRING, "vaapi",
 224         "opengl", G_TYPE_BOOLEAN, USE_GLX,
 225         "width", G_TYPE_INT, vi->width,
 226         "height", G_TYPE_INT, vi->height,
 227         "framerate", GST_TYPE_FRACTION, vi->fps_n, vi->fps_d,
 228         "pixel-aspect-ratio", GST_TYPE_FRACTION, vi->par_n, vi->par_d,
 229         NULL);
 230
 231     gst_caps_set_interlaced(state->caps, vi);
 232 #endif
 233     gst_caps_replace(&decode->srcpad_caps, state->caps);
 234     return TRUE;
 235 }
 236
 237 static void
 238 gst_vaapidecode_release(GstVaapiDecode *decode)
 239 {
 240     g_mutex_lock(&decode->decoder_mutex);
 241     g_cond_signal(&decode->decoder_ready);
 242     g_mutex_unlock(&decode->decoder_mutex);
 243 }
 244
 245 static GstFlowReturn
 246 gst_vaapidecode_decode_frame(GstVideoDecoder *vdec, GstVideoCodecFrame *frame)
 247 {
 248     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 249     GstVaapiDecoderStatus status;
 250     GstFlowReturn ret;
 251
 252     /* Decode current frame */
 253     for (;;) {
 254         status = gst_vaapi_decoder_decode(decode->decoder, frame);
 255         if (status == GST_VAAPI_DECODER_STATUS_ERROR_NO_SURFACE) {
 256             GST_VIDEO_DECODER_STREAM_UNLOCK(vdec);
 257             g_mutex_lock(&decode->decoder_mutex);
 258             g_cond_wait(&decode->decoder_ready, &decode->decoder_mutex);
 259             g_mutex_unlock(&decode->decoder_mutex);
 260             GST_VIDEO_DECODER_STREAM_LOCK(vdec);
 261             if (decode->decoder_loop_status < 0)
 262                 goto error_decode_loop;
 263             continue;
 264         }
 265         if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
 266             goto error_decode;
 267         break;
 268     }
 269
 270     /* Try to report back early any error that occured in the decode task */
 271     GST_VIDEO_DECODER_STREAM_UNLOCK(vdec);
 272     GST_VIDEO_DECODER_STREAM_LOCK(vdec);
 273     return decode->decoder_loop_status;
 274
 275     /* ERRORS */
 276 error_decode_loop:
 277     {
 278         GST_ERROR("decode loop error %d", decode->decoder_loop_status);
 279         gst_video_decoder_drop_frame(vdec, frame);
 280         return decode->decoder_loop_status;
 281     }
 282 error_decode:
 283     {
 284         GST_ERROR("decode error %d", status);
 285         switch (status) {
 286         case GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CODEC:
 287         case GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE:
 288         case GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CHROMA_FORMAT:
 289             ret = GST_FLOW_NOT_SUPPORTED;
 290             break;
 291         default:
 292             ret = GST_FLOW_ERROR;
 293             break;
 294         }
 295         gst_video_decoder_drop_frame(vdec, frame);
 296         return ret;
 297     }
 298 }
 299
 300 static GstFlowReturn
 301 gst_vaapidecode_push_decoded_frame(GstVideoDecoder *vdec,
 302     GstVideoCodecFrame *out_frame)
 303 {
 304     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 305     GstVaapiSurfaceProxy *proxy;
 306     GstFlowReturn ret;
 307 #if GST_CHECK_VERSION(1,0,0)
 308     const GstVaapiRectangle *crop_rect;
 309     GstVaapiVideoMeta *meta;
 310     guint flags;
 311 #endif
 312
 313     if (!GST_VIDEO_CODEC_FRAME_IS_DECODE_ONLY(out_frame)) {
 314         proxy = gst_video_codec_frame_get_user_data(out_frame);
 315
 316         gst_vaapi_surface_proxy_set_destroy_notify(proxy,
 317             (GDestroyNotify)gst_vaapidecode_release, decode);
 318
 319 #if GST_CHECK_VERSION(1,0,0)
 320         ret = gst_video_decoder_allocate_output_frame(vdec, out_frame);
 321         if (ret != GST_FLOW_OK)
 322             goto error_create_buffer;
 323
 324         meta = gst_buffer_get_vaapi_video_meta(out_frame->output_buffer);
 325         if (!meta)
 326             goto error_get_meta;
 327         gst_vaapi_video_meta_set_surface_proxy(meta, proxy);
 328
 329         flags = gst_vaapi_surface_proxy_get_flags(proxy);
 330         if (flags & GST_VAAPI_SURFACE_PROXY_FLAG_INTERLACED) {
 331             guint out_flags = GST_VIDEO_BUFFER_FLAG_INTERLACED;
 332             if (flags & GST_VAAPI_SURFACE_PROXY_FLAG_TFF)
 333                 out_flags |= GST_VIDEO_BUFFER_FLAG_TFF;
 334             if (flags & GST_VAAPI_SURFACE_PROXY_FLAG_RFF)
 335                 out_flags |= GST_VIDEO_BUFFER_FLAG_RFF;
 336             if (flags & GST_VAAPI_SURFACE_PROXY_FLAG_ONEFIELD)
 337                 out_flags |= GST_VIDEO_BUFFER_FLAG_ONEFIELD;
 338             GST_BUFFER_FLAG_SET(out_frame->output_buffer, out_flags);
 339         }
 340
 341         crop_rect = gst_vaapi_surface_proxy_get_crop_rect(proxy);
 342         if (crop_rect) {
 343             GstVideoCropMeta * const crop_meta =
 344                 gst_buffer_add_video_crop_meta(out_frame->output_buffer);
 345             if (crop_meta) {
 346                 crop_meta->x = crop_rect->x;
 347                 crop_meta->y = crop_rect->y;
 348                 crop_meta->width = crop_rect->width;
 349                 crop_meta->height = crop_rect->height;
 350             }
 351         }
 352
 353 #if GST_CHECK_VERSION(1,1,0) && USE_GLX
 354         if (decode->has_texture_upload_meta)
 355             gst_buffer_ensure_texture_upload_meta(out_frame->output_buffer);
 356 #endif
 357 #else
 358         out_frame->output_buffer =
 359             gst_vaapi_video_buffer_new_with_surface_proxy(proxy);
 360         if (!out_frame->output_buffer)
 361             goto error_create_buffer;
 362 #endif
 363     }
 364
 365     ret = gst_video_decoder_finish_frame(vdec, out_frame);
 366     if (ret != GST_FLOW_OK)
 367         goto error_commit_buffer;
 368
 369     gst_video_codec_frame_unref(out_frame);
 370     return GST_FLOW_OK;
 371
 372     /* ERRORS */
 373 error_create_buffer:
 374     {
 375         const GstVaapiID surface_id =
 376             gst_vaapi_surface_get_id(GST_VAAPI_SURFACE_PROXY_SURFACE(proxy));
 377
 378         GST_ERROR("video sink failed to create video buffer for proxy'ed "
 379                   "surface %" GST_VAAPI_ID_FORMAT,
 380                   GST_VAAPI_ID_ARGS(surface_id));
 381         gst_video_decoder_drop_frame(vdec, out_frame);
 382         gst_video_codec_frame_unref(out_frame);
 383         return GST_FLOW_ERROR;
 384     }
 385 #if GST_CHECK_VERSION(1,0,0)
 386 error_get_meta:
 387     {
 388         GST_ERROR("failed to get vaapi video meta attached to video buffer");
 389         gst_video_decoder_drop_frame(vdec, out_frame);
 390         gst_video_codec_frame_unref(out_frame);
 391         return GST_FLOW_ERROR;
 392     }
 393 #endif
 394 error_commit_buffer:
 395     {
 396         if (ret != GST_FLOW_FLUSHING)
 397             GST_ERROR("video sink rejected the video buffer (error %d)", ret);
 398         gst_video_codec_frame_unref(out_frame);
 399         return ret;
 400     }
 401 }
 402
 403 static GstFlowReturn
 404 gst_vaapidecode_handle_frame(GstVideoDecoder *vdec, GstVideoCodecFrame *frame)
 405 {
 406     GstFlowReturn ret;
 407
 408     /* Make sure to release the base class stream lock so that decode
 409        loop can call gst_video_decoder_finish_frame() without blocking */
 410     GST_VIDEO_DECODER_STREAM_UNLOCK(vdec);
 411     ret = gst_vaapidecode_decode_frame(vdec, frame);
 412     GST_VIDEO_DECODER_STREAM_LOCK(vdec);
 413     return ret;
 414 }
 415
 416 static void
 417 gst_vaapidecode_decode_loop(GstVaapiDecode *decode)
 418 {
 419     GstVideoDecoder * const vdec = GST_VIDEO_DECODER(decode);
 420     GstVaapiDecoderStatus status;
 421     GstVideoCodecFrame *out_frame;
 422     GstFlowReturn ret;
 423
 424     status = gst_vaapi_decoder_get_frame_with_timeout(decode->decoder,
 425         &out_frame, 100000);
 426
 427     GST_VIDEO_DECODER_STREAM_LOCK(vdec);
 428     switch (status) {
 429     case GST_VAAPI_DECODER_STATUS_SUCCESS:
 430         ret = gst_vaapidecode_push_decoded_frame(vdec, out_frame);
 431         break;
 432     case GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA:
 433         ret = GST_VIDEO_DECODER_FLOW_NEED_DATA;
 434         break;
 435     default:
 436         ret = GST_FLOW_ERROR;
 437         break;
 438     }
 439     decode->decoder_loop_status = ret;
 440     GST_VIDEO_DECODER_STREAM_UNLOCK(vdec);
 441
 442     if (ret == GST_FLOW_OK)
 443         return;
 444
 445     /* If invoked from gst_vaapidecode_finish(), then return right
 446        away no matter the errors, or the GstVaapiDecoder needs further
 447        data to complete decoding (there no more data to feed in) */
 448     if (decode->decoder_finish) {
 449         g_mutex_lock(&decode->decoder_mutex);
 450         g_cond_signal(&decode->decoder_finish_done);
 451         g_mutex_unlock(&decode->decoder_mutex);
 452         return;
 453     }
 454
 455     /* Suspend the task if an error occurred */
 456     if (ret != GST_VIDEO_DECODER_FLOW_NEED_DATA)
 457         gst_pad_pause_task(GST_VAAPI_PLUGIN_BASE_SRC_PAD(decode));
 458 }
 459
 460 static gboolean
 461 gst_vaapidecode_flush(GstVideoDecoder *vdec)
 462 {
 463     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 464     GstVaapiDecoderStatus status;
 465
 466     /* If there is something in GstVideoDecoder's output adapter, then
 467        submit the frame for decoding */
 468     if (decode->current_frame_size) {
 469         gst_video_decoder_have_frame(vdec);
 470         decode->current_frame_size = 0;
 471     }
 472
 473     status = gst_vaapi_decoder_flush(decode->decoder);
 474     if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
 475         goto error_flush;
 476     return TRUE;
 477
 478     /* ERRORS */
 479 error_flush:
 480     {
 481         GST_ERROR("failed to flush decoder (status %d)", status);
 482         return FALSE;
 483     }
 484 }
 485
 486 static GstFlowReturn
 487 gst_vaapidecode_finish(GstVideoDecoder *vdec)
 488 {
 489     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 490     GstFlowReturn ret = GST_FLOW_OK;
 491
 492     if (!gst_vaapidecode_flush(vdec))
 493         ret = GST_FLOW_OK;
 494
 495     /* Make sure the decode loop function has a chance to return, thus
 496        possibly unlocking gst_video_decoder_finish_frame() */
 497     GST_VIDEO_DECODER_STREAM_UNLOCK(vdec);
 498     g_mutex_lock(&decode->decoder_mutex);
 499     decode->decoder_finish = TRUE;
 500     g_cond_wait(&decode->decoder_finish_done, &decode->decoder_mutex);
 501     g_mutex_unlock(&decode->decoder_mutex);
 502     gst_pad_stop_task(GST_VAAPI_PLUGIN_BASE_SRC_PAD(decode));
 503     GST_VIDEO_DECODER_STREAM_LOCK(vdec);
 504     return ret;
 505 }
 506
 507 #if GST_CHECK_VERSION(1,0,0)
 508 static gboolean
 509 gst_vaapidecode_decide_allocation(GstVideoDecoder *vdec, GstQuery *query)
 510 {
 511     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 512     GstCaps *caps = NULL;
 513     GstBufferPool *pool;
 514     GstStructure *config;
 515     GstVideoInfo vi;
 516     guint size, min, max;
 517     gboolean need_pool, update_pool;
 518     gboolean has_video_meta = FALSE;
 519     GstVideoCodecState *state;
 520 #if GST_CHECK_VERSION(1,1,0) && USE_GLX
 521     gboolean has_texture_upload_meta = FALSE;
 522     GstCapsFeatures *features, *features2;
 523 #endif
 524
 525     gst_query_parse_allocation(query, &caps, &need_pool);
 526
 527     if (!caps)
 528         goto error_no_caps;
 529
 530     state = gst_video_decoder_get_output_state(vdec);
 531
 532     decode->has_texture_upload_meta = FALSE;
 533     has_video_meta = gst_query_find_allocation_meta(query, GST_VIDEO_META_API_TYPE, NULL);
 534 #if GST_CHECK_VERSION(1,1,0) && USE_GLX
 535     if (has_video_meta)
 536         decode->has_texture_upload_meta = gst_query_find_allocation_meta(query,
 537             GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, NULL);
 538
 539     features = gst_caps_get_features(state->caps, 0);
 540     features2 = gst_caps_features_new(GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, NULL);
 541
 542     has_texture_upload_meta =
 543         gst_vaapi_find_preferred_caps_feature(GST_VIDEO_DECODER_SRC_PAD(vdec),
 544             GST_VIDEO_FORMAT_ENCODED) ==
 545         GST_VAAPI_CAPS_FEATURE_GL_TEXTURE_UPLOAD_META;
 546
 547     /* Update src caps if feature is not handled downstream */
 548     if (!decode->has_texture_upload_meta &&
 549         gst_caps_features_is_equal(features, features2))
 550         gst_vaapidecode_update_src_caps (decode, state);
 551     else if (has_texture_upload_meta &&
 552              !gst_caps_features_is_equal(features, features2)) {
 553         gst_video_info_set_format(&state->info, GST_VIDEO_FORMAT_RGBA,
 554                                   state->info.width,
 555                                   state->info.height);
 556         gst_vaapidecode_update_src_caps(decode, state);
 557     }
 558     gst_caps_features_free(features2);
 559 #endif
 560
 561     gst_video_codec_state_unref(state);
 562
 563     gst_video_info_init(&vi);
 564     gst_video_info_from_caps(&vi, caps);
 565     if (GST_VIDEO_INFO_FORMAT(&vi) == GST_VIDEO_FORMAT_ENCODED)
 566         gst_video_info_set_format(&vi, GST_VIDEO_FORMAT_I420,
 567             GST_VIDEO_INFO_WIDTH(&vi), GST_VIDEO_INFO_HEIGHT(&vi));
 568
 569     g_return_val_if_fail(GST_VAAPI_PLUGIN_BASE_DISPLAY(decode) != NULL, FALSE);
 570
 571     if (gst_query_get_n_allocation_pools(query) > 0) {
 572         gst_query_parse_nth_allocation_pool(query, 0, &pool, &size, &min, &max);
 573         size = MAX(size, vi.size);
 574         update_pool = TRUE;
 575     }
 576     else {
 577         pool = NULL;
 578         size = vi.size;
 579         min = max = 0;
 580         update_pool = FALSE;
 581     }
 582
 583     if (!pool || !gst_buffer_pool_has_option(pool,
 584             GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META)) {
 585         GST_INFO("no pool or doesn't support GstVaapiVideoMeta, "
 586             "making new pool");
 587         if (pool)
 588             gst_object_unref(pool);
 589         pool = gst_vaapi_video_buffer_pool_new(
 590             GST_VAAPI_PLUGIN_BASE_DISPLAY(decode));
 591         if (!pool)
 592             goto error_create_pool;
 593
 594         config = gst_buffer_pool_get_config(pool);
 595         gst_buffer_pool_config_set_params(config, caps, size, min, max);
 596         gst_buffer_pool_config_add_option(config,
 597             GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META);
 598         gst_buffer_pool_set_config(pool, config);
 599     }
 600
 601     if (has_video_meta) {
 602         config = gst_buffer_pool_get_config(pool);
 603         gst_buffer_pool_config_add_option(config,
 604             GST_BUFFER_POOL_OPTION_VIDEO_META);
 605 #if GST_CHECK_VERSION(1,1,0) && USE_GLX
 606         if (decode->has_texture_upload_meta)
 607             gst_buffer_pool_config_add_option(config,
 608                 GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META);
 609 #endif
 610         gst_buffer_pool_set_config(pool, config);
 611     }
 612
 613     if (update_pool)
 614         gst_query_set_nth_allocation_pool(query, 0, pool, size, min, max);
 615     else
 616         gst_query_add_allocation_pool(query, pool, size, min, max);
 617     if (pool)
 618         gst_object_unref(pool);
 619     return TRUE;
 620
 621     /* ERRORS */
 622 error_no_caps:
 623     {
 624         GST_ERROR("no caps specified");
 625         return FALSE;
 626     }
 627 error_create_pool:
 628     {
 629         GST_ERROR("failed to create buffer pool");
 630         return FALSE;
 631     }
 632 }
 633 #endif
 634
 635 static inline gboolean
 636 gst_vaapidecode_ensure_display(GstVaapiDecode *decode)
 637 {
 638     return gst_vaapi_plugin_base_ensure_display(GST_VAAPI_PLUGIN_BASE(decode));
 639 }
 640
 641 static inline guint
 642 gst_vaapi_codec_from_caps(GstCaps *caps)
 643 {
 644     return gst_vaapi_profile_get_codec(gst_vaapi_profile_from_caps(caps));
 645 }
 646
 647 static gboolean
 648 gst_vaapidecode_create(GstVaapiDecode *decode, GstCaps *caps)
 649 {
 650     GstVaapiDisplay *dpy;
 651
 652     if (!gst_vaapidecode_ensure_display(decode))
 653         return FALSE;
 654     dpy = GST_VAAPI_PLUGIN_BASE_DISPLAY(decode);
 655
 656     switch (gst_vaapi_codec_from_caps(caps)) {
 657     case GST_VAAPI_CODEC_MPEG2:
 658         decode->decoder = gst_vaapi_decoder_mpeg2_new(dpy, caps);
 659         break;
 660     case GST_VAAPI_CODEC_MPEG4:
 661     case GST_VAAPI_CODEC_H263:
 662         decode->decoder = gst_vaapi_decoder_mpeg4_new(dpy, caps);
 663         break;
 664     case GST_VAAPI_CODEC_H264:
 665         decode->decoder = gst_vaapi_decoder_h264_new(dpy, caps);
 666
 667         /* Set the stream buffer alignment for better optimizations */
 668         if (decode->decoder && caps) {
 669             GstStructure * const structure = gst_caps_get_structure(caps, 0);
 670             const gchar *str = NULL;
 671
 672             if ((str = gst_structure_get_string(structure, "alignment"))) {
 673                 GstVaapiStreamAlignH264 alignment;
 674                 if (g_strcmp0(str, "au") == 0)
 675                     alignment = GST_VAAPI_STREAM_ALIGN_H264_AU;
 676                 else if (g_strcmp0(str, "nal") == 0)
 677                     alignment = GST_VAAPI_STREAM_ALIGN_H264_NALU;
 678                 else
 679                     alignment = GST_VAAPI_STREAM_ALIGN_H264_NONE;
 680                 gst_vaapi_decoder_h264_set_alignment(
 681                     GST_VAAPI_DECODER_H264(decode->decoder), alignment);
 682             }
 683         }
 684         break;
 685     case GST_VAAPI_CODEC_WMV3:
 686     case GST_VAAPI_CODEC_VC1:
 687         decode->decoder = gst_vaapi_decoder_vc1_new(dpy, caps);
 688         break;
 689 #if USE_JPEG_DECODER
 690     case GST_VAAPI_CODEC_JPEG:
 691         decode->decoder = gst_vaapi_decoder_jpeg_new(dpy, caps);
 692         break;
 693 #endif
 694 #if USE_VP8_DECODER
 695     case GST_VAAPI_CODEC_VP8:
 696         decode->decoder = gst_vaapi_decoder_vp8_new(dpy, caps);
 697         break;
 698 #endif
 699     default:
 700         decode->decoder = NULL;
 701         break;
 702     }
 703     if (!decode->decoder)
 704         return FALSE;
 705
 706     gst_vaapi_decoder_set_codec_state_changed_func(decode->decoder,
 707         gst_vaapi_decoder_state_changed, decode);
 708
 709     decode->decoder_caps = gst_caps_ref(caps);
 710     return gst_pad_start_task(GST_VAAPI_PLUGIN_BASE_SRC_PAD(decode),
 711         (GstTaskFunction)gst_vaapidecode_decode_loop, decode, NULL);
 712 }
 713
 714 static void
 715 gst_vaapidecode_destroy(GstVaapiDecode *decode)
 716 {
 717     gst_pad_stop_task(GST_VAAPI_PLUGIN_BASE_SRC_PAD(decode));
 718     gst_vaapi_decoder_replace(&decode->decoder, NULL);
 719     gst_caps_replace(&decode->decoder_caps, NULL);
 720     gst_vaapidecode_release(decode);
 721 }
 722
 723 static gboolean
 724 gst_vaapidecode_reset_full(GstVaapiDecode *decode, GstCaps *caps, gboolean hard)
 725 {
 726     GstVaapiCodec codec;
 727
 728     decode->has_texture_upload_meta = FALSE;
 729
 730     /* Reset tracked frame size */
 731     decode->current_frame_size = 0;
 732
 733     /* Reset timers if hard reset was requested (e.g. seek) */
 734     if (hard) {
 735         GstVideoDecoder * const vdec = GST_VIDEO_DECODER(decode);
 736         GstVideoCodecFrame *out_frame = NULL;
 737
 738         gst_vaapi_decoder_flush(decode->decoder);
 739         GST_VIDEO_DECODER_STREAM_UNLOCK(vdec);
 740         gst_pad_stop_task(GST_VAAPI_PLUGIN_BASE_SRC_PAD(decode));
 741         GST_VIDEO_DECODER_STREAM_LOCK(vdec);
 742         decode->decoder_loop_status = GST_FLOW_OK;
 743
 744         /* Purge all decoded frames as we don't need them (e.g. seek) */
 745         while (gst_vaapi_decoder_get_frame_with_timeout(decode->decoder,
 746                    &out_frame, 0) == GST_VAAPI_DECODER_STATUS_SUCCESS) {
 747             gst_video_codec_frame_unref(out_frame);
 748             out_frame = NULL;
 749         }
 750     }
 751
 752     /* Only reset decoder if codec type changed */
 753     else if (decode->decoder && decode->decoder_caps) {
 754         if (gst_caps_is_always_compatible(caps, decode->decoder_caps))
 755             return TRUE;
 756         codec = gst_vaapi_codec_from_caps(caps);
 757         if (codec == gst_vaapi_decoder_get_codec(decode->decoder))
 758             return TRUE;
 759     }
 760
 761     gst_vaapidecode_destroy(decode);
 762     return gst_vaapidecode_create(decode, caps);
 763 }
 764
 765 static void
 766 gst_vaapidecode_finalize(GObject *object)
 767 {
 768     GstVaapiDecode * const decode = GST_VAAPIDECODE(object);
 769
 770     gst_caps_replace(&decode->sinkpad_caps, NULL);
 771     gst_caps_replace(&decode->srcpad_caps,  NULL);
 772     gst_caps_replace(&decode->allowed_caps, NULL);
 773
 774     g_cond_clear(&decode->decoder_finish_done);
 775     g_cond_clear(&decode->decoder_ready);
 776     g_mutex_clear(&decode->decoder_mutex);
 777
 778     gst_vaapi_plugin_base_finalize(GST_VAAPI_PLUGIN_BASE(object));
 779     G_OBJECT_CLASS(gst_vaapidecode_parent_class)->finalize(object);
 780 }
 781
 782 static gboolean
 783 gst_vaapidecode_open(GstVideoDecoder *vdec)
 784 {
 785     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 786     GstVaapiDisplay * const old_display = GST_VAAPI_PLUGIN_BASE_DISPLAY(decode);
 787     gboolean success;
 788
 789     if (!gst_vaapi_plugin_base_open(GST_VAAPI_PLUGIN_BASE(decode)))
 790         return FALSE;
 791
 792     /* Let GstVideoContext ask for a proper display to its neighbours */
 793     /* Note: steal old display that may be allocated from get_caps()
 794        so that to retain a reference to it, thus avoiding extra
 795        initialization steps if we turn out to simply re-use the
 796        existing (cached) VA display */
 797     GST_VAAPI_PLUGIN_BASE_DISPLAY(decode) = NULL;
 798     success = gst_vaapidecode_ensure_display(decode);
 799     if (old_display)
 800         gst_vaapi_display_unref(old_display);
 801     return success;
 802 }
 803
 804 static gboolean
 805 gst_vaapidecode_close(GstVideoDecoder *vdec)
 806 {
 807     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 808
 809     gst_vaapidecode_destroy(decode);
 810     gst_vaapi_plugin_base_close(GST_VAAPI_PLUGIN_BASE(decode));
 811     return TRUE;
 812 }
 813
 814 static gboolean
 815 gst_vaapidecode_reset(GstVideoDecoder *vdec, gboolean hard)
 816 {
 817     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 818
 819     /* In GStreamer 1.0 context, this means a flush */
 820     if (decode->decoder && !hard && !gst_vaapidecode_flush(vdec))
 821         return FALSE;
 822     return gst_vaapidecode_reset_full(decode, decode->sinkpad_caps, hard);
 823 }
 824
 825 static gboolean
 826 gst_vaapidecode_set_format(GstVideoDecoder *vdec, GstVideoCodecState *state)
 827 {
 828     GstVaapiPluginBase * const plugin = GST_VAAPI_PLUGIN_BASE(vdec);
 829     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 830
 831     if (!gst_vaapidecode_update_sink_caps(decode, state->caps))
 832         return FALSE;
 833     if (!gst_vaapidecode_update_src_caps(decode, state))
 834         return FALSE;
 835     if (!gst_video_decoder_negotiate(vdec))
 836         return FALSE;
 837     if (!gst_vaapi_plugin_base_set_caps(plugin, decode->sinkpad_caps,
 838             decode->srcpad_caps))
 839         return FALSE;
 840     if (!gst_vaapidecode_reset_full(decode, decode->sinkpad_caps, FALSE))
 841         return FALSE;
 842     return TRUE;
 843 }
 844
 845 static GstFlowReturn
 846 gst_vaapidecode_parse_frame(GstVideoDecoder *vdec,
 847     GstVideoCodecFrame *frame, GstAdapter *adapter, gboolean at_eos)
 848 {
 849     GstVaapiDecode * const decode = GST_VAAPIDECODE(vdec);
 850     GstVaapiDecoderStatus status;
 851     GstFlowReturn ret;
 852     guint got_unit_size;
 853     gboolean got_frame;
 854
 855     status = gst_vaapi_decoder_parse(decode->decoder, frame,
 856         adapter, at_eos, &got_unit_size, &got_frame);
 857
 858     switch (status) {
 859     case GST_VAAPI_DECODER_STATUS_SUCCESS:
 860         if (got_unit_size > 0) {
 861             gst_video_decoder_add_to_frame(vdec, got_unit_size);
 862             decode->current_frame_size += got_unit_size;
 863         }
 864         if (got_frame) {
 865             ret = gst_video_decoder_have_frame(vdec);
 866             decode->current_frame_size = 0;
 867         }
 868         else
 869             ret = GST_VAAPI_DECODE_FLOW_PARSE_DATA;
 870         break;
 871     case GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA:
 872         ret = GST_VIDEO_DECODER_FLOW_NEED_DATA;
 873         break;
 874     case GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CODEC:
 875     case GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE:
 876     case GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CHROMA_FORMAT:
 877         GST_WARNING("parse error %d", status);
 878         ret = GST_FLOW_NOT_SUPPORTED;
 879         decode->current_frame_size = 0;
 880         break;
 881     default:
 882         GST_ERROR("parse error %d", status);
 883         ret = GST_FLOW_EOS;
 884         decode->current_frame_size = 0;
 885         break;
 886     }
 887     return ret;
 888 }
 889
 890 static GstFlowReturn
 891 gst_vaapidecode_parse(GstVideoDecoder *vdec,
 892     GstVideoCodecFrame *frame, GstAdapter *adapter, gboolean at_eos)
 893 {
 894     GstFlowReturn ret;
 895
 896     do {
 897         ret = gst_vaapidecode_parse_frame(vdec, frame, adapter, at_eos);
 898     } while (ret == GST_VAAPI_DECODE_FLOW_PARSE_DATA);
 899     return ret;
 900 }
 901
 902 static GstStateChangeReturn
 903 gst_vaapidecode_change_state (GstElement * element, GstStateChange transition)
 904 {
 905     GstVaapiDecode * const decode = GST_VAAPIDECODE(element);
 906
 907     switch (transition) {
 908     case GST_STATE_CHANGE_PAUSED_TO_READY:
 909         gst_pad_stop_task(GST_VAAPI_PLUGIN_BASE_SRC_PAD(decode));
 910         break;
 911     default:
 912         break;
 913     }
 914     return GST_ELEMENT_CLASS(gst_vaapidecode_parent_class)->change_state(
 915         element, transition);
 916 }
 917
 918 static void
 919 gst_vaapidecode_class_init(GstVaapiDecodeClass *klass)
 920 {
 921     GObjectClass * const object_class = G_OBJECT_CLASS(klass);
 922     GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
 923     GstVideoDecoderClass * const vdec_class = GST_VIDEO_DECODER_CLASS(klass);
 924     GstPadTemplate *pad_template;
 925
 926     GST_DEBUG_CATEGORY_INIT(gst_debug_vaapidecode,
 927                             GST_PLUGIN_NAME, 0, GST_PLUGIN_DESC);
 928
 929     gst_vaapi_plugin_base_class_init(GST_VAAPI_PLUGIN_BASE_CLASS(klass));
 930
 931     object_class->finalize   = gst_vaapidecode_finalize;
 932
 933     element_class->change_state =
 934         GST_DEBUG_FUNCPTR(gst_vaapidecode_change_state);
 935
 936     vdec_class->open         = GST_DEBUG_FUNCPTR(gst_vaapidecode_open);
 937     vdec_class->close        = GST_DEBUG_FUNCPTR(gst_vaapidecode_close);
 938     vdec_class->set_format   = GST_DEBUG_FUNCPTR(gst_vaapidecode_set_format);
 939     vdec_class->reset        = GST_DEBUG_FUNCPTR(gst_vaapidecode_reset);
 940     vdec_class->parse        = GST_DEBUG_FUNCPTR(gst_vaapidecode_parse);
 941     vdec_class->handle_frame = GST_DEBUG_FUNCPTR(gst_vaapidecode_handle_frame);
 942     vdec_class->finish       = GST_DEBUG_FUNCPTR(gst_vaapidecode_finish);
 943
 944 #if GST_CHECK_VERSION(1,0,0)
 945     vdec_class->decide_allocation =
 946         GST_DEBUG_FUNCPTR(gst_vaapidecode_decide_allocation);
 947 #endif
 948
 949     gst_element_class_set_static_metadata(element_class,
 950         "VA-API decoder",
 951         "Codec/Decoder/Video",
 952         GST_PLUGIN_DESC,
 953         "Gwenole Beauchesne <gwenole.beauchesne@intel.com>");
 954
 955     /* sink pad */
 956     pad_template = gst_static_pad_template_get(&gst_vaapidecode_sink_factory);
 957     gst_element_class_add_pad_template(element_class, pad_template);
 958
 959     /* src pad */
 960     pad_template = gst_static_pad_template_get(&gst_vaapidecode_src_factory);
 961     gst_element_class_add_pad_template(element_class, pad_template);
 962 }
 963
 964 static gboolean
 965 gst_vaapidecode_ensure_allowed_caps(GstVaapiDecode *decode)
 966 {
 967     GstCaps *caps, *allowed_caps;
 968     GArray *profiles;
 969     guint i;
 970
 971     if (decode->allowed_caps)
 972         return TRUE;
 973
 974     if (!gst_vaapidecode_ensure_display(decode))
 975         goto error_no_display;
 976
 977     profiles = gst_vaapi_display_get_decode_profiles(
 978         GST_VAAPI_PLUGIN_BASE_DISPLAY(decode));
 979     if (!profiles)
 980         goto error_no_profiles;
 981
 982     allowed_caps = gst_caps_new_empty();
 983     if (!allowed_caps)
 984         goto error_no_memory;
 985
 986     for (i = 0; i < profiles->len; i++) {
 987         const GstVaapiProfile profile =
 988             g_array_index(profiles, GstVaapiProfile, i);
 989         const gchar *media_type_name;
 990
 991         media_type_name = gst_vaapi_profile_get_media_type_name(profile);
 992         if (!media_type_name)
 993             continue;
 994
 995         caps = gst_caps_from_string(media_type_name);
 996         if (!caps)
 997             continue;
 998         allowed_caps = gst_caps_merge(allowed_caps, caps);
 999     }
1000     decode->allowed_caps = allowed_caps;
1001
1002     g_array_unref(profiles);
1003     return TRUE;
1004
1005     /* ERRORS */
1006 error_no_display:
1007     {
1008         GST_ERROR("failed to retrieve VA display");
1009         return FALSE;
1010     }
1011 error_no_profiles:
1012     {
1013         GST_ERROR("failed to retrieve VA decode profiles");
1014         return FALSE;
1015     }
1016 error_no_memory:
1017     {
1018         GST_ERROR("failed to allocate allowed-caps set");
1019         g_array_unref(profiles);
1020         return FALSE;
1021     }
1022 }
1023
1024 static GstCaps *
1025 gst_vaapidecode_get_caps(GstPad *pad)
1026 {
1027     GstVaapiDecode * const decode = GST_VAAPIDECODE(GST_OBJECT_PARENT(pad));
1028
1029     if (!gst_vaapidecode_ensure_allowed_caps(decode))
1030         return gst_caps_new_empty();
1031
1032     return gst_caps_ref(decode->allowed_caps);
1033 }
1034
1035 static gboolean
1036 gst_vaapidecode_query(GST_PAD_QUERY_FUNCTION_ARGS)
1037 {
1038     GstVaapiDecode * const decode =
1039         GST_VAAPIDECODE(gst_pad_get_parent_element(pad));
1040     GstVaapiPluginBase * const plugin = GST_VAAPI_PLUGIN_BASE(decode);
1041     gboolean res;
1042
1043     GST_INFO_OBJECT(decode, "query type %s", GST_QUERY_TYPE_NAME(query));
1044
1045     if (gst_vaapi_reply_to_query(query, plugin->display)) {
1046         GST_DEBUG("sharing display %p", plugin->display);
1047         res = TRUE;
1048     }
1049     else if (GST_PAD_IS_SINK(pad)) {
1050         switch (GST_QUERY_TYPE(query)) {
1051 #if GST_CHECK_VERSION(1,0,0)
1052         case GST_QUERY_CAPS: {
1053             GstCaps * const caps = gst_vaapidecode_get_caps(pad);
1054             gst_query_set_caps_result(query, caps);
1055             gst_caps_unref(caps);
1056             res = TRUE;
1057             break;
1058         }
1059 #endif
1060         default:
1061             res = GST_PAD_QUERY_FUNCTION_CALL(plugin->sinkpad_query, pad,
1062                 parent, query);
1063             break;
1064         }
1065     }
1066     else
1067         res = GST_PAD_QUERY_FUNCTION_CALL(plugin->srcpad_query, pad,
1068             parent, query);
1069
1070     gst_object_unref(decode);
1071     return res;
1072 }
1073
1074 static void
1075 gst_vaapidecode_init(GstVaapiDecode *decode)
1076 {
1077     GstVideoDecoder * const vdec = GST_VIDEO_DECODER(decode);
1078     GstPad *pad;
1079
1080     gst_vaapi_plugin_base_init(GST_VAAPI_PLUGIN_BASE(decode), GST_CAT_DEFAULT);
1081
1082     decode->decoder             = NULL;
1083     decode->decoder_caps        = NULL;
1084     decode->allowed_caps        = NULL;
1085     decode->decoder_loop_status = GST_FLOW_OK;
1086
1087     g_mutex_init(&decode->decoder_mutex);
1088     g_cond_init(&decode->decoder_ready);
1089     g_cond_init(&decode->decoder_finish_done);
1090
1091     gst_video_decoder_set_packetized(vdec, FALSE);
1092
1093     /* Pad through which data comes in to the element */
1094     pad = GST_VAAPI_PLUGIN_BASE_SINK_PAD(decode);
1095     gst_pad_set_query_function(pad, gst_vaapidecode_query);
1096 #if !GST_CHECK_VERSION(1,0,0)
1097     gst_pad_set_getcaps_function(pad, gst_vaapidecode_get_caps);
1098 #endif
1099
1100     /* Pad through which data goes out of the element */
1101     pad = GST_VAAPI_PLUGIN_BASE_SRC_PAD(decode);
1102     gst_pad_set_query_function(pad, gst_vaapidecode_query);
1103 }