subprojects/gstreamer-vaapi/gst-libs/gst/vaapi/gstvaapiutils.c

   1 /*
   2  *  gstvaapiutils.c - VA-API utilities
   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 #include "sysdeps.h"
  26 #include "gstvaapicompat.h"
  27 #include "gstvaapiutils.h"
  28 #include "gstvaapibufferproxy.h"
  29 #include "gstvaapifilter.h"
  30 #include "gstvaapisubpicture.h"
  31 #include "gstvaapisurface.h"
  32 #include <stdio.h>
  33 #include <stdarg.h>
  34
  35 #define DEBUG 1
  36 #include "gstvaapidebug.h"
  37
  38 /* string case an enum */
  39 #define STRCASEP(p, x)  STRCASE(G_PASTE(p, x))
  40 #define STRCASE(x)      case x: return G_STRINGIFY(x)
  41
  42 /* string case a macro */
  43 #define STRCASEM(p, x)  case G_PASTE(p, x): return G_STRINGIFY(x)
  44
  45 #if VA_CHECK_VERSION (0,40,0)
  46 static gchar *
  47 strip_msg (const char *message)
  48 {
  49   gchar *msg;
  50
  51   msg = g_strdup (message);
  52   if (!msg)
  53     return NULL;
  54   return g_strstrip (msg);
  55 }
  56
  57 #if VA_CHECK_VERSION (1,0,0)
  58 static void
  59 gst_vaapi_err (void *data, const char *message)
  60 {
  61   gchar *msg;
  62
  63   msg = strip_msg (message);
  64   if (!msg)
  65     return;
  66   GST_ERROR ("%s", msg);
  67   g_free (msg);
  68 }
  69
  70 static void
  71 gst_vaapi_warning (void *data, const char *message)
  72 {
  73   gchar *msg;
  74
  75   msg = strip_msg (message);
  76   if (!msg)
  77     return;
  78   GST_WARNING ("%s", msg);
  79   g_free (msg);
  80 }
  81 #endif
  82
  83 static void
  84 gst_vaapi_log (
  85 #if VA_CHECK_VERSION (1,0,0)
  86     void *data,
  87 #endif
  88     const char *message)
  89 {
  90   gchar *msg;
  91
  92   msg = strip_msg (message);
  93   if (!msg)
  94     return;
  95   GST_INFO ("%s", msg);
  96   g_free (msg);
  97 }
  98 #endif
  99
 100 gboolean
 101 vaapi_initialize (VADisplay dpy)
 102 {
 103   gint major_version, minor_version;
 104   VAStatus status;
 105
 106 #if VA_CHECK_VERSION (1,0,0)
 107   vaSetErrorCallback (dpy, gst_vaapi_warning, NULL);
 108   vaSetInfoCallback (dpy, gst_vaapi_log, NULL);
 109 #elif VA_CHECK_VERSION (0,40,0)
 110   vaSetInfoCallback (gst_vaapi_log);
 111 #endif
 112
 113   status = vaInitialize (dpy, &major_version, &minor_version);
 114
 115 #if VA_CHECK_VERSION (1,0,0)
 116   vaSetErrorCallback (dpy, gst_vaapi_err, NULL);
 117 #endif
 118
 119   if (!vaapi_check_status (status, "vaInitialize()"))
 120     return FALSE;
 121
 122   GST_INFO ("VA-API version %d.%d", major_version, minor_version);
 123   return TRUE;
 124 }
 125
 126 /* Check VA status for success or print out an error */
 127 gboolean
 128 vaapi_check_status (VAStatus status, const gchar * msg)
 129 {
 130   if (status != VA_STATUS_SUCCESS) {
 131     GST_DEBUG ("%s: %s", msg, vaErrorStr (status));
 132     return FALSE;
 133   }
 134   return TRUE;
 135 }
 136
 137 /* Maps VA buffer */
 138 gpointer
 139 vaapi_map_buffer (VADisplay dpy, VABufferID buf_id)
 140 {
 141   VAStatus status;
 142   gpointer data = NULL;
 143
 144   status = vaMapBuffer (dpy, buf_id, &data);
 145   if (!vaapi_check_status (status, "vaMapBuffer()"))
 146     return NULL;
 147   return data;
 148 }
 149
 150 /* Unmaps VA buffer */
 151 void
 152 vaapi_unmap_buffer (VADisplay dpy, VABufferID buf_id, gpointer * pbuf)
 153 {
 154   VAStatus status;
 155
 156   if (pbuf)
 157     *pbuf = NULL;
 158
 159   status = vaUnmapBuffer (dpy, buf_id);
 160   if (!vaapi_check_status (status, "vaUnmapBuffer()"))
 161     return;
 162 }
 163
 164 /* Creates and maps VA buffer */
 165 gboolean
 166 vaapi_create_buffer (VADisplay dpy, VAContextID ctx, int type, guint size,
 167     gconstpointer buf, VABufferID * buf_id_ptr, gpointer * mapped_data)
 168 {
 169   return vaapi_create_n_elements_buffer (dpy, ctx, type, size, buf, buf_id_ptr,
 170       mapped_data, 1);
 171 }
 172
 173 gboolean
 174 vaapi_create_n_elements_buffer (VADisplay dpy, VAContextID ctx, int type,
 175     guint size, gconstpointer buf, VABufferID * buf_id_ptr,
 176     gpointer * mapped_data, int num_elements)
 177 {
 178   VABufferID buf_id;
 179   VAStatus status;
 180   gpointer data = (gpointer) buf;
 181
 182   status = vaCreateBuffer (dpy, ctx, type, size, num_elements, data, &buf_id);
 183   if (!vaapi_check_status (status, "vaCreateBuffer()"))
 184     return FALSE;
 185
 186   if (mapped_data) {
 187     data = vaapi_map_buffer (dpy, buf_id);
 188     if (!data)
 189       goto error;
 190     *mapped_data = data;
 191   }
 192
 193   *buf_id_ptr = buf_id;
 194   return TRUE;
 195
 196   /* ERRORS */
 197 error:
 198   {
 199     vaapi_destroy_buffer (dpy, &buf_id);
 200     return FALSE;
 201   }
 202 }
 203
 204 /* Destroy VA buffer */
 205 void
 206 vaapi_destroy_buffer (VADisplay dpy, VABufferID * buf_id_ptr)
 207 {
 208   if (!buf_id_ptr || *buf_id_ptr == VA_INVALID_ID)
 209     return;
 210
 211   vaDestroyBuffer (dpy, *buf_id_ptr);
 212   *buf_id_ptr = VA_INVALID_ID;
 213 }
 214
 215 /* Return a string representation of a VAProfile */
 216 const gchar *
 217 string_of_VAProfile (VAProfile profile)
 218 {
 219   switch (profile) {
 220 #define MAP(profile) \
 221         STRCASEP(VAProfile, profile)
 222       MAP (MPEG2Simple);
 223       MAP (MPEG2Main);
 224       MAP (MPEG4Simple);
 225       MAP (MPEG4AdvancedSimple);
 226       MAP (MPEG4Main);
 227       MAP (JPEGBaseline);
 228       MAP (H263Baseline);
 229       MAP (H264ConstrainedBaseline);
 230 #if !VA_CHECK_VERSION(1,0,0)
 231       MAP (H264Baseline);
 232 #endif
 233       MAP (H264Main);
 234       MAP (H264High);
 235       MAP (H264MultiviewHigh);
 236       MAP (H264StereoHigh);
 237 #if VA_CHECK_VERSION(1,2,0)
 238       MAP (HEVCMain422_10);
 239       MAP (HEVCMain444);
 240       MAP (HEVCMain444_10);
 241       MAP (HEVCSccMain);
 242       MAP (HEVCSccMain10);
 243       MAP (HEVCSccMain444);
 244 #endif
 245 #if VA_CHECK_VERSION(1,8,0)
 246       MAP (HEVCSccMain444_10);
 247 #endif
 248       MAP (HEVCMain);
 249       MAP (HEVCMain10);
 250       MAP (VC1Simple);
 251       MAP (VC1Main);
 252       MAP (VC1Advanced);
 253       MAP (VP8Version0_3);
 254       MAP (VP9Profile0);
 255       MAP (VP9Profile1);
 256       MAP (VP9Profile2);
 257       MAP (VP9Profile3);
 258 #if VA_CHECK_VERSION(1,8,0)
 259       MAP (AV1Profile0);
 260       MAP (AV1Profile1);
 261 #endif
 262 #undef MAP
 263     default:
 264       break;
 265   }
 266   return "<unknown>";
 267 }
 268
 269 /* Return a string representation of a VAEntrypoint */
 270 const gchar *
 271 string_of_VAEntrypoint (VAEntrypoint entrypoint)
 272 {
 273   switch (entrypoint) {
 274 #define MAP(entrypoint) \
 275         STRCASEP(VAEntrypoint, entrypoint)
 276       MAP (VLD);
 277       MAP (IZZ);
 278       MAP (IDCT);
 279       MAP (MoComp);
 280       MAP (Deblocking);
 281       MAP (EncSlice);
 282       MAP (EncPicture);
 283 #if VA_CHECK_VERSION(0,39,1)
 284       MAP (EncSliceLP);
 285 #endif
 286       MAP (VideoProc);
 287 #if VA_CHECK_VERSION(1,0,0)
 288       MAP (FEI);
 289 #endif
 290 #undef MAP
 291     default:
 292       break;
 293   }
 294   return "<unknown>";
 295 }
 296
 297 /* Return a string representation of a VADisplayAttributeType */
 298 const gchar *
 299 string_of_VADisplayAttributeType (VADisplayAttribType attribute_type)
 300 {
 301   switch (attribute_type) {
 302 #define MAP(attribute_type) \
 303         STRCASEP(VADisplayAttrib, attribute_type)
 304       MAP (Brightness);
 305       MAP (Contrast);
 306       MAP (Hue);
 307       MAP (Saturation);
 308       MAP (BackgroundColor);
 309       MAP (Rotation);
 310       MAP (OutofLoopDeblock);
 311       MAP (CSCMatrix);
 312       MAP (BlendColor);
 313       MAP (OverlayAutoPaintColorKey);
 314       MAP (OverlayColorKey);
 315       MAP (RenderMode);
 316       MAP (RenderDevice);
 317       MAP (RenderRect);
 318 #undef MAP
 319     default:
 320       break;
 321   }
 322   return "<unknown>";
 323 }
 324
 325 /* Return a string representation of a VA chroma format */
 326 const gchar *
 327 string_of_va_chroma_format (guint chroma_format)
 328 {
 329   switch (chroma_format) {
 330 #define MAP(value) \
 331         STRCASEM(VA_RT_FORMAT_, value)
 332       MAP (YUV420);
 333       MAP (YUV422);
 334       MAP (YUV444);
 335       MAP (YUV400);
 336       MAP (RGB16);
 337       MAP (RGB32);
 338       MAP (RGBP);
 339       MAP (YUV420_10BPP);
 340 #if VA_CHECK_VERSION(1,2,0)
 341       MAP (YUV422_10);
 342       MAP (YUV444_10);
 343       MAP (YUV420_12);
 344       MAP (YUV422_12);
 345       MAP (YUV444_12);
 346       MAP (RGB32_10);
 347 #endif
 348 #undef MAP
 349     default:
 350       break;
 351   }
 352   return "<unknown>";
 353 }
 354
 355 const gchar *
 356 string_of_VARateControl (guint rate_control)
 357 {
 358   switch (rate_control) {
 359     case VA_RC_NONE:
 360       return "None";
 361     case VA_RC_CQP:
 362       return "CQP";
 363     case VA_RC_CBR:
 364       return "CBR";
 365     case VA_RC_VCM:
 366       return "VCM";
 367     case VA_RC_VBR:
 368       return "VBR";
 369     case VA_RC_VBR_CONSTRAINED:
 370       return "VBR-Constrained";
 371 #if VA_CHECK_VERSION(0,39,1)
 372     case VA_RC_MB:
 373       return "MB";
 374 #endif
 375 #if VA_CHECK_VERSION(1,1,0)
 376     case VA_RC_ICQ:
 377       return "VA_RC_ICQ";
 378 #endif
 379 #if VA_CHECK_VERSION(1,3,0)
 380     case VA_RC_QVBR:
 381       return "VA_RC_QVBR";
 382 #endif
 383     default:
 384       break;
 385   }
 386   return "<unknown>";
 387 }
 388
 389 /**
 390  * to_GstVaapiChromaType:
 391  * @va_rt_format: the value of VAConfigAttribRTFormat
 392  *
 393  * Converts the VA_RT_FORMAT_* to #GstVaapiChromaType
 394  *
 395  * Returns: the #GstVaapiChromaType associated to @va_rt_format or
 396  * zero.
 397  **/
 398 guint
 399 to_GstVaapiChromaType (guint va_rt_format)
 400 {
 401   if (va_rt_format & VA_RT_FORMAT_YUV420)
 402     return GST_VAAPI_CHROMA_TYPE_YUV420;
 403   if (va_rt_format & VA_RT_FORMAT_YUV422)
 404     return GST_VAAPI_CHROMA_TYPE_YUV422;
 405   if (va_rt_format & VA_RT_FORMAT_YUV444)
 406     return GST_VAAPI_CHROMA_TYPE_YUV444;
 407   if (va_rt_format & VA_RT_FORMAT_YUV411)
 408     return GST_VAAPI_CHROMA_TYPE_YUV411;
 409   if (va_rt_format & VA_RT_FORMAT_YUV400)
 410     return GST_VAAPI_CHROMA_TYPE_YUV400;
 411   if (va_rt_format & VA_RT_FORMAT_RGB32)
 412     return GST_VAAPI_CHROMA_TYPE_RGB32;
 413   if (va_rt_format & VA_RT_FORMAT_RGB16)
 414     return GST_VAAPI_CHROMA_TYPE_RGB16;
 415   if (va_rt_format & VA_RT_FORMAT_RGBP)
 416     return GST_VAAPI_CHROMA_TYPE_RGBP;
 417   if (va_rt_format & VA_RT_FORMAT_YUV420_10BPP)
 418     return GST_VAAPI_CHROMA_TYPE_YUV420_10BPP;
 419 #if VA_CHECK_VERSION(1,2,0)
 420   if (va_rt_format & VA_RT_FORMAT_YUV422_10)
 421     return GST_VAAPI_CHROMA_TYPE_YUV422_10BPP;
 422   if (va_rt_format & VA_RT_FORMAT_YUV444_10)
 423     return GST_VAAPI_CHROMA_TYPE_YUV444_10BPP;
 424   if (va_rt_format & VA_RT_FORMAT_YUV420_12)
 425     return GST_VAAPI_CHROMA_TYPE_YUV420_12BPP;
 426   if (va_rt_format & VA_RT_FORMAT_YUV422_12)
 427     return GST_VAAPI_CHROMA_TYPE_YUV422_12BPP;
 428   if (va_rt_format & VA_RT_FORMAT_YUV444_12)
 429     return GST_VAAPI_CHROMA_TYPE_YUV444_12BPP;
 430   if (va_rt_format & VA_RT_FORMAT_RGB32_10)
 431     return GST_VAAPI_CHROMA_TYPE_RGB32_10BPP;
 432 #endif
 433   return 0;
 434 }
 435
 436 /**
 437  * from_GstVaapiChromaType:
 438  * @chroma_type: the #GstVaapiChromaType
 439  *
 440  * Converts #GstVaapiChromaType to a chroma format suitable for
 441  * vaCreateSurfaces().
 442  */
 443 guint
 444 from_GstVaapiChromaType (guint chroma_type)
 445 {
 446   guint format;
 447
 448   switch (chroma_type) {
 449     case GST_VAAPI_CHROMA_TYPE_YUV420:
 450       format = VA_RT_FORMAT_YUV420;
 451       break;
 452     case GST_VAAPI_CHROMA_TYPE_YUV422:
 453       format = VA_RT_FORMAT_YUV422;
 454       break;
 455     case GST_VAAPI_CHROMA_TYPE_YUV444:
 456       format = VA_RT_FORMAT_YUV444;
 457       break;
 458     case GST_VAAPI_CHROMA_TYPE_YUV411:
 459       format = VA_RT_FORMAT_YUV411;
 460       break;
 461     case GST_VAAPI_CHROMA_TYPE_YUV400:
 462       format = VA_RT_FORMAT_YUV400;
 463       break;
 464     case GST_VAAPI_CHROMA_TYPE_RGB32:
 465       format = VA_RT_FORMAT_RGB32;
 466       break;
 467     case GST_VAAPI_CHROMA_TYPE_RGB16:
 468       format = VA_RT_FORMAT_RGB16;
 469       break;
 470     case GST_VAAPI_CHROMA_TYPE_RGBP:
 471       format = VA_RT_FORMAT_RGBP;
 472       break;
 473     case GST_VAAPI_CHROMA_TYPE_YUV420_10BPP:
 474       format = VA_RT_FORMAT_YUV420_10BPP;
 475       break;
 476 #if VA_CHECK_VERSION(1,2,0)
 477     case GST_VAAPI_CHROMA_TYPE_YUV422_10BPP:
 478       format = VA_RT_FORMAT_YUV422_10;
 479       break;
 480     case GST_VAAPI_CHROMA_TYPE_YUV444_10BPP:
 481       format = VA_RT_FORMAT_YUV444_10;
 482       break;
 483     case GST_VAAPI_CHROMA_TYPE_YUV420_12BPP:
 484       format = VA_RT_FORMAT_YUV420_12;
 485       break;
 486     case GST_VAAPI_CHROMA_TYPE_YUV422_12BPP:
 487       format = VA_RT_FORMAT_YUV422_12;
 488       break;
 489     case GST_VAAPI_CHROMA_TYPE_YUV444_12BPP:
 490       format = VA_RT_FORMAT_YUV444_12;
 491       break;
 492     case GST_VAAPI_CHROMA_TYPE_RGB32_10BPP:
 493       format = VA_RT_FORMAT_RGB32_10;
 494       break;
 495 #endif
 496     default:
 497       format = 0;
 498       break;
 499   }
 500   return format;
 501 }
 502
 503 /**
 504  * from_GstVaapiSubpictureFlags:
 505  * @flags: the #GstVaapiSubpictureFlags
 506  *
 507  * Converts #GstVaapiSubpictureFlags to flags suitable for
 508  * vaAssociateSubpicture().
 509  */
 510 guint
 511 from_GstVaapiSubpictureFlags (guint flags)
 512 {
 513   guint va_flags = 0;
 514
 515   if (flags & GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA)
 516     va_flags |= VA_SUBPICTURE_GLOBAL_ALPHA;
 517 #ifdef VA_SUBPICTURE_PREMULTIPLIED_ALPHA
 518   if (flags & GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA)
 519     flags |= VA_SUBPICTURE_PREMULTIPLIED_ALPHA;
 520 #endif
 521   return va_flags;
 522 }
 523
 524 /**
 525  * to_GstVaapiSubpictureFlags:
 526  * @flags: the #GstVaapiSubpictureFlags flags to translate
 527  *
 528  * Converts vaQuerySubpictureFormats() @flags to #GstVaapiSubpictureFlags
 529  * flags.
 530  *
 531  * Return value: the #GstVaapiSubpictureFlags flags
 532  */
 533 guint
 534 to_GstVaapiSubpictureFlags (guint va_flags)
 535 {
 536   guint flags = 0;
 537
 538   if (va_flags & VA_SUBPICTURE_GLOBAL_ALPHA)
 539     flags |= GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA;
 540 #ifdef VA_SUBPICTURE_PREMULTIPLIED_ALPHA
 541   if (va_flags & VA_SUBPICTURE_PREMULTIPLIED_ALPHA)
 542     flags |= GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA;
 543 #endif
 544   return flags;
 545 }
 546
 547 /**
 548  * from_GstVideoOverlayFormatFlags:
 549  * @flags: the #GstVideoOverlayFormatFlags flags to translate
 550  *
 551  * Converts #GstVaapiSubpictureFlags to #GstVaapiSubpictureFlags.
 552  *
 553  * Return value: the #GstVaapiSubpictureFlags flags
 554  */
 555 guint
 556 from_GstVideoOverlayFormatFlags (guint ovl_flags)
 557 {
 558   guint flags = 0;
 559
 560   if (ovl_flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)
 561     flags |= GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA;
 562   if (ovl_flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA)
 563     flags |= GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA;
 564   return flags;
 565 }
 566
 567 /**
 568  * to_GstVideoOverlayFormatFlags:
 569  * @flags: the #GstVaapiSubpictureFlags flags to translate
 570  *
 571  * Converts #GstVaapiSubpictureFlags to #GstVideoOverlayFormatFlags.
 572  *
 573  * Return value: the #GstVideoOverlayFormatFlags flags
 574  */
 575 guint
 576 to_GstVideoOverlayFormatFlags (guint flags)
 577 {
 578   guint ovl_flags = 0;
 579
 580   if (flags & GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA)
 581     ovl_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA;
 582   if (flags & GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA)
 583     ovl_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA;
 584   return ovl_flags;
 585 }
 586
 587 /**
 588  * from_GstVaapiSurfaceRenderFlags:
 589  * @flags: the #GstVaapiSurfaceRenderFlags
 590  *
 591  * Converts #GstVaapiSurfaceRenderFlags to flags suitable for
 592  * vaPutSurface().
 593  */
 594 guint
 595 from_GstVaapiSurfaceRenderFlags (guint flags)
 596 {
 597   guint va_fields, va_csc;
 598
 599   /* Picture structure */
 600   switch (flags & GST_VAAPI_PICTURE_STRUCTURE_MASK) {
 601     case GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD:
 602       va_fields = VA_TOP_FIELD;
 603       break;
 604     case GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD:
 605       va_fields = VA_BOTTOM_FIELD;
 606       break;
 607     default:
 608       va_fields = VA_FRAME_PICTURE;
 609       break;
 610   }
 611
 612   /* Color standard */
 613   switch (flags & GST_VAAPI_COLOR_STANDARD_MASK) {
 614 #ifdef VA_SRC_BT601
 615     case GST_VAAPI_COLOR_STANDARD_ITUR_BT_601:
 616       va_csc = VA_SRC_BT601;
 617       break;
 618 #endif
 619 #ifdef VA_SRC_BT709
 620     case GST_VAAPI_COLOR_STANDARD_ITUR_BT_709:
 621       va_csc = VA_SRC_BT709;
 622       break;
 623 #endif
 624 #ifdef VA_SRC_SMPTE_240
 625     case GST_VAAPI_COLOR_STANDARD_SMPTE_240M:
 626       va_csc = VA_SRC_SMPTE_240;
 627       break;
 628 #endif
 629     default:
 630       va_csc = 0;
 631       break;
 632   }
 633   return va_fields | va_csc;
 634 }
 635
 636 /**
 637  * to_GstVaapiSurfaceStatus:
 638  * @flags: the #GstVaapiSurfaceStatus flags to translate
 639  *
 640  * Converts vaQuerySurfaceStatus() @flags to #GstVaapiSurfaceStatus
 641  * flags.
 642  *
 643  * Return value: the #GstVaapiSurfaceStatus flags
 644  */
 645 guint
 646 to_GstVaapiSurfaceStatus (guint va_flags)
 647 {
 648   guint flags;
 649   const guint va_flags_mask = (VASurfaceReady |
 650       VASurfaceRendering | VASurfaceDisplaying);
 651
 652   /* Check for core status */
 653   switch (va_flags & va_flags_mask) {
 654     case VASurfaceReady:
 655       flags = GST_VAAPI_SURFACE_STATUS_IDLE;
 656       break;
 657     case VASurfaceRendering:
 658       flags = GST_VAAPI_SURFACE_STATUS_RENDERING;
 659       break;
 660     case VASurfaceDisplaying:
 661       flags = GST_VAAPI_SURFACE_STATUS_DISPLAYING;
 662       break;
 663     default:
 664       flags = 0;
 665       break;
 666   }
 667
 668   /* Check for encoder status */
 669   if (va_flags & VASurfaceSkipped)
 670     flags |= GST_VAAPI_SURFACE_STATUS_SKIPPED;
 671   return flags;
 672 }
 673
 674 /* Translate GstVaapiRotation value to VA-API rotation value */
 675 guint
 676 from_GstVaapiRotation (guint value)
 677 {
 678   switch (value) {
 679     case GST_VAAPI_ROTATION_0:
 680       return VA_ROTATION_NONE;
 681     case GST_VAAPI_ROTATION_90:
 682       return VA_ROTATION_90;
 683     case GST_VAAPI_ROTATION_180:
 684       return VA_ROTATION_180;
 685     case GST_VAAPI_ROTATION_270:
 686       return VA_ROTATION_270;
 687   }
 688   GST_ERROR ("unsupported GstVaapiRotation value %d", value);
 689   return VA_ROTATION_NONE;
 690 }
 691
 692 /* Translate VA-API rotation value to GstVaapiRotation value */
 693 guint
 694 to_GstVaapiRotation (guint value)
 695 {
 696   switch (value) {
 697     case VA_ROTATION_NONE:
 698       return GST_VAAPI_ROTATION_0;
 699     case VA_ROTATION_90:
 700       return GST_VAAPI_ROTATION_90;
 701     case VA_ROTATION_180:
 702       return GST_VAAPI_ROTATION_180;
 703     case VA_ROTATION_270:
 704       return GST_VAAPI_ROTATION_270;
 705   }
 706   GST_ERROR ("unsupported VA-API rotation value %d", value);
 707   return GST_VAAPI_ROTATION_0;
 708 }
 709
 710 guint
 711 from_GstVaapiRateControl (guint value)
 712 {
 713   switch (value) {
 714     case GST_VAAPI_RATECONTROL_NONE:
 715       return VA_RC_NONE;
 716     case GST_VAAPI_RATECONTROL_CQP:
 717       return VA_RC_CQP;
 718     case GST_VAAPI_RATECONTROL_CBR:
 719       return VA_RC_CBR;
 720     case GST_VAAPI_RATECONTROL_VCM:
 721       return VA_RC_VCM;
 722     case GST_VAAPI_RATECONTROL_VBR:
 723       return VA_RC_VBR;
 724     case GST_VAAPI_RATECONTROL_VBR_CONSTRAINED:
 725       return VA_RC_VBR_CONSTRAINED;
 726 #if VA_CHECK_VERSION(0,39,1)
 727     case GST_VAAPI_RATECONTROL_MB:
 728       return VA_RC_MB;
 729 #endif
 730 #if VA_CHECK_VERSION(1,1,0)
 731     case GST_VAAPI_RATECONTROL_ICQ:
 732       return VA_RC_ICQ;
 733 #endif
 734 #if VA_CHECK_VERSION(1,3,0)
 735     case GST_VAAPI_RATECONTROL_QVBR:
 736       return VA_RC_QVBR;
 737 #endif
 738   }
 739   GST_ERROR ("unsupported GstVaapiRateControl value %u", value);
 740   return VA_RC_NONE;
 741 }
 742
 743 guint
 744 to_GstVaapiRateControl (guint value)
 745 {
 746   switch (value) {
 747     case VA_RC_NONE:
 748       return GST_VAAPI_RATECONTROL_NONE;
 749     case VA_RC_CQP:
 750       return GST_VAAPI_RATECONTROL_CQP;
 751     case VA_RC_CBR:
 752       return GST_VAAPI_RATECONTROL_CBR;
 753     case VA_RC_VCM:
 754       return GST_VAAPI_RATECONTROL_VCM;
 755     case VA_RC_VBR:
 756       return GST_VAAPI_RATECONTROL_VBR;
 757     case VA_RC_VBR_CONSTRAINED:
 758       return GST_VAAPI_RATECONTROL_VBR_CONSTRAINED;
 759 #if VA_CHECK_VERSION(0,39,1)
 760     case VA_RC_MB:
 761       return GST_VAAPI_RATECONTROL_MB;
 762 #endif
 763 #if VA_CHECK_VERSION(1,1,0)
 764     case VA_RC_ICQ:
 765       return GST_VAAPI_RATECONTROL_ICQ;
 766 #endif
 767 #if VA_CHECK_VERSION(1,3,0)
 768     case VA_RC_QVBR:
 769       return GST_VAAPI_RATECONTROL_QVBR;
 770 #endif
 771
 772   }
 773   GST_ERROR ("unsupported VA-API Rate Control value %u", value);
 774   return GST_VAAPI_RATECONTROL_NONE;
 775 }
 776
 777 /* VPP: translate GstVaapiDeinterlaceMethod to VA deinterlacing algorithm */
 778 guint
 779 from_GstVaapiDeinterlaceMethod (guint value)
 780 {
 781   switch (value) {
 782     case GST_VAAPI_DEINTERLACE_METHOD_NONE:
 783       return 0;
 784     case GST_VAAPI_DEINTERLACE_METHOD_BOB:
 785       return VAProcDeinterlacingBob;
 786     case GST_VAAPI_DEINTERLACE_METHOD_WEAVE:
 787       return VAProcDeinterlacingWeave;
 788     case GST_VAAPI_DEINTERLACE_METHOD_MOTION_ADAPTIVE:
 789       return VAProcDeinterlacingMotionAdaptive;
 790     case GST_VAAPI_DEINTERLACE_METHOD_MOTION_COMPENSATED:
 791       return VAProcDeinterlacingMotionCompensated;
 792   }
 793   GST_ERROR ("unsupported GstVaapiDeinterlaceMethod value %d", value);
 794   return 0;
 795 }
 796
 797 /* VPP: translate GstVaapiDeinterlaceFlags into VA deinterlacing flags */
 798 guint
 799 from_GstVaapiDeinterlaceFlags (guint flags)
 800 {
 801   guint va_flags = 0;
 802
 803   if (!(flags & GST_VAAPI_DEINTERLACE_FLAG_TFF))
 804     va_flags |= VA_DEINTERLACING_BOTTOM_FIELD_FIRST;
 805
 806   if (flags & GST_VAAPI_DEINTERLACE_FLAG_ONEFIELD)
 807     va_flags |= VA_DEINTERLACING_ONE_FIELD;
 808
 809   if (!(flags & GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD))
 810     va_flags |= VA_DEINTERLACING_BOTTOM_FIELD;
 811   return va_flags;
 812 }
 813
 814 /* VPP: translate GstVaapiScaleMethod into VA scaling flags */
 815 guint
 816 from_GstVaapiScaleMethod (guint value)
 817 {
 818   guint va_flags;
 819
 820   switch (value) {
 821     case GST_VAAPI_SCALE_METHOD_DEFAULT:
 822       va_flags = VA_FILTER_SCALING_DEFAULT;
 823       break;
 824     case GST_VAAPI_SCALE_METHOD_FAST:
 825       va_flags = VA_FILTER_SCALING_FAST;
 826       break;
 827     case GST_VAAPI_SCALE_METHOD_HQ:
 828       va_flags = VA_FILTER_SCALING_HQ;
 829       break;
 830     default:
 831       va_flags = 0;
 832       break;
 833   }
 834   return va_flags;
 835 }
 836
 837 /* VPP: translate VA scaling flags into GstVaapiScale Method */
 838 guint
 839 to_GstVaapiScaleMethod (guint flags)
 840 {
 841   GstVaapiScaleMethod method;
 842
 843   switch (flags) {
 844     case VA_FILTER_SCALING_FAST:
 845       method = GST_VAAPI_SCALE_METHOD_FAST;
 846       break;
 847     case VA_FILTER_SCALING_HQ:
 848       method = GST_VAAPI_SCALE_METHOD_HQ;
 849       break;
 850     default:
 851       method = GST_VAAPI_SCALE_METHOD_DEFAULT;
 852       break;
 853   }
 854   return method;
 855 }
 856
 857 /* VPP: translate GstVideoOrientationMethod into VA mirror/rotation flags */
 858 void
 859 from_GstVideoOrientationMethod (guint value, guint * va_mirror,
 860     guint * va_rotation)
 861 {
 862   *va_mirror = 0;
 863   *va_rotation = 0;
 864
 865   switch (value) {
 866 #if VA_CHECK_VERSION(1,1,0)
 867     case GST_VIDEO_ORIENTATION_IDENTITY:
 868       *va_mirror = VA_MIRROR_NONE;
 869       *va_rotation = VA_ROTATION_NONE;
 870       break;
 871     case GST_VIDEO_ORIENTATION_HORIZ:
 872       *va_mirror = VA_MIRROR_HORIZONTAL;
 873       *va_rotation = VA_ROTATION_NONE;
 874       break;
 875     case GST_VIDEO_ORIENTATION_VERT:
 876       *va_mirror = VA_MIRROR_VERTICAL;
 877       *va_rotation = VA_ROTATION_NONE;
 878       break;
 879     case GST_VIDEO_ORIENTATION_90R:
 880       *va_mirror = VA_MIRROR_NONE;
 881       *va_rotation = VA_ROTATION_90;
 882       break;
 883     case GST_VIDEO_ORIENTATION_180:
 884       *va_mirror = VA_MIRROR_NONE;
 885       *va_rotation = VA_ROTATION_180;
 886       break;
 887     case GST_VIDEO_ORIENTATION_90L:
 888       *va_mirror = VA_MIRROR_NONE;
 889       *va_rotation = VA_ROTATION_270;
 890       break;
 891     case GST_VIDEO_ORIENTATION_UL_LR:
 892       *va_mirror = VA_MIRROR_HORIZONTAL;
 893       *va_rotation = VA_ROTATION_90;
 894       break;
 895     case GST_VIDEO_ORIENTATION_UR_LL:
 896       *va_mirror = VA_MIRROR_VERTICAL;
 897       *va_rotation = VA_ROTATION_90;
 898       break;
 899 #endif
 900     default:
 901       break;
 902   }
 903 }
 904
 905 /**
 906  * from_GstVaapiBufferMemoryType:
 907  * @type: a #GstVaapiBufferMemoryType
 908  *
 909  * Returns: the VA's memory type symbol
 910  **/
 911 guint
 912 from_GstVaapiBufferMemoryType (guint type)
 913 {
 914   guint va_type;
 915
 916   switch (type) {
 917 #if VA_CHECK_VERSION(1,1,0)
 918     case GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF2:
 919       va_type = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
 920       break;
 921 #endif
 922     case GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF:
 923       va_type = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
 924       break;
 925     case GST_VAAPI_BUFFER_MEMORY_TYPE_GEM_BUF:
 926       va_type = VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM;
 927       break;
 928     case GST_VAAPI_BUFFER_MEMORY_TYPE_V4L2:
 929       va_type = VA_SURFACE_ATTRIB_MEM_TYPE_V4L2;
 930       break;
 931     case GST_VAAPI_BUFFER_MEMORY_TYPE_USER_PTR:
 932       va_type = VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR;
 933       break;
 934     default:
 935       va_type = 0;
 936       break;
 937   }
 938   return va_type;
 939 }
 940
 941 /**
 942  * to_GstVaapiBufferMemoryType:
 943  * @va_type: a VA's memory type symbol
 944  *
 945  * It will return the first "supported" memory type from @va_type bit
 946  * flag.
 947  *
 948  * Returns: a #GstVaapiBufferMemoryType or 0 if unknown.
 949  **/
 950 guint
 951 to_GstVaapiBufferMemoryType (guint va_type)
 952 {
 953 #if VA_CHECK_VERSION(1,1,0)
 954   if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2))
 955     return GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF2;
 956 #endif
 957   if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME))
 958     return GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF;
 959   if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM))
 960     return GST_VAAPI_BUFFER_MEMORY_TYPE_GEM_BUF;
 961   if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_V4L2))
 962     return GST_VAAPI_BUFFER_MEMORY_TYPE_V4L2;
 963   if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR))
 964     return GST_VAAPI_BUFFER_MEMORY_TYPE_USER_PTR;
 965   return 0;
 966 }
 967
 968 /**
 969  * from_GstVideoColorimetry:
 970  * @colorimetry: a #GstVideoColorimetry type
 971  *
 972  * VPP: maps the #GstVideoColorimetry type to the VAProcColorStandardType.  If
 973  * @colorimetry is NULL or colorimetry->primaries are unknown, then returns
 974  * VAProcColorStandardNone.  If there is no 1:1 correlation, then returns
 975  * VAProcColorStandardExplicit.  Otherwise, the correlating
 976  * VAProcColorStandardType is returned.
 977  *
 978  * Returns: a VAProcColorStandardType.
 979  **/
 980 guint
 981 from_GstVideoColorimetry (const GstVideoColorimetry * const colorimetry)
 982 {
 983 #if VA_CHECK_VERSION(1,2,0)
 984   if (!colorimetry
 985       || colorimetry->primaries == GST_VIDEO_COLOR_PRIMARIES_UNKNOWN)
 986     return VAProcColorStandardNone;
 987   if (gst_video_colorimetry_matches (colorimetry, GST_VIDEO_COLORIMETRY_BT709))
 988     return VAProcColorStandardBT709;
 989   /* NOTE: VAProcColorStandardBT2020 in VAAPI is the same as
 990    * GST_VIDEO_COLORIMETRY_BT2020_10 in gstreamer. */
 991   if (gst_video_colorimetry_matches (colorimetry,
 992           GST_VIDEO_COLORIMETRY_BT2020_10) ||
 993       gst_video_colorimetry_matches (colorimetry, GST_VIDEO_COLORIMETRY_BT2020))
 994     return VAProcColorStandardBT2020;
 995   if (gst_video_colorimetry_matches (colorimetry, GST_VIDEO_COLORIMETRY_BT601))
 996     return VAProcColorStandardBT601;
 997   if (gst_video_colorimetry_matches (colorimetry,
 998           GST_VIDEO_COLORIMETRY_SMPTE240M))
 999     return VAProcColorStandardSMPTE240M;
1000
1001   return VAProcColorStandardExplicit;
1002 #else
1003   return VAProcColorStandardNone;
1004 #endif
1005 }
1006
1007 /**
1008  * from_GstVideoColorRange:
1009  * @value: a #GstVideoColorRange
1010  *
1011  * VPP: maps the #GstVideoColorRange to the VA value.
1012  *
1013  * Returns: the VA color range.
1014  **/
1015 guint
1016 from_GstVideoColorRange (const GstVideoColorRange value)
1017 {
1018 #if VA_CHECK_VERSION(1,2,0)
1019   switch (value) {
1020     case GST_VIDEO_COLOR_RANGE_0_255:
1021       return VA_SOURCE_RANGE_FULL;
1022     case GST_VIDEO_COLOR_RANGE_16_235:
1023       return VA_SOURCE_RANGE_REDUCED;
1024     default:
1025       return VA_SOURCE_RANGE_UNKNOWN;
1026   }
1027 #else
1028   return 0;
1029 #endif
1030 }