gst/vaapi/gstvaapipostproc.c

   1 /*
   2  *  gstvaapipostproc.c - VA-API video postprocessing
   3  *
   4  *  Copyright (C) 2012-2014 Intel Corporation
   5  *    Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Lesser General Public License
   9  *  as published by the Free Software Foundation; either version 2.1
  10  *  of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Lesser General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Lesser General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  *  Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * SECTION:gstvaapipostproc
  25  * @short_description: A video postprocessing filter
  26  *
  27  * vaapipostproc consists in various postprocessing algorithms to be
  28  * applied to VA surfaces. So far, only basic bob deinterlacing is
  29  * implemented.
  30  */
  31
  32 #include "gst/vaapi/sysdeps.h"
  33 #include <gst/video/video.h>
  34
  35 #include "gstvaapipostproc.h"
  36 #include "gstvaapipluginutil.h"
  37 #include "gstvaapivideobuffer.h"
  38 #if GST_CHECK_VERSION(1,0,0)
  39 #include "gstvaapivideobufferpool.h"
  40 #include "gstvaapivideomemory.h"
  41 #endif
  42
  43 #define GST_PLUGIN_NAME "vaapipostproc"
  44 #define GST_PLUGIN_DESC "A video postprocessing filter"
  45
  46 GST_DEBUG_CATEGORY_STATIC(gst_debug_vaapipostproc);
  47 #define GST_CAT_DEFAULT gst_debug_vaapipostproc
  48
  49 /* Default templates */
  50 static const char gst_vaapipostproc_sink_caps_str[] =
  51 #if GST_CHECK_VERSION(1,1,0)
  52     GST_VIDEO_CAPS_MAKE_WITH_FEATURES(
  53         GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE, "{ ENCODED, NV12, I420, YV12 }") ", "
  54 #else
  55     GST_VAAPI_SURFACE_CAPS ", "
  56 #endif
  57     GST_CAPS_INTERLACED_MODES "; "
  58 #if GST_CHECK_VERSION(1,0,0)
  59     GST_VIDEO_CAPS_MAKE(GST_VIDEO_FORMATS_ALL) ", "
  60 #else
  61     "video/x-raw-yuv, "
  62     "width  = " GST_VIDEO_SIZE_RANGE ", "
  63     "height = " GST_VIDEO_SIZE_RANGE ", "
  64     "framerate = " GST_VIDEO_FPS_RANGE ", "
  65 #endif
  66     GST_CAPS_INTERLACED_MODES;
  67
  68 static const char gst_vaapipostproc_src_caps_str[] =
  69 #if GST_CHECK_VERSION(1,1,0)
  70     GST_VIDEO_CAPS_MAKE_WITH_FEATURES(
  71         GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE, "{ ENCODED, NV12, I420, YV12 }") ", "
  72 #else
  73     GST_VAAPI_SURFACE_CAPS ", "
  74 #endif
  75     GST_CAPS_INTERLACED_FALSE;
  76
  77 static GstStaticPadTemplate gst_vaapipostproc_sink_factory =
  78     GST_STATIC_PAD_TEMPLATE(
  79         "sink",
  80         GST_PAD_SINK,
  81         GST_PAD_ALWAYS,
  82         GST_STATIC_CAPS(gst_vaapipostproc_sink_caps_str));
  83
  84 static GstStaticPadTemplate gst_vaapipostproc_src_factory =
  85     GST_STATIC_PAD_TEMPLATE(
  86         "src",
  87         GST_PAD_SRC,
  88         GST_PAD_ALWAYS,
  89         GST_STATIC_CAPS(gst_vaapipostproc_src_caps_str));
  90
  91 G_DEFINE_TYPE_WITH_CODE(
  92     GstVaapiPostproc,
  93     gst_vaapipostproc,
  94     GST_TYPE_BASE_TRANSFORM,
  95     GST_VAAPI_PLUGIN_BASE_INIT_INTERFACES)
  96
  97 enum {
  98     PROP_0,
  99
 100     PROP_FORMAT,
 101     PROP_WIDTH,
 102     PROP_HEIGHT,
 103     PROP_FORCE_ASPECT_RATIO,
 104     PROP_DEINTERLACE_MODE,
 105     PROP_DEINTERLACE_METHOD,
 106     PROP_DENOISE,
 107     PROP_SHARPEN,
 108     PROP_HUE,
 109     PROP_SATURATION,
 110     PROP_BRIGHTNESS,
 111     PROP_CONTRAST,
 112 };
 113
 114 #define DEFAULT_FORMAT                  GST_VIDEO_FORMAT_ENCODED
 115 #define DEFAULT_DEINTERLACE_MODE        GST_VAAPI_DEINTERLACE_MODE_AUTO
 116 #define DEFAULT_DEINTERLACE_METHOD      GST_VAAPI_DEINTERLACE_METHOD_BOB
 117
 118 #define GST_VAAPI_TYPE_DEINTERLACE_MODE \
 119     gst_vaapi_deinterlace_mode_get_type()
 120
 121 static GType
 122 gst_vaapi_deinterlace_mode_get_type(void)
 123 {
 124     static GType deinterlace_mode_type = 0;
 125
 126     static const GEnumValue mode_types[] = {
 127         { GST_VAAPI_DEINTERLACE_MODE_AUTO,
 128           "Auto detection", "auto" },
 129         { GST_VAAPI_DEINTERLACE_MODE_INTERLACED,
 130           "Force deinterlacing", "interlaced" },
 131         { GST_VAAPI_DEINTERLACE_MODE_DISABLED,
 132           "Never deinterlace", "disabled" },
 133         { 0, NULL, NULL },
 134     };
 135
 136     if (!deinterlace_mode_type) {
 137         deinterlace_mode_type =
 138             g_enum_register_static("GstVaapiDeinterlaceMode", mode_types);
 139     }
 140     return deinterlace_mode_type;
 141 }
 142
 143 static void
 144 ds_reset(GstVaapiDeinterlaceState *ds)
 145 {
 146     guint i;
 147
 148     for (i = 0; i < G_N_ELEMENTS(ds->buffers); i++)
 149         gst_buffer_replace(&ds->buffers[i], NULL);
 150     ds->buffers_index = 0;
 151     ds->num_surfaces = 0;
 152     ds->deint = FALSE;
 153     ds->tff = FALSE;
 154 }
 155
 156 static void
 157 ds_add_buffer(GstVaapiDeinterlaceState *ds, GstBuffer *buf)
 158 {
 159     gst_buffer_replace(&ds->buffers[ds->buffers_index], buf);
 160     ds->buffers_index = (ds->buffers_index + 1) % G_N_ELEMENTS(ds->buffers);
 161 }
 162
 163 static inline GstBuffer *
 164 ds_get_buffer(GstVaapiDeinterlaceState *ds, guint index)
 165 {
 166     /* Note: the index increases towards older buffers.
 167        i.e. buffer at index 0 means the immediately preceding buffer
 168        in the history, buffer at index 1 means the one preceding the
 169        surface at index 0, etc. */
 170     const guint n = ds->buffers_index + G_N_ELEMENTS(ds->buffers) - index - 1;
 171     return ds->buffers[n % G_N_ELEMENTS(ds->buffers)];
 172 }
 173
 174 static void
 175 ds_set_surfaces(GstVaapiDeinterlaceState *ds)
 176 {
 177     GstVaapiVideoMeta *meta;
 178     guint i;
 179
 180     ds->num_surfaces = 0;
 181     for (i = 0; i < G_N_ELEMENTS(ds->buffers); i++) {
 182         GstBuffer * const buf = ds_get_buffer(ds, i);
 183         if (!buf)
 184             break;
 185
 186         meta = gst_buffer_get_vaapi_video_meta(buf);
 187         ds->surfaces[ds->num_surfaces++] =
 188             gst_vaapi_video_meta_get_surface(meta);
 189     }
 190 }
 191
 192 static GstVaapiFilterOpInfo *
 193 find_filter_op(GPtrArray *filter_ops, GstVaapiFilterOp op)
 194 {
 195     guint i;
 196
 197     if (filter_ops) {
 198         for (i = 0; i < filter_ops->len; i++) {
 199             GstVaapiFilterOpInfo * const filter_op =
 200                 g_ptr_array_index(filter_ops, i);
 201             if (filter_op->op == op)
 202                 return filter_op;
 203         }
 204     }
 205     return NULL;
 206 }
 207
 208 static inline gboolean
 209 gst_vaapipostproc_ensure_display(GstVaapiPostproc *postproc)
 210 {
 211     return gst_vaapi_plugin_base_ensure_display(GST_VAAPI_PLUGIN_BASE(postproc));
 212 }
 213
 214 static gboolean
 215 gst_vaapipostproc_ensure_uploader(GstVaapiPostproc *postproc)
 216 {
 217     if (!gst_vaapipostproc_ensure_display(postproc))
 218         return FALSE;
 219     if (!gst_vaapi_plugin_base_ensure_uploader(GST_VAAPI_PLUGIN_BASE(postproc)))
 220         return FALSE;
 221     return TRUE;
 222 }
 223
 224 static gboolean
 225 gst_vaapipostproc_ensure_filter(GstVaapiPostproc *postproc)
 226 {
 227     if (postproc->filter)
 228         return TRUE;
 229
 230     if (!gst_vaapipostproc_ensure_display(postproc))
 231         return FALSE;
 232
 233     postproc->filter = gst_vaapi_filter_new(
 234         GST_VAAPI_PLUGIN_BASE_DISPLAY(postproc));
 235     if (!postproc->filter)
 236         return FALSE;
 237     return TRUE;
 238 }
 239
 240 static gboolean
 241 gst_vaapipostproc_ensure_filter_caps(GstVaapiPostproc *postproc)
 242 {
 243     if (!gst_vaapipostproc_ensure_filter(postproc))
 244         return FALSE;
 245
 246     postproc->filter_ops = gst_vaapi_filter_get_operations(postproc->filter);
 247     if (!postproc->filter_ops)
 248         return FALSE;
 249
 250     postproc->filter_formats = gst_vaapi_filter_get_formats(postproc->filter);
 251     if (!postproc->filter_formats)
 252         return FALSE;
 253     return TRUE;
 254 }
 255
 256 static gboolean
 257 gst_vaapipostproc_create(GstVaapiPostproc *postproc)
 258 {
 259     if (!gst_vaapi_plugin_base_open(GST_VAAPI_PLUGIN_BASE(postproc)))
 260         return FALSE;
 261     if (!gst_vaapipostproc_ensure_display(postproc))
 262         return FALSE;
 263     if (!gst_vaapipostproc_ensure_uploader(postproc))
 264         return FALSE;
 265     if (gst_vaapipostproc_ensure_filter(postproc))
 266         postproc->use_vpp = TRUE;
 267     return TRUE;
 268 }
 269
 270 static void
 271 gst_vaapipostproc_destroy_filter(GstVaapiPostproc *postproc)
 272 {
 273     if (postproc->filter_formats) {
 274         g_array_unref(postproc->filter_formats);
 275         postproc->filter_formats = NULL;
 276     }
 277
 278     if (postproc->filter_ops) {
 279         g_ptr_array_unref(postproc->filter_ops);
 280         postproc->filter_ops = NULL;
 281     }
 282     gst_vaapi_filter_replace(&postproc->filter, NULL);
 283     gst_vaapi_video_pool_replace(&postproc->filter_pool, NULL);
 284 }
 285
 286 static void
 287 gst_vaapipostproc_destroy(GstVaapiPostproc *postproc)
 288 {
 289     ds_reset(&postproc->deinterlace_state);
 290     gst_vaapipostproc_destroy_filter(postproc);
 291
 292     gst_caps_replace(&postproc->allowed_sinkpad_caps, NULL);
 293     gst_caps_replace(&postproc->allowed_srcpad_caps, NULL);
 294     gst_vaapi_plugin_base_close(GST_VAAPI_PLUGIN_BASE(postproc));
 295 }
 296
 297 static gboolean
 298 gst_vaapipostproc_start(GstBaseTransform *trans)
 299 {
 300     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
 301
 302     ds_reset(&postproc->deinterlace_state);
 303     if (!gst_vaapi_plugin_base_open(GST_VAAPI_PLUGIN_BASE(postproc)))
 304         return FALSE;
 305     if (!gst_vaapipostproc_ensure_display(postproc))
 306         return FALSE;
 307     return TRUE;
 308 }
 309
 310 static gboolean
 311 gst_vaapipostproc_stop(GstBaseTransform *trans)
 312 {
 313     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
 314
 315     ds_reset(&postproc->deinterlace_state);
 316     gst_vaapi_plugin_base_close(GST_VAAPI_PLUGIN_BASE(postproc));
 317     return TRUE;
 318 }
 319
 320 static gboolean
 321 should_deinterlace_buffer(GstVaapiPostproc *postproc, GstBuffer *buf)
 322 {
 323     if (!(postproc->flags & GST_VAAPI_POSTPROC_FLAG_DEINTERLACE) ||
 324         postproc->deinterlace_mode == GST_VAAPI_DEINTERLACE_MODE_DISABLED)
 325         return FALSE;
 326
 327     if (postproc->deinterlace_mode == GST_VAAPI_DEINTERLACE_MODE_INTERLACED)
 328         return TRUE;
 329
 330     g_assert(postproc->deinterlace_mode == GST_VAAPI_DEINTERLACE_MODE_AUTO);
 331
 332     switch (GST_VIDEO_INFO_INTERLACE_MODE(&postproc->sinkpad_info)) {
 333     case GST_VIDEO_INTERLACE_MODE_INTERLEAVED:
 334         return TRUE;
 335     case GST_VIDEO_INTERLACE_MODE_PROGRESSIVE:
 336         return FALSE;
 337     case GST_VIDEO_INTERLACE_MODE_MIXED:
 338 #if GST_CHECK_VERSION(1,0,0)
 339         if (GST_BUFFER_FLAG_IS_SET(buf, GST_VIDEO_BUFFER_FLAG_INTERLACED))
 340             return TRUE;
 341 #else
 342         if (!GST_BUFFER_FLAG_IS_SET(buf, GST_VIDEO_BUFFER_PROGRESSIVE))
 343             return TRUE;
 344 #endif
 345         break;
 346     default:
 347         GST_ERROR("unhandled \"interlace-mode\", disabling deinterlacing" );
 348         break;
 349     }
 350     return FALSE;
 351 }
 352
 353 static GstBuffer *
 354 create_output_buffer(GstVaapiPostproc *postproc)
 355 {
 356     GstBuffer *outbuf;
 357
 358     /* Create a raw VA video buffer without GstVaapiVideoMeta attached
 359        to it yet, as this will be done next in the transform() hook */
 360     outbuf = gst_vaapi_video_buffer_new_empty();
 361     if (!outbuf)
 362         goto error_create_buffer;
 363
 364 #if !GST_CHECK_VERSION(1,0,0)
 365     gst_buffer_set_caps(outbuf, GST_VAAPI_PLUGIN_BASE_SRC_PAD_CAPS(postproc));
 366 #endif
 367     return outbuf;
 368
 369     /* ERRORS */
 370 error_create_buffer:
 371     {
 372         GST_ERROR("failed to create output video buffer");
 373         return NULL;
 374     }
 375 }
 376
 377 static inline void
 378 append_output_buffer_metadata(GstBuffer *outbuf, GstBuffer *inbuf, guint flags)
 379 {
 380     gst_buffer_copy_into(outbuf, inbuf, flags |
 381         GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_META | GST_BUFFER_COPY_MEMORY,
 382         0, -1);
 383 }
 384
 385 static gboolean
 386 deint_method_is_advanced(GstVaapiDeinterlaceMethod deint_method)
 387 {
 388     gboolean is_advanced;
 389
 390     switch (deint_method) {
 391     case GST_VAAPI_DEINTERLACE_METHOD_MOTION_ADAPTIVE:
 392     case GST_VAAPI_DEINTERLACE_METHOD_MOTION_COMPENSATED:
 393         is_advanced = TRUE;
 394         break;
 395     default:
 396         is_advanced = FALSE;
 397         break;
 398     }
 399     return is_advanced;
 400 }
 401
 402 static GstVaapiDeinterlaceMethod
 403 get_next_deint_method(GstVaapiDeinterlaceMethod deint_method)
 404 {
 405     switch (deint_method) {
 406     case GST_VAAPI_DEINTERLACE_METHOD_MOTION_COMPENSATED:
 407         deint_method = GST_VAAPI_DEINTERLACE_METHOD_MOTION_ADAPTIVE;
 408         break;
 409     default:
 410         /* Default to basic "bob" for all others */
 411         deint_method = GST_VAAPI_DEINTERLACE_METHOD_BOB;
 412         break;
 413     }
 414     return deint_method;
 415 }
 416
 417 static gboolean
 418 set_best_deint_method(GstVaapiPostproc *postproc, guint flags,
 419     GstVaapiDeinterlaceMethod *deint_method_ptr)
 420 {
 421     GstVaapiDeinterlaceMethod deint_method = postproc->deinterlace_method;
 422     gboolean success;
 423
 424     for (;;) {
 425         success = gst_vaapi_filter_set_deinterlacing(postproc->filter,
 426             deint_method, flags);
 427         if (success || deint_method == GST_VAAPI_DEINTERLACE_METHOD_BOB)
 428             break;
 429         deint_method = get_next_deint_method(deint_method);
 430     }
 431     *deint_method_ptr = deint_method;
 432     return success;
 433 }
 434
 435 static GstFlowReturn
 436 gst_vaapipostproc_process_vpp(GstBaseTransform *trans, GstBuffer *inbuf,
 437     GstBuffer *outbuf)
 438 {
 439     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
 440     GstVaapiDeinterlaceState * const ds = &postproc->deinterlace_state;
 441     GstVaapiVideoMeta *inbuf_meta, *outbuf_meta;
 442     GstVaapiSurface *inbuf_surface, *outbuf_surface;
 443     GstVaapiFilterStatus status;
 444     GstClockTime timestamp;
 445     GstFlowReturn ret;
 446     GstBuffer *fieldbuf;
 447     GstVaapiDeinterlaceMethod deint_method;
 448     guint flags, deint_flags;
 449     gboolean tff, deint, deint_refs, deint_changed;
 450     GstVaapiRectangle *crop_rect = NULL;
 451
 452     /* Validate filters */
 453     if ((postproc->flags & GST_VAAPI_POSTPROC_FLAG_FORMAT) &&
 454         !gst_vaapi_filter_set_format(postproc->filter, postproc->format))
 455         return GST_FLOW_NOT_SUPPORTED;
 456
 457     if ((postproc->flags & GST_VAAPI_POSTPROC_FLAG_DENOISE) &&
 458         !gst_vaapi_filter_set_denoising_level(postproc->filter,
 459             postproc->denoise_level))
 460         return GST_FLOW_NOT_SUPPORTED;
 461
 462     if ((postproc->flags & GST_VAAPI_POSTPROC_FLAG_SHARPEN) &&
 463         !gst_vaapi_filter_set_sharpening_level(postproc->filter,
 464             postproc->sharpen_level))
 465         return GST_FLOW_NOT_SUPPORTED;
 466
 467     if ((postproc->flags & GST_VAAPI_POSTPROC_FLAG_HUE) &&
 468         !gst_vaapi_filter_set_hue(postproc->filter,
 469             postproc->hue))
 470         return GST_FLOW_NOT_SUPPORTED;
 471
 472     if ((postproc->flags & GST_VAAPI_POSTPROC_FLAG_SATURATION) &&
 473         !gst_vaapi_filter_set_saturation(postproc->filter,
 474             postproc->saturation))
 475         return GST_FLOW_NOT_SUPPORTED;
 476
 477     if ((postproc->flags & GST_VAAPI_POSTPROC_FLAG_BRIGHTNESS) &&
 478         !gst_vaapi_filter_set_brightness(postproc->filter,
 479             postproc->brightness))
 480         return GST_FLOW_NOT_SUPPORTED;
 481
 482     if ((postproc->flags & GST_VAAPI_POSTPROC_FLAG_CONTRAST) &&
 483         !gst_vaapi_filter_set_contrast(postproc->filter,
 484             postproc->contrast))
 485         return GST_FLOW_NOT_SUPPORTED;
 486
 487     inbuf_meta = gst_buffer_get_vaapi_video_meta(inbuf);
 488     if (!inbuf_meta)
 489         goto error_invalid_buffer;
 490     inbuf_surface = gst_vaapi_video_meta_get_surface(inbuf_meta);
 491
 492 #if GST_CHECK_VERSION(1,0,0)
 493     GstVideoCropMeta * const crop_meta =
 494         gst_buffer_get_video_crop_meta(inbuf);
 495     if (crop_meta) {
 496         GstVaapiRectangle tmp_rect;
 497         crop_rect = &tmp_rect;
 498         crop_rect->x = crop_meta->x;
 499         crop_rect->y = crop_meta->y;
 500         crop_rect->width = crop_meta->width;
 501         crop_rect->height = crop_meta->height;
 502     }
 503 #endif
 504     if (!crop_rect)
 505         crop_rect = (GstVaapiRectangle *)
 506             gst_vaapi_video_meta_get_render_rect(inbuf_meta);
 507
 508     timestamp  = GST_BUFFER_TIMESTAMP(inbuf);
 509     tff        = GST_BUFFER_FLAG_IS_SET(inbuf, GST_VIDEO_BUFFER_FLAG_TFF);
 510     deint      = should_deinterlace_buffer(postproc, inbuf);
 511
 512     /* Drop references if deinterlacing conditions changed */
 513     deint_changed = deint != ds->deint;
 514     if (deint_changed || (ds->num_surfaces > 0 && tff != ds->tff))
 515         ds_reset(ds);
 516
 517     deint_method = postproc->deinterlace_method;
 518     deint_refs = deint_method_is_advanced(deint_method);
 519     if (deint_refs) {
 520         GstBuffer * const prev_buf = ds_get_buffer(ds, 0);
 521         GstClockTime prev_pts, pts = GST_BUFFER_TIMESTAMP(inbuf);
 522         /* Reset deinterlacing state when there is a discontinuity */
 523         if (prev_buf && (prev_pts = GST_BUFFER_TIMESTAMP(prev_buf)) != pts) {
 524             const GstClockTimeDiff pts_diff = GST_CLOCK_DIFF(prev_pts, pts);
 525             if (pts_diff < 0 || (postproc->field_duration > 0 &&
 526                     pts_diff > postproc->field_duration * 2))
 527                 ds_reset(ds);
 528         }
 529     }
 530
 531     ds->deint = deint;
 532     ds->tff = tff;
 533
 534     flags = gst_vaapi_video_meta_get_render_flags(inbuf_meta) &
 535         ~GST_VAAPI_PICTURE_STRUCTURE_MASK;
 536
 537     /* First field */
 538     if (postproc->flags & GST_VAAPI_POSTPROC_FLAG_DEINTERLACE) {
 539         fieldbuf = create_output_buffer(postproc);
 540         if (!fieldbuf)
 541             goto error_create_buffer;
 542
 543         outbuf_meta = gst_vaapi_video_meta_new_from_pool(postproc->filter_pool);
 544         if (!outbuf_meta)
 545             goto error_create_meta;
 546         outbuf_surface = gst_vaapi_video_meta_get_surface(outbuf_meta);
 547
 548         if (deint) {
 549             deint_flags = (tff ? GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD : 0);
 550             if (tff)
 551                 deint_flags |= GST_VAAPI_DEINTERLACE_FLAG_TFF;
 552             if (!set_best_deint_method(postproc, deint_flags, &deint_method))
 553                 goto error_op_deinterlace;
 554
 555             if (deint_method != postproc->deinterlace_method) {
 556                 GST_DEBUG("unsupported deinterlace-method %u. Using %u instead",
 557                           postproc->deinterlace_method, deint_method);
 558                 postproc->deinterlace_method = deint_method;
 559                 deint_refs = deint_method_is_advanced(deint_method);
 560             }
 561
 562             if (deint_refs) {
 563                 ds_set_surfaces(ds);
 564                 if (!gst_vaapi_filter_set_deinterlacing_references(
 565                         postproc->filter, ds->surfaces, ds->num_surfaces,
 566                         NULL, 0))
 567                     goto error_op_deinterlace;
 568             }
 569         }
 570         else if (deint_changed) {
 571             // Reset internal filter to non-deinterlacing mode
 572             deint_method = GST_VAAPI_DEINTERLACE_METHOD_NONE;
 573             if (!gst_vaapi_filter_set_deinterlacing(postproc->filter,
 574                     deint_method, 0))
 575                 goto error_op_deinterlace;
 576         }
 577
 578         gst_vaapi_filter_set_cropping_rectangle(postproc->filter, crop_rect);
 579         status = gst_vaapi_filter_process(postproc->filter, inbuf_surface,
 580             outbuf_surface, flags);
 581         if (status != GST_VAAPI_FILTER_STATUS_SUCCESS)
 582             goto error_process_vpp;
 583
 584         gst_buffer_set_vaapi_video_meta(fieldbuf, outbuf_meta);
 585         gst_vaapi_video_meta_unref(outbuf_meta);
 586
 587         GST_BUFFER_TIMESTAMP(fieldbuf) = timestamp;
 588         GST_BUFFER_DURATION(fieldbuf)  = postproc->field_duration;
 589         ret = gst_pad_push(trans->srcpad, fieldbuf);
 590         if (ret != GST_FLOW_OK)
 591             goto error_push_buffer;
 592     }
 593     fieldbuf = NULL;
 594
 595     /* Second field */
 596     outbuf_meta = gst_vaapi_video_meta_new_from_pool(postproc->filter_pool);
 597     if (!outbuf_meta)
 598         goto error_create_meta;
 599     outbuf_surface = gst_vaapi_video_meta_get_surface(outbuf_meta);
 600
 601     if (deint) {
 602         deint_flags = (tff ? 0 : GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD);
 603         if (tff)
 604             deint_flags |= GST_VAAPI_DEINTERLACE_FLAG_TFF;
 605         if (!gst_vaapi_filter_set_deinterlacing(postproc->filter,
 606                 deint_method, deint_flags))
 607             goto error_op_deinterlace;
 608
 609         if (deint_refs && !gst_vaapi_filter_set_deinterlacing_references(
 610                 postproc->filter, ds->surfaces, ds->num_surfaces, NULL, 0))
 611             goto error_op_deinterlace;
 612     }
 613     else if (deint_changed && !gst_vaapi_filter_set_deinterlacing(
 614                  postproc->filter, deint_method, 0))
 615         goto error_op_deinterlace;
 616
 617     gst_vaapi_filter_set_cropping_rectangle(postproc->filter, crop_rect);
 618     status = gst_vaapi_filter_process(postproc->filter, inbuf_surface,
 619         outbuf_surface, flags);
 620     if (status != GST_VAAPI_FILTER_STATUS_SUCCESS)
 621         goto error_process_vpp;
 622
 623     if (!(postproc->flags & GST_VAAPI_POSTPROC_FLAG_DEINTERLACE))
 624         gst_buffer_copy_into(outbuf, inbuf, GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
 625     else {
 626         GST_BUFFER_TIMESTAMP(outbuf) = timestamp + postproc->field_duration;
 627         GST_BUFFER_DURATION(outbuf)  = postproc->field_duration;
 628     }
 629     gst_buffer_set_vaapi_video_meta(outbuf, outbuf_meta);
 630     gst_vaapi_video_meta_unref(outbuf_meta);
 631
 632     if (deint && deint_refs)
 633         ds_add_buffer(ds, inbuf);
 634     return GST_FLOW_OK;
 635
 636     /* ERRORS */
 637 error_invalid_buffer:
 638     {
 639         GST_ERROR("failed to validate source buffer");
 640         return GST_FLOW_ERROR;
 641     }
 642 error_create_buffer:
 643     {
 644         GST_ERROR("failed to create output buffer");
 645         return GST_FLOW_ERROR;
 646     }
 647 error_create_meta:
 648     {
 649         GST_ERROR("failed to create new output buffer meta");
 650         gst_buffer_replace(&fieldbuf, NULL);
 651         gst_vaapi_video_meta_unref(outbuf_meta);
 652         return GST_FLOW_ERROR;
 653     }
 654 error_op_deinterlace:
 655     {
 656         GST_ERROR("failed to apply deinterlacing filter");
 657         gst_buffer_replace(&fieldbuf, NULL);
 658         gst_vaapi_video_meta_unref(outbuf_meta);
 659         return GST_FLOW_NOT_SUPPORTED;
 660     }
 661 error_process_vpp:
 662     {
 663         GST_ERROR("failed to apply VPP filters (error %d)", status);
 664         gst_buffer_replace(&fieldbuf, NULL);
 665         gst_vaapi_video_meta_unref(outbuf_meta);
 666         return GST_FLOW_ERROR;
 667     }
 668 error_push_buffer:
 669     {
 670         if (ret != GST_FLOW_FLUSHING)
 671             GST_ERROR("failed to push output buffer to video sink");
 672         return GST_FLOW_ERROR;
 673     }
 674 }
 675
 676 static GstFlowReturn
 677 gst_vaapipostproc_process(GstBaseTransform *trans, GstBuffer *inbuf,
 678     GstBuffer *outbuf)
 679 {
 680     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
 681     GstVaapiVideoMeta *meta;
 682     GstClockTime timestamp;
 683     GstFlowReturn ret;
 684     GstBuffer *fieldbuf;
 685     guint fieldbuf_flags, outbuf_flags, flags;
 686     gboolean tff, deint;
 687
 688     meta = gst_buffer_get_vaapi_video_meta(inbuf);
 689     if (!meta)
 690         goto error_invalid_buffer;
 691
 692     timestamp  = GST_BUFFER_TIMESTAMP(inbuf);
 693     tff        = GST_BUFFER_FLAG_IS_SET(inbuf, GST_VIDEO_BUFFER_FLAG_TFF);
 694     deint      = should_deinterlace_buffer(postproc, inbuf);
 695
 696     flags = gst_vaapi_video_meta_get_render_flags(meta) &
 697         ~GST_VAAPI_PICTURE_STRUCTURE_MASK;
 698
 699     /* First field */
 700     fieldbuf = create_output_buffer(postproc);
 701     if (!fieldbuf)
 702         goto error_create_buffer;
 703     append_output_buffer_metadata(fieldbuf, inbuf, 0);
 704
 705     meta = gst_buffer_get_vaapi_video_meta(fieldbuf);
 706     fieldbuf_flags = flags;
 707     fieldbuf_flags |= deint ? (
 708         tff ?
 709         GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD :
 710         GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD) :
 711         GST_VAAPI_PICTURE_STRUCTURE_FRAME;
 712     gst_vaapi_video_meta_set_render_flags(meta, fieldbuf_flags);
 713
 714     GST_BUFFER_TIMESTAMP(fieldbuf) = timestamp;
 715     GST_BUFFER_DURATION(fieldbuf)  = postproc->field_duration;
 716     ret = gst_pad_push(trans->srcpad, fieldbuf);
 717     if (ret != GST_FLOW_OK)
 718         goto error_push_buffer;
 719
 720     /* Second field */
 721     append_output_buffer_metadata(outbuf, inbuf, 0);
 722
 723     meta = gst_buffer_get_vaapi_video_meta(outbuf);
 724     outbuf_flags = flags;
 725     outbuf_flags |= deint ? (
 726         tff ?
 727         GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD :
 728         GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD) :
 729         GST_VAAPI_PICTURE_STRUCTURE_FRAME;
 730     gst_vaapi_video_meta_set_render_flags(meta, outbuf_flags);
 731
 732     GST_BUFFER_TIMESTAMP(outbuf) = timestamp + postproc->field_duration;
 733     GST_BUFFER_DURATION(outbuf)  = postproc->field_duration;
 734     return GST_FLOW_OK;
 735
 736     /* ERRORS */
 737 error_invalid_buffer:
 738     {
 739         GST_ERROR("failed to validate source buffer");
 740         return GST_FLOW_ERROR;
 741     }
 742 error_create_buffer:
 743     {
 744         GST_ERROR("failed to create output buffer");
 745         return GST_FLOW_EOS;
 746     }
 747 error_push_buffer:
 748     {
 749         if (ret != GST_FLOW_FLUSHING)
 750             GST_ERROR("failed to push output buffer to video sink");
 751         return GST_FLOW_EOS;
 752     }
 753 }
 754
 755 static GstFlowReturn
 756 gst_vaapipostproc_passthrough(GstBaseTransform *trans, GstBuffer *inbuf,
 757     GstBuffer *outbuf)
 758 {
 759     GstVaapiVideoMeta *meta;
 760
 761     /* No video processing needed, simply copy buffer metadata */
 762     meta = gst_buffer_get_vaapi_video_meta(inbuf);
 763     if (!meta)
 764         goto error_invalid_buffer;
 765
 766     append_output_buffer_metadata(outbuf, inbuf, GST_BUFFER_COPY_TIMESTAMPS);
 767     return GST_FLOW_OK;
 768
 769     /* ERRORS */
 770 error_invalid_buffer:
 771     {
 772         GST_ERROR("failed to validate source buffer");
 773         return GST_FLOW_ERROR;
 774     }
 775 }
 776
 777 static gboolean
 778 is_deinterlace_enabled(GstVaapiPostproc *postproc, GstVideoInfo *vip)
 779 {
 780     gboolean deinterlace;
 781
 782     switch (postproc->deinterlace_mode) {
 783     case GST_VAAPI_DEINTERLACE_MODE_AUTO:
 784         deinterlace = GST_VIDEO_INFO_IS_INTERLACED(vip);
 785         break;
 786     case GST_VAAPI_DEINTERLACE_MODE_INTERLACED:
 787         deinterlace = TRUE;
 788         break;
 789     default:
 790         deinterlace = FALSE;
 791         break;
 792     }
 793     return deinterlace;
 794 }
 795
 796 static gboolean
 797 video_info_changed(GstVideoInfo *old_vip, GstVideoInfo *new_vip)
 798 {
 799     if (GST_VIDEO_INFO_FORMAT(old_vip) != GST_VIDEO_INFO_FORMAT(new_vip))
 800         return TRUE;
 801     if (GST_VIDEO_INFO_INTERLACE_MODE(old_vip) !=
 802         GST_VIDEO_INFO_INTERLACE_MODE(new_vip))
 803         return TRUE;
 804     if (GST_VIDEO_INFO_WIDTH(old_vip) != GST_VIDEO_INFO_WIDTH(new_vip))
 805         return TRUE;
 806     if (GST_VIDEO_INFO_HEIGHT(old_vip) != GST_VIDEO_INFO_HEIGHT(new_vip))
 807         return TRUE;
 808     return FALSE;
 809 }
 810
 811 static gboolean
 812 gst_vaapipostproc_update_sink_caps(GstVaapiPostproc *postproc, GstCaps *caps,
 813     gboolean *caps_changed_ptr)
 814 {
 815     GstVideoInfo vi;
 816     gboolean deinterlace;
 817
 818     if (!gst_video_info_from_caps(&vi, caps))
 819         return FALSE;
 820
 821     if (video_info_changed(&vi, &postproc->sinkpad_info))
 822         postproc->sinkpad_info = vi, *caps_changed_ptr = TRUE;
 823
 824     deinterlace = is_deinterlace_enabled(postproc, &vi);
 825     if (deinterlace)
 826         postproc->flags |= GST_VAAPI_POSTPROC_FLAG_DEINTERLACE;
 827     postproc->field_duration = GST_VIDEO_INFO_FPS_N(&vi) > 0 ?
 828         gst_util_uint64_scale(GST_SECOND, GST_VIDEO_INFO_FPS_D(&vi),
 829             (1 + deinterlace) * GST_VIDEO_INFO_FPS_N(&vi)) : 0;
 830
 831     postproc->is_raw_yuv = GST_VIDEO_INFO_IS_YUV(&vi);
 832     return TRUE;
 833 }
 834
 835 static gboolean
 836 gst_vaapipostproc_update_src_caps(GstVaapiPostproc *postproc, GstCaps *caps,
 837     gboolean *caps_changed_ptr)
 838 {
 839     GstVideoInfo vi;
 840
 841     if (!gst_video_info_from_caps(&vi, caps))
 842         return FALSE;
 843
 844     if (video_info_changed(&vi, &postproc->srcpad_info))
 845         postproc->srcpad_info = vi, *caps_changed_ptr = TRUE;
 846
 847     if (postproc->format != GST_VIDEO_INFO_FORMAT(&postproc->sinkpad_info))
 848         postproc->flags |= GST_VAAPI_POSTPROC_FLAG_FORMAT;
 849
 850     if ((postproc->width || postproc->height) &&
 851         postproc->width != GST_VIDEO_INFO_WIDTH(&postproc->sinkpad_info) &&
 852         postproc->height != GST_VIDEO_INFO_HEIGHT(&postproc->sinkpad_info))
 853         postproc->flags |= GST_VAAPI_POSTPROC_FLAG_SIZE;
 854     return TRUE;
 855 }
 856
 857 static gboolean
 858 ensure_allowed_sinkpad_caps(GstVaapiPostproc *postproc)
 859 {
 860     GstCaps *out_caps, *yuv_caps;
 861
 862     if (postproc->allowed_sinkpad_caps)
 863         return TRUE;
 864
 865     /* Create VA caps */
 866 #if GST_CHECK_VERSION(1,1,0)
 867     out_caps = gst_static_pad_template_get_caps(
 868         &gst_vaapipostproc_sink_factory);
 869 #else
 870     out_caps = gst_caps_from_string(GST_VAAPI_SURFACE_CAPS ", "
 871         GST_CAPS_INTERLACED_MODES);
 872 #endif
 873     if (!out_caps) {
 874         GST_ERROR("failed to create VA sink caps");
 875         return FALSE;
 876     }
 877
 878     /* Append YUV caps */
 879     if (gst_vaapipostproc_ensure_uploader(postproc)) {
 880         yuv_caps = GST_VAAPI_PLUGIN_BASE_UPLOADER_CAPS(postproc);
 881         if (yuv_caps) {
 882             out_caps = gst_caps_make_writable(out_caps);
 883             gst_caps_append(out_caps, gst_caps_copy(yuv_caps));
 884         }
 885         else
 886             GST_WARNING("failed to create YUV sink caps");
 887     }
 888     postproc->allowed_sinkpad_caps = out_caps;
 889
 890     /* XXX: append VA/VPP filters */
 891     return TRUE;
 892 }
 893
 894 /* Fixup output caps so that to reflect the supported set of pixel formats */
 895 static GstCaps *
 896 expand_allowed_srcpad_caps(GstVaapiPostproc *postproc, GstCaps *caps)
 897 {
 898     GValue value = G_VALUE_INIT, v_format = G_VALUE_INIT;
 899     guint i, num_structures;
 900     gboolean had_filter;
 901
 902     had_filter = postproc->filter != NULL;
 903     if (!had_filter && !gst_vaapipostproc_ensure_filter(postproc))
 904         goto cleanup;
 905     if (!gst_vaapipostproc_ensure_filter_caps(postproc))
 906         goto cleanup;
 907
 908     /* Reset "format" field for each structure */
 909     if (!gst_vaapi_value_set_format_list(&value, postproc->filter_formats))
 910         goto cleanup;
 911     if (gst_vaapi_value_set_format(&v_format, GST_VIDEO_FORMAT_ENCODED)) {
 912         gst_value_list_prepend_value(&value, &v_format);
 913         g_value_unset(&v_format);
 914     }
 915
 916     num_structures = gst_caps_get_size(caps);
 917     for (i = 0; i < num_structures; i++) {
 918         GstStructure * const structure = gst_caps_get_structure(caps, i);
 919         if (!structure)
 920             continue;
 921         gst_structure_set_value(structure, "format", &value);
 922     }
 923     g_value_unset(&value);
 924
 925 cleanup:
 926     if (!had_filter)
 927         gst_vaapipostproc_destroy_filter(postproc);
 928     return caps;
 929 }
 930
 931 static gboolean
 932 ensure_allowed_srcpad_caps(GstVaapiPostproc *postproc)
 933 {
 934     GstCaps *out_caps;
 935
 936     if (postproc->allowed_srcpad_caps)
 937         return TRUE;
 938
 939     /* Create initial caps from pad template */
 940     out_caps = gst_caps_from_string(gst_vaapipostproc_src_caps_str);
 941     if (!out_caps) {
 942         GST_ERROR("failed to create VA src caps");
 943         return FALSE;
 944     }
 945
 946     postproc->allowed_srcpad_caps =
 947         expand_allowed_srcpad_caps(postproc, out_caps);
 948     return postproc->allowed_srcpad_caps != NULL;
 949 }
 950
 951 static void
 952 find_best_size(GstVaapiPostproc *postproc, GstVideoInfo *vip,
 953     guint *width_ptr, guint *height_ptr)
 954 {
 955     guint width, height;
 956
 957     width  = GST_VIDEO_INFO_WIDTH(vip);
 958     height = GST_VIDEO_INFO_HEIGHT(vip);
 959     if (postproc->width && postproc->height) {
 960         width = postproc->width;
 961         height = postproc->height;
 962     }
 963     else if (postproc->keep_aspect) {
 964         const gdouble ratio  = (gdouble)width / height;
 965         if (postproc->width) {
 966             width = postproc->width;
 967             height = postproc->width / ratio;
 968         }
 969         else if (postproc->height) {
 970             height = postproc->height;
 971             width = postproc->height * ratio;
 972         }
 973     }
 974     else if (postproc->width)
 975         width = postproc->width;
 976     else if (postproc->height)
 977         height = postproc->height;
 978
 979     *width_ptr = width;
 980     *height_ptr = height;
 981 }
 982
 983 static GstCaps *
 984 gst_vaapipostproc_transform_caps_impl(GstBaseTransform *trans,
 985     GstPadDirection direction, GstCaps *caps)
 986 {
 987     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
 988     GstVideoInfo vi;
 989     GstVideoFormat format;
 990     GstCaps *out_caps;
 991     guint width, height;
 992
 993     /* Generate the sink pad caps, that could be fixated afterwards */
 994     if (direction == GST_PAD_SRC) {
 995         if (!ensure_allowed_sinkpad_caps(postproc))
 996             return NULL;
 997         return gst_caps_ref(postproc->allowed_sinkpad_caps);
 998     }
 999
1000     /* Generate complete set of src pad caps if non-fixated sink pad
1001        caps are provided */
1002     if (!gst_caps_is_fixed(caps)) {
1003         if (!ensure_allowed_srcpad_caps(postproc))
1004             return NULL;
1005         return gst_caps_ref(postproc->allowed_srcpad_caps);
1006     }
1007
1008     /* Generate the expected src pad caps, from the current fixated
1009        sink pad caps */
1010     if (!gst_video_info_from_caps(&vi, caps))
1011         return NULL;
1012
1013     // Set double framerate in interlaced mode
1014     if (is_deinterlace_enabled(postproc, &vi)) {
1015         gint fps_n = GST_VIDEO_INFO_FPS_N(&vi);
1016         gint fps_d = GST_VIDEO_INFO_FPS_D(&vi);
1017         if (!gst_util_fraction_multiply(fps_n, fps_d, 2, 1, &fps_n, &fps_d))
1018             return NULL;
1019         GST_VIDEO_INFO_FPS_N(&vi) = fps_n;
1020         GST_VIDEO_INFO_FPS_D(&vi) = fps_d;
1021     }
1022
1023     // Signal the other pad that we only generate progressive frames
1024     GST_VIDEO_INFO_INTERLACE_MODE(&vi) = GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
1025
1026     // Update size from user-specified parameters
1027 #if GST_CHECK_VERSION(1,1,0)
1028     format = postproc->format;
1029 #else
1030     format = GST_VIDEO_FORMAT_ENCODED;
1031 #endif
1032     find_best_size(postproc, &vi, &width, &height);
1033     gst_video_info_set_format(&vi, format, width, height);
1034
1035 #if GST_CHECK_VERSION(1,1,0)
1036     out_caps = gst_video_info_to_caps(&vi);
1037     if (!out_caps)
1038         return NULL;
1039
1040     gst_caps_set_features(out_caps, 0,
1041         gst_caps_features_new(GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE, NULL));
1042 #else
1043     /* XXX: gst_video_info_to_caps() from GStreamer 0.10 does not
1044        reconstruct suitable caps for "encoded" video formats */
1045     out_caps = gst_caps_from_string(GST_VAAPI_SURFACE_CAPS_NAME);
1046     if (!out_caps)
1047         return NULL;
1048
1049     gst_caps_set_simple(out_caps,
1050         "type", G_TYPE_STRING, "vaapi",
1051         "opengl", G_TYPE_BOOLEAN, USE_GLX,
1052         "width", G_TYPE_INT, GST_VIDEO_INFO_WIDTH(&vi),
1053         "height", G_TYPE_INT, GST_VIDEO_INFO_HEIGHT(&vi),
1054         "framerate", GST_TYPE_FRACTION, GST_VIDEO_INFO_FPS_N(&vi),
1055             GST_VIDEO_INFO_FPS_D(&vi),
1056         "pixel-aspect-ratio", GST_TYPE_FRACTION, GST_VIDEO_INFO_PAR_N(&vi),
1057             GST_VIDEO_INFO_PAR_D(&vi),
1058         NULL);
1059
1060     gst_caps_set_interlaced(out_caps, &vi);
1061 #endif
1062     return out_caps;
1063 }
1064
1065 #if GST_CHECK_VERSION(1,0,0)
1066 static GstCaps *
1067 gst_vaapipostproc_transform_caps(GstBaseTransform *trans,
1068     GstPadDirection direction, GstCaps *caps, GstCaps *filter)
1069 {
1070     GstCaps *out_caps;
1071
1072     caps = gst_vaapipostproc_transform_caps_impl(trans, direction, caps);
1073     if (caps && filter) {
1074         out_caps = gst_caps_intersect_full(caps, filter,
1075             GST_CAPS_INTERSECT_FIRST);
1076         gst_caps_unref(caps);
1077         return out_caps;
1078     }
1079     return caps;
1080 }
1081 #else
1082 #define gst_vaapipostproc_transform_caps \
1083     gst_vaapipostproc_transform_caps_impl
1084 #endif
1085
1086 #if GST_CHECK_VERSION(1,0,0)
1087 typedef gsize GstBaseTransformSizeType;
1088 #else
1089 typedef guint GstBaseTransformSizeType;
1090 #endif
1091
1092 static gboolean
1093 gst_vaapipostproc_transform_size(GstBaseTransform *trans,
1094     GstPadDirection direction, GstCaps *caps, GstBaseTransformSizeType size,
1095     GstCaps *othercaps, GstBaseTransformSizeType *othersize)
1096 {
1097     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
1098
1099     if (direction == GST_PAD_SINK || !postproc->is_raw_yuv)
1100         *othersize = 0;
1101     else
1102         *othersize = size;
1103     return TRUE;
1104 }
1105
1106 static GstFlowReturn
1107 gst_vaapipostproc_transform(GstBaseTransform *trans, GstBuffer *inbuf,
1108     GstBuffer *outbuf)
1109 {
1110     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
1111     GstBuffer *buf;
1112     GstFlowReturn ret;
1113
1114     ret = gst_vaapi_plugin_base_get_input_buffer(
1115         GST_VAAPI_PLUGIN_BASE(postproc), inbuf, &buf);
1116     if (ret != GST_FLOW_OK)
1117         return GST_FLOW_ERROR;
1118
1119     ret = GST_FLOW_NOT_SUPPORTED;
1120     if (postproc->flags) {
1121         /* Use VA/VPP extensions to process this frame */
1122         if (postproc->use_vpp &&
1123             postproc->flags != GST_VAAPI_POSTPROC_FLAG_DEINTERLACE) {
1124             ret = gst_vaapipostproc_process_vpp(trans, buf, outbuf);
1125             if (ret != GST_FLOW_NOT_SUPPORTED)
1126                 goto done;
1127             GST_WARNING("unsupported VPP filters. Disabling");
1128             postproc->use_vpp = FALSE;
1129         }
1130
1131         /* Only append picture structure meta data (top/bottom field) */
1132         if (postproc->flags & GST_VAAPI_POSTPROC_FLAG_DEINTERLACE) {
1133             ret = gst_vaapipostproc_process(trans, buf, outbuf);
1134             if (ret != GST_FLOW_NOT_SUPPORTED)
1135                 goto done;
1136         }
1137     }
1138
1139     /* Fallback: passthrough to the downstream element as is */
1140     ret = gst_vaapipostproc_passthrough(trans, buf, outbuf);
1141
1142 done:
1143     gst_buffer_unref(buf);
1144     return ret;
1145 }
1146
1147 static GstFlowReturn
1148 gst_vaapipostproc_prepare_output_buffer(GstBaseTransform *trans,
1149     GstBuffer *inbuf,
1150 #if !GST_CHECK_VERSION(1,0,0)
1151     gint size, GstCaps *caps,
1152 #endif
1153     GstBuffer **outbuf_ptr)
1154 {
1155     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
1156
1157     *outbuf_ptr = create_output_buffer(postproc);
1158     return *outbuf_ptr ? GST_FLOW_OK : GST_FLOW_ERROR;
1159 }
1160
1161 static gboolean
1162 ensure_srcpad_buffer_pool(GstVaapiPostproc *postproc, GstCaps *caps)
1163 {
1164     GstVideoInfo vi;
1165     GstVaapiVideoPool *pool;
1166
1167     gst_video_info_init(&vi);
1168     gst_video_info_from_caps(&vi, caps);
1169     gst_video_info_set_format(&vi, postproc->format,
1170         GST_VIDEO_INFO_WIDTH(&vi), GST_VIDEO_INFO_HEIGHT(&vi));
1171
1172     if (postproc->filter_pool && !video_info_changed(&vi, &postproc->filter_pool_info))
1173         return TRUE;
1174     postproc->filter_pool_info = vi;
1175
1176     pool = gst_vaapi_surface_pool_new(GST_VAAPI_PLUGIN_BASE_DISPLAY(postproc),
1177         &postproc->filter_pool_info);
1178     if (!pool)
1179         return FALSE;
1180
1181     gst_vaapi_video_pool_replace(&postproc->filter_pool, pool);
1182     gst_vaapi_video_pool_unref(pool);
1183     return TRUE;
1184 }
1185
1186 static gboolean
1187 gst_vaapipostproc_set_caps(GstBaseTransform *trans, GstCaps *caps,
1188     GstCaps *out_caps)
1189 {
1190     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
1191     gboolean caps_changed = FALSE;
1192
1193     if (!gst_vaapipostproc_update_sink_caps(postproc, caps, &caps_changed))
1194         return FALSE;
1195     if (!gst_vaapipostproc_update_src_caps(postproc, out_caps, &caps_changed))
1196         return FALSE;
1197
1198     if (caps_changed) {
1199         gst_vaapipostproc_destroy(postproc);
1200         if (!gst_vaapipostproc_create(postproc))
1201             return FALSE;
1202         if (!gst_vaapi_plugin_base_set_caps(GST_VAAPI_PLUGIN_BASE(trans),
1203                 caps, out_caps))
1204             return FALSE;
1205     }
1206
1207     if (!ensure_srcpad_buffer_pool(postproc, out_caps))
1208         return FALSE;
1209     return TRUE;
1210 }
1211
1212 static gboolean
1213 gst_vaapipostproc_query(GstBaseTransform *trans, GstPadDirection direction,
1214     GstQuery *query)
1215 {
1216     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
1217
1218     GST_INFO_OBJECT(trans, "query type `%s'", GST_QUERY_TYPE_NAME(query));
1219
1220     if (gst_vaapi_reply_to_query(query, GST_VAAPI_PLUGIN_BASE_DISPLAY(postproc))) {
1221         GST_DEBUG("sharing display %p", GST_VAAPI_PLUGIN_BASE_DISPLAY(postproc));
1222         return TRUE;
1223     }
1224
1225     return GST_BASE_TRANSFORM_CLASS(gst_vaapipostproc_parent_class)->query(
1226         trans, direction, query);
1227 }
1228
1229 #if GST_CHECK_VERSION(1,0,0)
1230 static gboolean
1231 gst_vaapipostproc_propose_allocation(GstBaseTransform *trans,
1232     GstQuery *decide_query, GstQuery *query)
1233 {
1234     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(trans);
1235     GstVaapiPluginBase * const plugin = GST_VAAPI_PLUGIN_BASE(trans);
1236
1237     /* Let vaapidecode allocate the video buffers */
1238     if (!postproc->is_raw_yuv)
1239         return FALSE;
1240     if (!gst_vaapi_plugin_base_propose_allocation(plugin, query))
1241         return FALSE;
1242     return TRUE;
1243 }
1244 #endif
1245
1246 static void
1247 gst_vaapipostproc_finalize(GObject *object)
1248 {
1249     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(object);
1250
1251     gst_vaapipostproc_destroy(postproc);
1252
1253     gst_vaapi_plugin_base_finalize(GST_VAAPI_PLUGIN_BASE(postproc));
1254     G_OBJECT_CLASS(gst_vaapipostproc_parent_class)->finalize(object);
1255 }
1256
1257 static void
1258 gst_vaapipostproc_set_property(
1259     GObject      *object,
1260     guint         prop_id,
1261     const GValue *value,
1262     GParamSpec   *pspec
1263 )
1264 {
1265     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(object);
1266
1267     switch (prop_id) {
1268     case PROP_FORMAT:
1269         postproc->format = g_value_get_enum(value);
1270         break;
1271     case PROP_WIDTH:
1272         postproc->width = g_value_get_uint(value);
1273         break;
1274     case PROP_HEIGHT:
1275         postproc->height = g_value_get_uint(value);
1276         break;
1277     case PROP_FORCE_ASPECT_RATIO:
1278         postproc->keep_aspect = g_value_get_boolean(value);
1279         break;
1280     case PROP_DEINTERLACE_MODE:
1281         postproc->deinterlace_mode = g_value_get_enum(value);
1282         break;
1283     case PROP_DEINTERLACE_METHOD:
1284         postproc->deinterlace_method = g_value_get_enum(value);
1285         break;
1286      case PROP_DENOISE:
1287          postproc->denoise_level = g_value_get_float(value);
1288          postproc->flags |= GST_VAAPI_POSTPROC_FLAG_DENOISE;
1289          break;
1290      case PROP_SHARPEN:
1291          postproc->sharpen_level = g_value_get_float(value);
1292          postproc->flags |= GST_VAAPI_POSTPROC_FLAG_SHARPEN;
1293          break;
1294     case PROP_HUE:
1295         postproc->hue = g_value_get_float(value);
1296         postproc->flags |= GST_VAAPI_POSTPROC_FLAG_HUE;
1297         break;
1298     case PROP_SATURATION:
1299         postproc->saturation = g_value_get_float(value);
1300         postproc->flags |= GST_VAAPI_POSTPROC_FLAG_SATURATION;
1301         break;
1302     case PROP_BRIGHTNESS:
1303         postproc->brightness = g_value_get_float(value);
1304         postproc->flags |= GST_VAAPI_POSTPROC_FLAG_BRIGHTNESS;
1305         break;
1306     case PROP_CONTRAST:
1307         postproc->contrast = g_value_get_float(value);
1308         postproc->flags |= GST_VAAPI_POSTPROC_FLAG_CONTRAST;
1309         break;
1310     default:
1311         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
1312         break;
1313     }
1314 }
1315
1316 static void
1317 gst_vaapipostproc_get_property(
1318     GObject    *object,
1319     guint       prop_id,
1320     GValue     *value,
1321     GParamSpec *pspec
1322 )
1323 {
1324     GstVaapiPostproc * const postproc = GST_VAAPIPOSTPROC(object);
1325
1326     switch (prop_id) {
1327     case PROP_FORMAT:
1328         g_value_set_enum(value, postproc->format);
1329         break;
1330     case PROP_WIDTH:
1331         g_value_set_uint(value, postproc->width);
1332         break;
1333     case PROP_HEIGHT:
1334         g_value_set_uint(value, postproc->height);
1335         break;
1336     case PROP_FORCE_ASPECT_RATIO:
1337         g_value_set_boolean(value, postproc->keep_aspect);
1338         break;
1339     case PROP_DEINTERLACE_MODE:
1340         g_value_set_enum(value, postproc->deinterlace_mode);
1341         break;
1342     case PROP_DEINTERLACE_METHOD:
1343         g_value_set_enum(value, postproc->deinterlace_method);
1344         break;
1345     case PROP_DENOISE:
1346         g_value_set_float(value, postproc->denoise_level);
1347         break;
1348     case PROP_SHARPEN:
1349         g_value_set_float(value, postproc->sharpen_level);
1350         break;
1351     case PROP_HUE:
1352         g_value_set_float(value, postproc->hue);
1353         break;
1354     case PROP_SATURATION:
1355         g_value_set_float(value, postproc->saturation);
1356         break;
1357     case PROP_BRIGHTNESS:
1358         g_value_set_float(value, postproc->brightness);
1359         break;
1360     case PROP_CONTRAST:
1361         g_value_set_float(value, postproc->contrast);
1362         break;
1363     default:
1364         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
1365         break;
1366     }
1367 }
1368
1369 static void
1370 gst_vaapipostproc_class_init(GstVaapiPostprocClass *klass)
1371 {
1372     GObjectClass * const object_class = G_OBJECT_CLASS(klass);
1373     GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
1374     GstBaseTransformClass * const trans_class = GST_BASE_TRANSFORM_CLASS(klass);
1375     GstPadTemplate *pad_template;
1376     GPtrArray *filter_ops;
1377     GstVaapiFilterOpInfo *filter_op;
1378
1379     GST_DEBUG_CATEGORY_INIT(gst_debug_vaapipostproc,
1380                             GST_PLUGIN_NAME, 0, GST_PLUGIN_DESC);
1381
1382     gst_vaapi_plugin_base_class_init(GST_VAAPI_PLUGIN_BASE_CLASS(klass));
1383
1384     object_class->finalize      = gst_vaapipostproc_finalize;
1385     object_class->set_property  = gst_vaapipostproc_set_property;
1386     object_class->get_property  = gst_vaapipostproc_get_property;
1387     trans_class->start          = gst_vaapipostproc_start;
1388     trans_class->stop           = gst_vaapipostproc_stop;
1389     trans_class->transform_caps = gst_vaapipostproc_transform_caps;
1390     trans_class->transform_size = gst_vaapipostproc_transform_size;
1391     trans_class->transform      = gst_vaapipostproc_transform;
1392     trans_class->set_caps       = gst_vaapipostproc_set_caps;
1393     trans_class->query          = gst_vaapipostproc_query;
1394
1395 #if GST_CHECK_VERSION(1,0,0)
1396     trans_class->propose_allocation = gst_vaapipostproc_propose_allocation;
1397 #endif
1398
1399     trans_class->prepare_output_buffer =
1400         gst_vaapipostproc_prepare_output_buffer;
1401
1402     gst_element_class_set_static_metadata(element_class,
1403         "VA-API video postprocessing",
1404         "Filter/Converter/Video",
1405         GST_PLUGIN_DESC,
1406         "Gwenole Beauchesne <gwenole.beauchesne@intel.com>");
1407
1408     /* sink pad */
1409     pad_template = gst_static_pad_template_get(&gst_vaapipostproc_sink_factory);
1410     gst_element_class_add_pad_template(element_class, pad_template);
1411
1412     /* src pad */
1413     pad_template = gst_static_pad_template_get(&gst_vaapipostproc_src_factory);
1414     gst_element_class_add_pad_template(element_class, pad_template);
1415
1416     /**
1417      * GstVaapiPostproc:deinterlace-mode:
1418      *
1419      * This selects whether the deinterlacing should always be applied or if
1420      * they should only be applied on content that has the "interlaced" flag
1421      * on the caps.
1422      */
1423     g_object_class_install_property
1424         (object_class,
1425          PROP_DEINTERLACE_MODE,
1426          g_param_spec_enum("deinterlace-mode",
1427                            "Deinterlace mode",
1428                            "Deinterlace mode to use",
1429                            GST_VAAPI_TYPE_DEINTERLACE_MODE,
1430                            DEFAULT_DEINTERLACE_MODE,
1431                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1432
1433     /**
1434      * GstVaapiPostproc:deinterlace-method:
1435      *
1436      * This selects the deinterlacing method to apply.
1437      */
1438     g_object_class_install_property
1439         (object_class,
1440          PROP_DEINTERLACE_METHOD,
1441          g_param_spec_enum("deinterlace-method",
1442                            "Deinterlace method",
1443                            "Deinterlace method to use",
1444                            GST_VAAPI_TYPE_DEINTERLACE_METHOD,
1445                            DEFAULT_DEINTERLACE_METHOD,
1446                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1447
1448     filter_ops = gst_vaapi_filter_get_operations(NULL);
1449     if (!filter_ops)
1450         return;
1451
1452     /**
1453      * GstVaapiPostproc:format:
1454      *
1455      * The forced output pixel format, expressed as a #GstVideoFormat.
1456      */
1457     filter_op = find_filter_op(filter_ops, GST_VAAPI_FILTER_OP_FORMAT);
1458     if (filter_op)
1459         g_object_class_install_property(object_class,
1460             PROP_FORMAT, filter_op->pspec);
1461
1462     /**
1463      * GstVaapiPostproc:width:
1464      *
1465      * The forced output width in pixels. If set to zero, the width is
1466      * calculated from the height if aspect ration is preserved, or
1467      * inherited from the sink caps width
1468      */
1469     g_object_class_install_property
1470         (object_class,
1471          PROP_WIDTH,
1472          g_param_spec_uint("width",
1473                            "Width",
1474                            "Forced output width",
1475                            0, G_MAXINT, 0,
1476                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1477
1478     /**
1479      * GstVaapiPostproc:height:
1480      *
1481      * The forced output height in pixels. If set to zero, the height
1482      * is calculated from the width if aspect ration is preserved, or
1483      * inherited from the sink caps height
1484      */
1485     g_object_class_install_property
1486         (object_class,
1487          PROP_HEIGHT,
1488          g_param_spec_uint("height",
1489                            "Height",
1490                            "Forced output height",
1491                            0, G_MAXINT, 0,
1492                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1493
1494     /**
1495      * GstVaapiPostproc:force-aspect-ratio:
1496      *
1497      * When enabled, scaling respects video aspect ratio; when
1498      * disabled, the video is distorted to fit the width and height
1499      * properties.
1500      */
1501     g_object_class_install_property
1502         (object_class,
1503          PROP_FORCE_ASPECT_RATIO,
1504          g_param_spec_boolean("force-aspect-ratio",
1505                               "Force aspect ratio",
1506                               "When enabled, scaling will respect original aspect ratio",
1507                               TRUE,
1508                               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1509
1510     /**
1511      * GstVaapiPostproc:denoise:
1512      *
1513      * The level of noise reduction to apply.
1514      */
1515     filter_op = find_filter_op(filter_ops, GST_VAAPI_FILTER_OP_DENOISE);
1516     if (filter_op)
1517         g_object_class_install_property(object_class,
1518             PROP_DENOISE, filter_op->pspec);
1519
1520     /**
1521      * GstVaapiPostproc:sharpen:
1522      *
1523      * The level of sharpening to apply for positive values, or the
1524      * level of blurring for negative values.
1525      */
1526     filter_op = find_filter_op(filter_ops, GST_VAAPI_FILTER_OP_SHARPEN);
1527     if (filter_op)
1528         g_object_class_install_property(object_class,
1529             PROP_SHARPEN, filter_op->pspec);
1530
1531     /**
1532      * GstVaapiPostproc:hue:
1533      *
1534      * The color hue, expressed as a float value. Range is -180.0 to
1535      * 180.0. Default value is 0.0 and represents no modification.
1536      */
1537     filter_op = find_filter_op(filter_ops, GST_VAAPI_FILTER_OP_HUE);
1538     if (filter_op)
1539         g_object_class_install_property(object_class,
1540             PROP_HUE, filter_op->pspec);
1541
1542     /**
1543      * GstVaapiPostproc:saturation:
1544      *
1545      * The color saturation, expressed as a float value. Range is 0.0
1546      * to 2.0. Default value is 1.0 and represents no modification.
1547      */
1548     filter_op = find_filter_op(filter_ops, GST_VAAPI_FILTER_OP_SATURATION);
1549     if (filter_op)
1550         g_object_class_install_property(object_class,
1551             PROP_SATURATION, filter_op->pspec);
1552
1553     /**
1554      * GstVaapiPostproc:brightness:
1555      *
1556      * The color brightness, expressed as a float value. Range is -1.0
1557      * to 1.0. Default value is 0.0 and represents no modification.
1558      */
1559     filter_op = find_filter_op(filter_ops, GST_VAAPI_FILTER_OP_BRIGHTNESS);
1560     if (filter_op)
1561         g_object_class_install_property(object_class,
1562             PROP_BRIGHTNESS, filter_op->pspec);
1563
1564     /**
1565      * GstVaapiPostproc:contrast:
1566      *
1567      * The color contrast, expressed as a float value. Range is 0.0 to
1568      * 2.0. Default value is 1.0 and represents no modification.
1569      */
1570     filter_op = find_filter_op(filter_ops, GST_VAAPI_FILTER_OP_CONTRAST);
1571     if (filter_op)
1572         g_object_class_install_property(object_class,
1573             PROP_CONTRAST, filter_op->pspec);
1574
1575     g_ptr_array_unref(filter_ops);
1576 }
1577
1578 static void
1579 gst_vaapipostproc_init(GstVaapiPostproc *postproc)
1580 {
1581     gst_vaapi_plugin_base_init(GST_VAAPI_PLUGIN_BASE(postproc), GST_CAT_DEFAULT);
1582
1583     postproc->format                    = DEFAULT_FORMAT;
1584     postproc->deinterlace_mode          = DEFAULT_DEINTERLACE_MODE;
1585     postproc->deinterlace_method        = DEFAULT_DEINTERLACE_METHOD;
1586     postproc->field_duration            = GST_CLOCK_TIME_NONE;
1587     postproc->keep_aspect               = TRUE;
1588
1589     gst_video_info_init(&postproc->sinkpad_info);
1590     gst_video_info_init(&postproc->srcpad_info);
1591     gst_video_info_init(&postproc->filter_pool_info);
1592 }