va/va.h

   1 /*
   2  * Copyright (c) 2007-2009 Intel Corporation. All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sub license, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  19  * IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE LIABLE FOR
  20  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  21  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  22  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24 /*
  25  * Video Acceleration (VA) API Specification
  26  *
  27  * Rev. 0.30
  28  * <jonathan.bian@intel.com>
  29  *
  30  * Revision History:
  31  * rev 0.10 (12/10/2006 Jonathan Bian) - Initial draft
  32  * rev 0.11 (12/15/2006 Jonathan Bian) - Fixed some errors
  33  * rev 0.12 (02/05/2007 Jonathan Bian) - Added VC-1 data structures for slice level decode
  34  * rev 0.13 (02/28/2007 Jonathan Bian) - Added GetDisplay()
  35  * rev 0.14 (04/13/2007 Jonathan Bian) - Fixed MPEG-2 PictureParameter structure, cleaned up a few funcs.
  36  * rev 0.15 (04/20/2007 Jonathan Bian) - Overhauled buffer management
  37  * rev 0.16 (05/02/2007 Jonathan Bian) - Added error codes and fixed some issues with configuration
  38  * rev 0.17 (05/07/2007 Jonathan Bian) - Added H.264/AVC data structures for slice level decode.
  39  * rev 0.18 (05/14/2007 Jonathan Bian) - Added data structures for MPEG-4 slice level decode
  40  *                                       and MPEG-2 motion compensation.
  41  * rev 0.19 (08/06/2007 Jonathan Bian) - Removed extra type for bitplane data.
  42  * rev 0.20 (08/08/2007 Jonathan Bian) - Added missing fields to VC-1 PictureParameter structure.
  43  * rev 0.21 (08/20/2007 Jonathan Bian) - Added image and subpicture support.
  44  * rev 0.22 (08/27/2007 Jonathan Bian) - Added support for chroma-keying and global alpha.
  45  * rev 0.23 (09/11/2007 Jonathan Bian) - Fixed some issues with images and subpictures.
  46  * rev 0.24 (09/18/2007 Jonathan Bian) - Added display attributes.
  47  * rev 0.25 (10/18/2007 Jonathan Bian) - Changed to use IDs only for some types.
  48  * rev 0.26 (11/07/2007 Waldo Bastian) - Change vaCreateBuffer semantics
  49  * rev 0.27 (11/19/2007 Matt Sottek)   - Added DeriveImage
  50  * rev 0.28 (12/06/2007 Jonathan Bian) - Added new versions of PutImage and AssociateSubpicture
  51  *                                       to enable scaling
  52  * rev 0.29 (02/07/2008 Jonathan Bian) - VC1 parameter fixes,
  53  *                                       added VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED
  54  * rev 0.30 (03/01/2009 Jonathan Bian) - Added encoding support for H.264 BP and MPEG-4 SP and fixes
  55  *                                       for ISO C conformance.
  56  * rev 0.31 (09/02/2009 Gwenole Beauchesne) - VC-1/H264 fields change for VDPAU and XvBA backend
  57  *                                       Application needs to relink with the new library.
  58  *
  59  * rev 0.31.1 (03/29/2009)              - Data structure for JPEG encode
  60  * rev 0.31.2 (01/13/2011 Anthony Pabon)- Added a flag to indicate Subpicture coordinates are screen
  61  *                                        screen relative rather than source video relative.
  62  * rev 0.32.0 (01/13/2011 Xiang Haihao) - Add profile into VAPictureParameterBufferVC1
  63  *                                        update VAAPI to 0.32.0
  64  *
  65  * Acknowledgements:
  66  *  Some concepts borrowed from XvMC and XvImage.
  67  *  Waldo Bastian (Intel), Matt Sottek (Intel),  Austin Yuan (Intel), and Gwenole Beauchesne (SDS)
  68  *  contributed to various aspects of the API.
  69  */
  70
  71 /**
  72  * \file va.h
  73  * \brief The Core API
  74  *
  75  * This file contains the \ref api_core "Core API".
  76  */
  77
  78 #ifndef _VA_H_
  79 #define _VA_H_
  80
  81 #include <stddef.h>
  82 #include <stdint.h>
  83 #include <va/va_version.h>
  84
  85 #ifdef __cplusplus
  86 extern "C" {
  87 #endif
  88
  89 /**
  90  * \mainpage Video Acceleration (VA) API
  91  *
  92  * \section intro Introduction
  93  *
  94  * The main motivation for VA-API (Video Acceleration API) is to
  95  * enable hardware accelerated video decode and encode at various
  96  * entry-points (VLD, IDCT, Motion Compensation etc.) for the
  97  * prevailing coding standards today (MPEG-2, MPEG-4 ASP/H.263, MPEG-4
  98  * AVC/H.264, VC-1/VMW3, and JPEG).
  99  *
 100  * VA-API is split into several modules:
 101  * - \ref api_core
 102  * - \ref api_enc_h264
 103  * - \ref api_vpp
 104  */
 105
 106 /**
 107  * \defgroup api_core Core API
 108  *
 109  * @{
 110  */
 111
 112 /**
 113 Overview
 114
 115 The VA API is intended to provide an interface between a video decode/encode/display
 116 application (client) and a hardware accelerator (server), to off-load
 117 video decode/encode/display operations from the host to the hardware accelerator at various
 118 entry-points.
 119
 120 The basic operation steps are:
 121
 122 - Negotiate a mutually acceptable configuration with the server to lock
 123   down profile, entrypoints, and other attributes that will not change on
 124   a frame-by-frame basis.
 125 - Create a decode context which represents a "virtualized" hardware decode
 126   device
 127 - Get and fill decode buffers with picture level, slice level and macroblock
 128   level data (depending on entrypoints)
 129 - Pass the decode buffers to the server to decode the current frame
 130
 131 Initialization & Configuration Management
 132
 133 - Find out supported profiles
 134 - Find out entrypoints for a given profile
 135 - Find out configuration attributes for a given profile/entrypoint pair
 136 - Create a configuration for use by the decoder
 137
 138 */
 139
 140 typedef void* VADisplay;        /* window system dependent */
 141
 142 typedef int VAStatus;   /** Return status type from functions */
 143 /** Values for the return status */
 144 #define VA_STATUS_SUCCESS                       0x00000000
 145 #define VA_STATUS_ERROR_OPERATION_FAILED        0x00000001
 146 #define VA_STATUS_ERROR_ALLOCATION_FAILED       0x00000002
 147 #define VA_STATUS_ERROR_INVALID_DISPLAY         0x00000003
 148 #define VA_STATUS_ERROR_INVALID_CONFIG          0x00000004
 149 #define VA_STATUS_ERROR_INVALID_CONTEXT         0x00000005
 150 #define VA_STATUS_ERROR_INVALID_SURFACE         0x00000006
 151 #define VA_STATUS_ERROR_INVALID_BUFFER          0x00000007
 152 #define VA_STATUS_ERROR_INVALID_IMAGE           0x00000008
 153 #define VA_STATUS_ERROR_INVALID_SUBPICTURE      0x00000009
 154 #define VA_STATUS_ERROR_ATTR_NOT_SUPPORTED      0x0000000a
 155 #define VA_STATUS_ERROR_MAX_NUM_EXCEEDED        0x0000000b
 156 #define VA_STATUS_ERROR_UNSUPPORTED_PROFILE     0x0000000c
 157 #define VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT  0x0000000d
 158 #define VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT   0x0000000e
 159 #define VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE  0x0000000f
 160 #define VA_STATUS_ERROR_SURFACE_BUSY            0x00000010
 161 #define VA_STATUS_ERROR_FLAG_NOT_SUPPORTED      0x00000011
 162 #define VA_STATUS_ERROR_INVALID_PARAMETER       0x00000012
 163 #define VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED 0x00000013
 164 #define VA_STATUS_ERROR_UNIMPLEMENTED           0x00000014
 165 #define VA_STATUS_ERROR_SURFACE_IN_DISPLAYING   0x00000015
 166 #define VA_STATUS_ERROR_INVALID_IMAGE_FORMAT    0x00000016
 167 #define VA_STATUS_ERROR_DECODING_ERROR          0x00000017
 168 #define VA_STATUS_ERROR_ENCODING_ERROR          0x00000018
 169 /**
 170  * \brief An invalid/unsupported value was supplied.
 171  *
 172  * This is a catch-all error code for invalid or unsupported values.
 173  * e.g. value exceeding the valid range, invalid type in the context
 174  * of generic attribute values.
 175  */
 176 #define VA_STATUS_ERROR_INVALID_VALUE           0x00000019
 177 /** \brief An unsupported filter was supplied. */
 178 #define VA_STATUS_ERROR_UNSUPPORTED_FILTER      0x00000020
 179 /** \brief An invalid filter chain was supplied. */
 180 #define VA_STATUS_ERROR_INVALID_FILTER_CHAIN    0x00000021
 181 /** \brief Indicate HW busy (e.g. run multiple encoding simultaneously). */
 182 #define VA_STATUS_ERROR_HW_BUSY                 0x00000022
 183 /** \brief An unsupported memory type was supplied. */
 184 #define VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE 0x00000024
 185 #define VA_STATUS_ERROR_UNKNOWN                 0xFFFFFFFF
 186
 187 /** De-interlacing flags for vaPutSurface() */
 188 #define VA_FRAME_PICTURE        0x00000000
 189 #define VA_TOP_FIELD            0x00000001
 190 #define VA_BOTTOM_FIELD         0x00000002
 191
 192 /**
 193  * Enabled the positioning/cropping/blending feature:
 194  * 1, specify the video playback position in the isurface
 195  * 2, specify the cropping info for video playback
 196  * 3, encoded video will blend with background color
 197  */
 198 #define VA_ENABLE_BLEND         0x00000004 /* video area blend with the constant color */
 199
 200 /**
 201  * Clears the drawable with background color.
 202  * for hardware overlay based implementation this flag
 203  * can be used to turn off the overlay
 204  */
 205 #define VA_CLEAR_DRAWABLE       0x00000008
 206
 207 /** Color space conversion flags for vaPutSurface() */
 208 #define VA_SRC_COLOR_MASK       0x000000f0
 209 #define VA_SRC_BT601            0x00000010
 210 #define VA_SRC_BT709            0x00000020
 211 #define VA_SRC_SMPTE_240        0x00000040
 212
 213 /** Scaling flags for vaPutSurface() */
 214 #define VA_FILTER_SCALING_DEFAULT       0x00000000
 215 #define VA_FILTER_SCALING_FAST          0x00000100
 216 #define VA_FILTER_SCALING_HQ            0x00000200
 217 #define VA_FILTER_SCALING_NL_ANAMORPHIC 0x00000300
 218 #define VA_FILTER_SCALING_MASK          0x00000f00
 219
 220 /**
 221  * Returns a short english description of error_status
 222  */
 223 const char *vaErrorStr(VAStatus error_status);
 224
 225 /**
 226  * Initialization:
 227  * A display must be obtained by calling vaGetDisplay() before calling
 228  * vaInitialize() and other functions. This connects the API to the
 229  * native window system.
 230  * For X Windows, native_dpy would be from XOpenDisplay()
 231  */
 232 typedef void* VANativeDisplay;  /* window system dependent */
 233
 234 int vaDisplayIsValid(VADisplay dpy);
 235
 236 /**
 237  *  Set the override driver name instead of queried driver driver.
 238  */
 239 VAStatus vaSetDriverName(VADisplay dpy,
 240                          char *driver_name
 241 );
 242
 243 /**
 244  * Initialize the library
 245  */
 246 VAStatus vaInitialize (
 247     VADisplay dpy,
 248     int *major_version,  /* out */
 249     int *minor_version   /* out */
 250 );
 251
 252 /**
 253  * After this call, all library internal resources will be cleaned up
 254  */
 255 VAStatus vaTerminate (
 256     VADisplay dpy
 257 );
 258
 259 /**
 260  * vaQueryVendorString returns a pointer to a zero-terminated string
 261  * describing some aspects of the VA implemenation on a specific
 262  * hardware accelerator. The format of the returned string is vendor
 263  * specific and at the discretion of the implementer.
 264  * e.g. for the Intel GMA500 implementation, an example would be:
 265  * "Intel GMA500 - 2.0.0.32L.0005"
 266  */
 267 const char *vaQueryVendorString (
 268     VADisplay dpy
 269 );
 270
 271 typedef int (*VAPrivFunc)();
 272
 273 /**
 274  * Return a function pointer given a function name in the library.
 275  * This allows private interfaces into the library
 276  */
 277 VAPrivFunc vaGetLibFunc (
 278     VADisplay dpy,
 279     const char *func
 280 );
 281
 282 /** Currently defined profiles */
 283 typedef enum
 284 {
 285     /** \brief Profile ID used for video processing. */
 286     VAProfileNone                       = -1,
 287     VAProfileMPEG2Simple                = 0,
 288     VAProfileMPEG2Main                  = 1,
 289     VAProfileMPEG4Simple                = 2,
 290     VAProfileMPEG4AdvancedSimple        = 3,
 291     VAProfileMPEG4Main                  = 4,
 292     VAProfileH264Baseline               = 5,
 293     VAProfileH264Main                   = 6,
 294     VAProfileH264High                   = 7,
 295     VAProfileVC1Simple                  = 8,
 296     VAProfileVC1Main                    = 9,
 297     VAProfileVC1Advanced                = 10,
 298     VAProfileH263Baseline               = 11,
 299     VAProfileJPEGBaseline               = 12,
 300     VAProfileH264ConstrainedBaseline    = 13,
 301     VAProfileVP8Version0_3              = 14,
 302     VAProfileH264MultiviewHigh          = 15,
 303     VAProfileH264StereoHigh             = 16,
 304     VAProfileHEVCMain                   = 17,
 305     VAProfileHEVCMain10                 = 18,
 306     VAProfileVP9Profile0                = 19,
 307     VAProfileVP9Profile1                = 20,
 308     VAProfileVP9Profile2                = 21,
 309     VAProfileVP9Profile3                = 22
 310 } VAProfile;
 311
 312 /**
 313  *  Currently defined entrypoints
 314  */
 315 typedef enum
 316 {
 317     VAEntrypointVLD             = 1,
 318     VAEntrypointIZZ             = 2,
 319     VAEntrypointIDCT            = 3,
 320     VAEntrypointMoComp          = 4,
 321     VAEntrypointDeblocking      = 5,
 322     VAEntrypointEncSlice        = 6,    /* slice level encode */
 323     VAEntrypointEncPicture      = 7,    /* pictuer encode, JPEG, etc */
 324     VAEntrypointVideoProc       = 10,   /**< Video pre/post-processing. */
 325 } VAEntrypoint;
 326
 327 /** Currently defined configuration attribute types */
 328 typedef enum
 329 {
 330     VAConfigAttribRTFormat              = 0,
 331     VAConfigAttribSpatialResidual       = 1,
 332     VAConfigAttribSpatialClipping       = 2,
 333     VAConfigAttribIntraResidual         = 3,
 334     VAConfigAttribEncryption            = 4,
 335     VAConfigAttribRateControl           = 5,
 336
 337     /** @name Attributes for decoding */
 338     /**@{*/
 339     /**
 340      * \brief Slice Decoding mode. Read/write.
 341      *
 342      * This attribute determines what mode the driver supports for slice
 343      * decoding, through vaGetConfigAttributes(); and what mode the user
 344      * will be providing to the driver, through vaCreateConfig(), if the
 345      * driver supports those. If this attribute is not set by the user then
 346      * it is assumed that VA_DEC_SLICE_MODE_NORMAL mode is used.
 347      *
 348      * See \c VA_DEC_SLICE_MODE_xxx for the list of slice decoding modes.
 349      */
 350     VAConfigAttribDecSliceMode          = 6,
 351
 352     /** @name Attributes for encoding */
 353     /**@{*/
 354     /**
 355      * \brief Packed headers mode. Read/write.
 356      *
 357      * This attribute determines what packed headers the driver supports,
 358      * through vaGetConfigAttributes(); and what packed headers the user
 359      * will be providing to the driver, through vaCreateConfig(), if the
 360      * driver supports those.
 361      *
 362      * See \c VA_ENC_PACKED_HEADER_xxx for the list of packed headers.
 363      */
 364     VAConfigAttribEncPackedHeaders      = 10,
 365     /**
 366      * \brief Interlaced mode. Read/write.
 367      *
 368      * This attribute determines what kind of interlaced encoding mode
 369      * the driver supports.
 370      *
 371      * See \c VA_ENC_INTERLACED_xxx for the list of interlaced modes.
 372      */
 373     VAConfigAttribEncInterlaced         = 11,
 374     /**
 375      * \brief Maximum number of reference frames. Read-only.
 376      *
 377      * This attribute determines the maximum number of reference
 378      * frames supported for encoding.
 379      *
 380      * Note: for H.264 encoding, the value represents the maximum number
 381      * of reference frames for both the reference picture list 0 (bottom
 382      * 16 bits) and the reference picture list 1 (top 16 bits).
 383      */
 384     VAConfigAttribEncMaxRefFrames       = 13,
 385     /**
 386      * \brief Maximum number of slices per frame. Read-only.
 387      *
 388      * This attribute determines the maximum number of slices the
 389      * driver can support to encode a single frame.
 390      */
 391     VAConfigAttribEncMaxSlices          = 14,
 392     /**
 393      * \brief Slice structure. Read-only.
 394      *
 395      * This attribute determines slice structures supported by the
 396      * driver for encoding. This attribute is a hint to the user so
 397      * that he can choose a suitable surface size and how to arrange
 398      * the encoding process of multiple slices per frame.
 399      *
 400      * More specifically, for H.264 encoding, this attribute
 401      * determines the range of accepted values to
 402      * VAEncSliceParameterBufferH264::macroblock_address and
 403      * VAEncSliceParameterBufferH264::num_macroblocks.
 404      *
 405      * See \c VA_ENC_SLICE_STRUCTURE_xxx for the supported slice
 406      * structure types.
 407      */
 408     VAConfigAttribEncSliceStructure     = 15,
 409     /**
 410      * \brief Macroblock information. Read-only.
 411      *
 412      * This attribute determines whether the driver supports extra
 413      * encoding information per-macroblock. e.g. QP.
 414      *
 415      * More specifically, for H.264 encoding, if the driver returns a non-zero
 416      * value for this attribute, this means the application can create
 417      * additional #VAEncMacroblockParameterBufferH264 buffers referenced
 418      * through VAEncSliceParameterBufferH264::macroblock_info.
 419      */
 420     VAConfigAttribEncMacroblockInfo     = 16,
 421     /**
 422      * \brief JPEG encoding attribute. Read-only.
 423      *
 424      * This attribute exposes a number of capabilities of the underlying
 425      * JPEG implementation. The attribute value is partitioned into fields as defined in the
 426      * VAConfigAttribValEncJPEG union.
 427      */
 428     VAConfigAttribEncJPEG             = 20,
 429     /**
 430      * \brief Encoding quality range attribute. Read-only.
 431      *
 432      * This attribute conveys whether the driver supports different quality level settings
 433      * for encoding. A value less than or equal to 1 means that the encoder only has a single
 434      * quality setting, and a value greater than 1 represents the number of quality levels
 435      * that can be configured. e.g. a value of 2 means there are two distinct quality levels.
 436      */
 437     VAConfigAttribEncQualityRange     = 21,
 438     /**
 439      * \brief Encoding skip frame attribute. Read-only.
 440      *
 441      * This attribute conveys whether the driver supports sending skip frame parameters
 442      * (VAEncMiscParameterTypeSkipFrame) to the encoder's rate control, when the user has
 443      * externally skipped frames.
 444      */
 445     VAConfigAttribEncSkipFrame        = 24,
 446     /**@}*/
 447     VAConfigAttribTypeMax
 448 } VAConfigAttribType;
 449
 450 /**
 451  * Configuration attributes
 452  * If there is more than one value for an attribute, a default
 453  * value will be assigned to the attribute if the client does not
 454  * specify the attribute when creating a configuration
 455  */
 456 typedef struct _VAConfigAttrib {
 457     VAConfigAttribType type;
 458     unsigned int value; /* OR'd flags (bits) for this attribute */
 459 } VAConfigAttrib;
 460
 461 /** attribute value for VAConfigAttribRTFormat */
 462 #define VA_RT_FORMAT_YUV420     0x00000001
 463 #define VA_RT_FORMAT_YUV422     0x00000002
 464 #define VA_RT_FORMAT_YUV444     0x00000004
 465 #define VA_RT_FORMAT_YUV411     0x00000008
 466 #define VA_RT_FORMAT_YUV400     0x00000010
 467 /** YUV formats with more than 8 bpp */
 468 #define VA_RT_FORMAT_YUV420_10BPP       0x00000100
 469 /** RGB formats */
 470 #define VA_RT_FORMAT_RGB16      0x00010000
 471 #define VA_RT_FORMAT_RGB32      0x00020000
 472 /* RGBP covers RGBP and BGRP fourcc */
 473 #define VA_RT_FORMAT_RGBP       0x00100000
 474 #define VA_RT_FORMAT_PROTECTED  0x80000000
 475
 476 /** @name Attribute values for VAConfigAttribRateControl */
 477 /**@{*/
 478 /** \brief Driver does not support any form of rate control. */
 479 #define VA_RC_NONE                      0x00000001
 480 /** \brief Constant bitrate. */
 481 #define VA_RC_CBR                       0x00000002
 482 /** \brief Variable bitrate. */
 483 #define VA_RC_VBR                       0x00000004
 484 /** \brief Video conference mode. */
 485 #define VA_RC_VCM                       0x00000008
 486 /** \brief Constant QP. */
 487 #define VA_RC_CQP                       0x00000010
 488 /** \brief Variable bitrate with peak rate higher than average bitrate. */
 489 #define VA_RC_VBR_CONSTRAINED           0x00000020
 490 /**@}*/
 491
 492 /** @name Attribute values for VAConfigAttribDecSliceMode */
 493 /**@{*/
 494 /** \brief Driver supports normal mode for slice decoding */
 495 #define VA_DEC_SLICE_MODE_NORMAL       0x00000001
 496 /** \brief Driver supports base mode for slice decoding */
 497 #define VA_DEC_SLICE_MODE_BASE         0x00000002
 498 /**@}*/
 499
 500 /** @name Attribute values for VAConfigAttribEncPackedHeaders */
 501 /**@{*/
 502 /** \brief Driver does not support any packed headers mode. */
 503 #define VA_ENC_PACKED_HEADER_NONE       0x00000000
 504 /** \brief Driver supports packed sequence headers. e.g. SPS for H.264. */
 505 #define VA_ENC_PACKED_HEADER_SEQUENCE   0x00000001
 506 /** \brief Driver supports packed picture headers. e.g. PPS for H.264. */
 507 #define VA_ENC_PACKED_HEADER_PICTURE    0x00000002
 508 /** \brief Driver supports packed slice headers. e.g. \c slice_header() for H.264. */
 509 #define VA_ENC_PACKED_HEADER_SLICE      0x00000004
 510 /** \brief Driver supports misc packed headers. e.g. SEI for H.264. */
 511 #define VA_ENC_PACKED_HEADER_MISC       0x00000008
 512 /** \brief Driver supports raw packed header, see VAEncPackedHeaderRawData */
 513 #define VA_ENC_PACKED_HEADER_RAW_DATA   0x00000010
 514 /**@}*/
 515
 516 /** @name Attribute values for VAConfigAttribEncInterlaced */
 517 /**@{*/
 518 /** \brief Driver does not support interlaced coding. */
 519 #define VA_ENC_INTERLACED_NONE          0x00000000
 520 /** \brief Driver supports interlaced frame coding. */
 521 #define VA_ENC_INTERLACED_FRAME         0x00000001
 522 /** \brief Driver supports interlaced field coding. */
 523 #define VA_ENC_INTERLACED_FIELD         0x00000002
 524 /** \brief Driver supports macroblock adaptive frame field coding. */
 525 #define VA_ENC_INTERLACED_MBAFF         0x00000004
 526 /** \brief Driver supports picture adaptive frame field coding. */
 527 #define VA_ENC_INTERLACED_PAFF          0x00000008
 528 /**@}*/
 529
 530 /** @name Attribute values for VAConfigAttribEncSliceStructure */
 531 /**@{*/
 532 /** \brief Driver supports an arbitrary number of rows per slice. */
 533 #define VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS           0x00000000
 534 /** \brief Driver supports a power-of-two number of rows per slice. */
 535 #define VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS        0x00000001
 536 /** \brief Driver supports an arbitrary number of rows per slice. */
 537 #define VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS    0x00000002
 538 /**@}*/
 539
 540 /** \brief Attribute value for VAConfigAttribEncJPEG */
 541 typedef union _VAConfigAttribValEncJPEG {
 542     struct {
 543         /** \brief set to 1 for arithmatic coding. */
 544         unsigned int arithmatic_coding_mode : 1;
 545         /** \brief set to 1 for progressive dct. */
 546         unsigned int progressive_dct_mode : 1;
 547         /** \brief set to 1 for non-interleaved. */
 548         unsigned int non_interleaved_mode : 1;
 549         /** \brief set to 1 for differential. */
 550         unsigned int differential_mode : 1;
 551         unsigned int max_num_components : 3;
 552         unsigned int max_num_scans : 4;
 553         unsigned int max_num_huffman_tables : 3;
 554         unsigned int max_num_quantization_tables : 3;
 555     } bits;
 556     unsigned int value;
 557 } VAConfigAttribValEncJPEG;
 558
 559 /**
 560  * if an attribute is not applicable for a given
 561  * profile/entrypoint pair, then set the value to the following
 562  */
 563 #define VA_ATTRIB_NOT_SUPPORTED 0x80000000
 564
 565 /** Get maximum number of profiles supported by the implementation */
 566 int vaMaxNumProfiles (
 567     VADisplay dpy
 568 );
 569
 570 /** Get maximum number of entrypoints supported by the implementation */
 571 int vaMaxNumEntrypoints (
 572     VADisplay dpy
 573 );
 574
 575 /** Get maximum number of attributs supported by the implementation */
 576 int vaMaxNumConfigAttributes (
 577     VADisplay dpy
 578 );
 579
 580 /**
 581  * Query supported profiles
 582  * The caller must provide a "profile_list" array that can hold at
 583  * least vaMaxNumProfile() entries. The actual number of profiles
 584  * returned in "profile_list" is returned in "num_profile".
 585  */
 586 VAStatus vaQueryConfigProfiles (
 587     VADisplay dpy,
 588     VAProfile *profile_list,    /* out */
 589     int *num_profiles           /* out */
 590 );
 591
 592 /**
 593  * Query supported entrypoints for a given profile
 594  * The caller must provide an "entrypoint_list" array that can hold at
 595  * least vaMaxNumEntrypoints() entries. The actual number of entrypoints
 596  * returned in "entrypoint_list" is returned in "num_entrypoints".
 597  */
 598 VAStatus vaQueryConfigEntrypoints (
 599     VADisplay dpy,
 600     VAProfile profile,
 601     VAEntrypoint *entrypoint_list,      /* out */
 602     int *num_entrypoints                /* out */
 603 );
 604
 605 /**
 606  * Get attributes for a given profile/entrypoint pair
 607  * The caller must provide an "attrib_list" with all attributes to be
 608  * retrieved.  Upon return, the attributes in "attrib_list" have been
 609  * updated with their value.  Unknown attributes or attributes that are
 610  * not supported for the given profile/entrypoint pair will have their
 611  * value set to VA_ATTRIB_NOT_SUPPORTED
 612  */
 613 VAStatus vaGetConfigAttributes (
 614     VADisplay dpy,
 615     VAProfile profile,
 616     VAEntrypoint entrypoint,
 617     VAConfigAttrib *attrib_list, /* in/out */
 618     int num_attribs
 619 );
 620
 621 /** Generic ID type, can be re-typed for specific implementation */
 622 typedef unsigned int VAGenericID;
 623
 624 typedef VAGenericID VAConfigID;
 625
 626 /**
 627  * Create a configuration for the decode pipeline
 628  * it passes in the attribute list that specifies the attributes it cares
 629  * about, with the rest taking default values.
 630  */
 631 VAStatus vaCreateConfig (
 632     VADisplay dpy,
 633     VAProfile profile,
 634     VAEntrypoint entrypoint,
 635     VAConfigAttrib *attrib_list,
 636     int num_attribs,
 637     VAConfigID *config_id /* out */
 638 );
 639
 640 /**
 641  * Free resources associdated with a given config
 642  */
 643 VAStatus vaDestroyConfig (
 644     VADisplay dpy,
 645     VAConfigID config_id
 646 );
 647
 648 /**
 649  * Query all attributes for a given configuration
 650  * The profile of the configuration is returned in "profile"
 651  * The entrypoint of the configuration is returned in "entrypoint"
 652  * The caller must provide an "attrib_list" array that can hold at least
 653  * vaMaxNumConfigAttributes() entries. The actual number of attributes
 654  * returned in "attrib_list" is returned in "num_attribs"
 655  */
 656 VAStatus vaQueryConfigAttributes (
 657     VADisplay dpy,
 658     VAConfigID config_id,
 659     VAProfile *profile,         /* out */
 660     VAEntrypoint *entrypoint,   /* out */
 661     VAConfigAttrib *attrib_list,/* out */
 662     int *num_attribs            /* out */
 663 );
 664
 665
 666 /**
 667  * Contexts and Surfaces
 668  *
 669  * Context represents a "virtual" video decode pipeline. Surfaces are render
 670  * targets for a given context. The data in the surfaces are not accessible
 671  * to the client and the internal data format of the surface is implementatin
 672  * specific.
 673  *
 674  * Surfaces will be bound to a context when the context is created. Once
 675  * a surface is bound to a given context, it can not be used to create
 676  * another context. The association is removed when the context is destroyed
 677  *
 678  * Both contexts and surfaces are identified by unique IDs and its
 679  * implementation specific internals are kept opaque to the clients
 680  */
 681
 682 typedef VAGenericID VAContextID;
 683
 684 typedef VAGenericID VASurfaceID;
 685
 686 #define VA_INVALID_ID           0xffffffff
 687 #define VA_INVALID_SURFACE      VA_INVALID_ID
 688
 689 /** \brief Generic value types. */
 690 typedef enum  {
 691     VAGenericValueTypeInteger = 1,      /**< 32-bit signed integer. */
 692     VAGenericValueTypeFloat,            /**< 32-bit floating-point value. */
 693     VAGenericValueTypePointer,          /**< Generic pointer type */
 694     VAGenericValueTypeFunc              /**< Pointer to function */
 695 } VAGenericValueType;
 696
 697 /** \brief Generic function type. */
 698 typedef void (*VAGenericFunc)(void);
 699
 700 /** \brief Generic value. */
 701 typedef struct _VAGenericValue {
 702     /** \brief Value type. See #VAGenericValueType. */
 703     VAGenericValueType  type;
 704     /** \brief Value holder. */
 705     union {
 706         /** \brief 32-bit signed integer. */
 707         int             i;
 708         /** \brief 32-bit float. */
 709         float           f;
 710         /** \brief Generic pointer. */
 711         void           *p;
 712         /** \brief Pointer to function. */
 713         VAGenericFunc   fn;
 714     }                   value;
 715 } VAGenericValue;
 716
 717 /** @name Surface attribute flags */
 718 /**@{*/
 719 /** \brief Surface attribute is not supported. */
 720 #define VA_SURFACE_ATTRIB_NOT_SUPPORTED 0x00000000
 721 /** \brief Surface attribute can be got through vaQuerySurfaceAttributes(). */
 722 #define VA_SURFACE_ATTRIB_GETTABLE      0x00000001
 723 /** \brief Surface attribute can be set through vaCreateSurfaces(). */
 724 #define VA_SURFACE_ATTRIB_SETTABLE      0x00000002
 725 /**@}*/
 726
 727 /** \brief Surface attribute types. */
 728 typedef enum {
 729     VASurfaceAttribNone = 0,
 730     /**
 731      * \brief Pixel format (fourcc).
 732      *
 733      * The value is meaningful as input to vaQuerySurfaceAttributes().
 734      * If zero, the driver returns the optimal pixel format for the
 735      * specified config. Otherwise, if non-zero, the value represents
 736      * a pixel format (FOURCC) that is kept as is on output, if the
 737      * driver supports it. Otherwise, the driver sets the value to
 738      * zero and drops the \c VA_SURFACE_ATTRIB_SETTABLE flag.
 739      */
 740     VASurfaceAttribPixelFormat,
 741     /** \brief Minimal width in pixels (int, read-only). */
 742     VASurfaceAttribMinWidth,
 743     /** \brief Maximal width in pixels (int, read-only). */
 744     VASurfaceAttribMaxWidth,
 745     /** \brief Minimal height in pixels (int, read-only). */
 746     VASurfaceAttribMinHeight,
 747     /** \brief Maximal height in pixels (int, read-only). */
 748     VASurfaceAttribMaxHeight,
 749     /** \brief Surface memory type expressed in bit fields (int, read/write). */
 750     VASurfaceAttribMemoryType,
 751     /** \brief External buffer descriptor (pointer, write). */
 752     VASurfaceAttribExternalBufferDescriptor,
 753     /** \brief Surface usage hint, gives the driver a hint of intended usage
 754      *  to optimize allocation (e.g. tiling) (int, read/write). */
 755     VASurfaceAttribUsageHint,
 756     /** \brief Number of surface attributes. */
 757     VASurfaceAttribCount
 758 } VASurfaceAttribType;
 759
 760 /** \brief Surface attribute. */
 761 typedef struct _VASurfaceAttrib {
 762     /** \brief Type. */
 763     VASurfaceAttribType type;
 764     /** \brief Flags. See "Surface attribute flags". */
 765     unsigned int        flags;
 766     /** \brief Value. See "Surface attribute types" for the expected types. */
 767     VAGenericValue      value;
 768 } VASurfaceAttrib;
 769
 770 /**
 771  * @name VASurfaceAttribMemoryType values in bit fields.
 772  * Bit 0:7 are reserved for generic types, Bit 31:28 are reserved for
 773  * Linux DRM, Bit 23:20 are reserved for Android. DRM and Android specific
 774  * types are defined in DRM and Android header files.
 775  */
 776 /**@{*/
 777 /** \brief VA memory type (default) is supported. */
 778 #define VA_SURFACE_ATTRIB_MEM_TYPE_VA                   0x00000001
 779 /** \brief V4L2 buffer memory type is supported. */
 780 #define VA_SURFACE_ATTRIB_MEM_TYPE_V4L2                 0x00000002
 781 /** \brief User pointer memory type is supported. */
 782 #define VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR             0x00000004
 783 /**@}*/
 784
 785 /**
 786  * \brief VASurfaceAttribExternalBuffers structure for
 787  * the VASurfaceAttribExternalBufferDescriptor attribute.
 788  */
 789 typedef struct _VASurfaceAttribExternalBuffers {
 790     /** \brief pixel format in fourcc. */
 791     unsigned int pixel_format;
 792     /** \brief width in pixels. */
 793     unsigned int width;
 794     /** \brief height in pixels. */
 795     unsigned int height;
 796     /** \brief total size of the buffer in bytes. */
 797     unsigned int data_size;
 798     /** \brief number of planes for planar layout */
 799     unsigned int num_planes;
 800     /** \brief pitch for each plane in bytes */
 801     unsigned int pitches[4];
 802     /** \brief offset for each plane in bytes */
 803     unsigned int offsets[4];
 804     /** \brief buffer handles or user pointers */
 805     unsigned long *buffers;
 806     /** \brief number of elements in the "buffers" array */
 807     unsigned int num_buffers;
 808     /** \brief flags. See "Surface external buffer descriptor flags". */
 809     unsigned int flags;
 810     /** \brief reserved for passing private data */
 811     void *private_data;
 812 } VASurfaceAttribExternalBuffers;
 813
 814 /** @name VASurfaceAttribExternalBuffers flags */
 815 /**@{*/
 816 /** \brief Enable memory tiling */
 817 #define VA_SURFACE_EXTBUF_DESC_ENABLE_TILING    0x00000001
 818 /** \brief Memory is cacheable */
 819 #define VA_SURFACE_EXTBUF_DESC_CACHED           0x00000002
 820 /** \brief Memory is non-cacheable */
 821 #define VA_SURFACE_EXTBUF_DESC_UNCACHED         0x00000004
 822 /** \brief Memory is write-combined */
 823 #define VA_SURFACE_EXTBUF_DESC_WC               0x00000008
 824 /** \brief Memory is protected */
 825 #define VA_SURFACE_EXTBUF_DESC_PROTECTED        0x80000000
 826
 827 /** @name VASurfaceAttribUsageHint attribute usage hint flags */
 828 /**@{*/
 829 /** \brief Surface usage not indicated. */
 830 #define VA_SURFACE_ATTRIB_USAGE_HINT_GENERIC    0x00000000
 831 /** \brief Surface used by video decoder. */
 832 #define VA_SURFACE_ATTRIB_USAGE_HINT_DECODER    0x00000001
 833 /** \brief Surface used by video encoder. */
 834 #define VA_SURFACE_ATTRIB_USAGE_HINT_ENCODER    0x00000002
 835 /** \brief Surface read by video post-processing. */
 836 #define VA_SURFACE_ATTRIB_USAGE_HINT_VPP_READ   0x00000004
 837 /** \brief Surface written by video post-processing. */
 838 #define VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE  0x00000008
 839 /** \brief Surface used for display. */
 840 #define VA_SURFACE_ATTRIB_USAGE_HINT_DISPLAY    0x00000010
 841
 842 /**@}*/
 843
 844 /**
 845  * \brief Queries surface attributes for the supplied config.
 846  *
 847  * Unlike vaGetSurfaceAttributes(), this function queries for all
 848  * supported attributes for the supplied VA @config. In particular, if
 849  * the underlying hardware supports the creation of VA surfaces in
 850  * various formats, then this function will enumerate all pixel
 851  * formats that are supported.
 852  *
 853  * The \c attrib_list array is allocated by the user and \c
 854  * num_attribs shall be initialized to the number of allocated
 855  * elements in that array. Upon successful return, the actual number
 856  * of attributes will be overwritten into \c num_attribs. Otherwise,
 857  * \c VA_STATUS_ERROR_MAX_NUM_EXCEEDED is returned and \c num_attribs
 858  * is adjusted to the number of elements that would be returned if
 859  * enough space was available.
 860  *
 861  * Note: it is perfectly valid to pass NULL to the \c attrib_list
 862  * argument when vaQuerySurfaceAttributes() is used to determine the
 863  * actual number of elements that need to be allocated.
 864  *
 865  * @param[in] dpy               the VA display
 866  * @param[in] config            the config identifying a codec or a video
 867  *     processing pipeline
 868  * @param[out] attrib_list      the output array of #VASurfaceAttrib elements
 869  * @param[in,out] num_attribs   the number of elements allocated on
 870  *      input, the number of elements actually filled in output
 871  */
 872 VAStatus
 873 vaQuerySurfaceAttributes(
 874     VADisplay           dpy,
 875     VAConfigID          config,
 876     VASurfaceAttrib    *attrib_list,
 877     unsigned int       *num_attribs
 878 );
 879
 880 /**
 881  * \brief Creates an array of surfaces
 882  *
 883  * Creates an array of surfaces. The optional list of attributes shall
 884  * be constructed and validated through vaGetSurfaceAttributes() or
 885  * constructed based based on what the underlying hardware could
 886  * expose through vaQuerySurfaceAttributes().
 887  *
 888  * @param[in] dpy               the VA display
 889  * @param[in] format            the desired surface format. See \c VA_RT_FORMAT_*
 890  * @param[in] width             the surface width
 891  * @param[in] height            the surface height
 892  * @param[out] surfaces         the array of newly created surfaces
 893  * @param[in] num_surfaces      the number of surfaces to create
 894  * @param[in] attrib_list       the list of (optional) attributes, or \c NULL
 895  * @param[in] num_attribs       the number of attributes supplied in
 896  *     \c attrib_list, or zero
 897  */
 898 VAStatus
 899 vaCreateSurfaces(
 900     VADisplay           dpy,
 901     unsigned int        format,
 902     unsigned int        width,
 903     unsigned int        height,
 904     VASurfaceID        *surfaces,
 905     unsigned int        num_surfaces,
 906     VASurfaceAttrib    *attrib_list,
 907     unsigned int        num_attribs
 908 );
 909
 910 /**
 911  * vaDestroySurfaces - Destroy resources associated with surfaces.
 912  *  Surfaces can only be destroyed after the context associated has been
 913  *  destroyed.
 914  *  dpy: display
 915  *  surfaces: array of surfaces to destroy
 916  *  num_surfaces: number of surfaces in the array to be destroyed.
 917  */
 918 VAStatus vaDestroySurfaces (
 919     VADisplay dpy,
 920     VASurfaceID *surfaces,
 921     int num_surfaces
 922 );
 923
 924 #define VA_PROGRESSIVE 0x1
 925 /**
 926  * vaCreateContext - Create a context
 927  *  dpy: display
 928  *  config_id: configuration for the context
 929  *  picture_width: coded picture width
 930  *  picture_height: coded picture height
 931  *  flag: any combination of the following:
 932  *    VA_PROGRESSIVE (only progressive frame pictures in the sequence when set)
 933  *  render_targets: render targets (surfaces) tied to the context
 934  *  num_render_targets: number of render targets in the above array
 935  *  context: created context id upon return
 936  */
 937 VAStatus vaCreateContext (
 938     VADisplay dpy,
 939     VAConfigID config_id,
 940     int picture_width,
 941     int picture_height,
 942     int flag,
 943     VASurfaceID *render_targets,
 944     int num_render_targets,
 945     VAContextID *context                /* out */
 946 );
 947
 948 /**
 949  * vaDestroyContext - Destroy a context
 950  *  dpy: display
 951  *  context: context to be destroyed
 952  */
 953 VAStatus vaDestroyContext (
 954     VADisplay dpy,
 955     VAContextID context
 956 );
 957
 958 /**
 959  * Buffers
 960  * Buffers are used to pass various types of data from the
 961  * client to the server. The server maintains a data store
 962  * for each buffer created, and the client idenfies a buffer
 963  * through a unique buffer id assigned by the server.
 964  */
 965
 966 typedef VAGenericID VABufferID;
 967
 968 typedef enum
 969 {
 970     VAPictureParameterBufferType        = 0,
 971     VAIQMatrixBufferType                = 1,
 972     VABitPlaneBufferType                = 2,
 973     VASliceGroupMapBufferType           = 3,
 974     VASliceParameterBufferType          = 4,
 975     VASliceDataBufferType               = 5,
 976     VAMacroblockParameterBufferType     = 6,
 977     VAResidualDataBufferType            = 7,
 978     VADeblockingParameterBufferType     = 8,
 979     VAImageBufferType                   = 9,
 980     VAProtectedSliceDataBufferType      = 10,
 981     VAQMatrixBufferType                 = 11,
 982     VAHuffmanTableBufferType            = 12,
 983     VAProbabilityBufferType             = 13,
 984
 985 /* Following are encode buffer types */
 986     VAEncCodedBufferType                = 21,
 987     VAEncSequenceParameterBufferType    = 22,
 988     VAEncPictureParameterBufferType     = 23,
 989     VAEncSliceParameterBufferType       = 24,
 990     VAEncPackedHeaderParameterBufferType = 25,
 991     VAEncPackedHeaderDataBufferType     = 26,
 992     VAEncMiscParameterBufferType        = 27,
 993     VAEncMacroblockParameterBufferType  = 28,
 994     VAEncMacroblockMapBufferType        = 29,
 995 /* Following are video processing buffer types */
 996     /**
 997      * \brief Video processing pipeline parameter buffer.
 998      *
 999      * This buffer describes the video processing pipeline. See
1000      * #VAProcPipelineParameterBuffer for details.
1001      */
1002     VAProcPipelineParameterBufferType   = 41,
1003     /**
1004      * \brief Video filter parameter buffer.
1005      *
1006      * This buffer describes the video filter parameters. All buffers
1007      * inherit from #VAProcFilterParameterBufferBase, thus including
1008      * a unique filter buffer type.
1009      *
1010      * The default buffer used by most filters is #VAProcFilterParameterBuffer.
1011      * Filters requiring advanced parameters include, but are not limited to,
1012      * deinterlacing (#VAProcFilterParameterBufferDeinterlacing),
1013      * color balance (#VAProcFilterParameterBufferColorBalance), etc.
1014      */
1015     VAProcFilterParameterBufferType     = 42,
1016     VABufferTypeMax
1017 } VABufferType;
1018
1019 typedef enum
1020 {
1021     VAEncMiscParameterTypeFrameRate     = 0,
1022     VAEncMiscParameterTypeRateControl   = 1,
1023     VAEncMiscParameterTypeMaxSliceSize  = 2,
1024     VAEncMiscParameterTypeAIR           = 3,
1025     /** \brief Buffer type used to express a maximum frame size (in bits). */
1026     VAEncMiscParameterTypeMaxFrameSize  = 4,
1027     /** \brief Buffer type used for HRD parameters. */
1028     VAEncMiscParameterTypeHRD           = 5,
1029     VAEncMiscParameterTypeQualityLevel  = 6,
1030     /** \brief Buffer type used for sending skip frame parameters to the encoder's
1031       * rate control, when the user has externally skipped frames. */
1032     VAEncMiscParameterTypeSkipFrame     = 9
1033 } VAEncMiscParameterType;
1034
1035 /** \brief Packed header type. */
1036 typedef enum {
1037     /** \brief Packed sequence header. */
1038     VAEncPackedHeaderSequence   = 1,
1039     /** \brief Packed picture header. */
1040     VAEncPackedHeaderPicture    = 2,
1041     /** \brief Packed slice header. */
1042     VAEncPackedHeaderSlice      = 3,
1043     /**
1044      * \brief Packed raw header.
1045      *
1046      * Packed raw data header can be used by the client to insert a header
1047      * into the bitstream data buffer at the point it is passed, the driver
1048      * will handle the raw packed header based on "has_emulation_bytes" field
1049      * in the packed header parameter structure.
1050      */
1051     VAEncPackedHeaderRawData    = 4,
1052     /** \brief Misc packed header. See codec-specific definitions. */
1053     VAEncPackedHeaderMiscMask   = 0x80000000,
1054 } VAEncPackedHeaderType;
1055
1056 /** \brief Packed header parameter. */
1057 typedef struct _VAEncPackedHeaderParameterBuffer {
1058     /** Type of the packed header buffer. See #VAEncPackedHeaderType. */
1059     unsigned int                type;
1060     /** \brief Size of the #VAEncPackedHeaderDataBuffer in bits. */
1061     unsigned int                bit_length;
1062     /** \brief Flag: buffer contains start code emulation prevention bytes? */
1063     unsigned char               has_emulation_bytes;
1064 } VAEncPackedHeaderParameterBuffer;
1065
1066 /**
1067  *  For application, e.g. set a new bitrate
1068  *    VABufferID buf_id;
1069  *    VAEncMiscParameterBuffer *misc_param;
1070  *    VAEncMiscParameterRateControl *misc_rate_ctrl;
1071  *
1072  *    vaCreateBuffer(dpy, context, VAEncMiscParameterBufferType,
1073  *              sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterRateControl),
1074  *              1, NULL, &buf_id);
1075  *
1076  *    vaMapBuffer(dpy,buf_id,(void **)&misc_param);
1077  *    misc_param->type = VAEncMiscParameterTypeRateControl;
1078  *    misc_rate_ctrl= (VAEncMiscParameterRateControl *)misc_param->data;
1079  *    misc_rate_ctrl->bits_per_second = 6400000;
1080  *    vaUnmapBuffer(dpy, buf_id);
1081  *    vaRenderPicture(dpy, context, &buf_id, 1);
1082  */
1083 typedef struct _VAEncMiscParameterBuffer
1084 {
1085     VAEncMiscParameterType type;
1086     unsigned int data[0];
1087 } VAEncMiscParameterBuffer;
1088
1089
1090 /** \brief Rate control parameters */
1091 typedef struct _VAEncMiscParameterRateControl
1092 {
1093     /* this is the maximum bit-rate to be constrained by the rate control implementation */
1094     unsigned int bits_per_second;
1095     /* this is the bit-rate the rate control is targeting, as a percentage of the maximum
1096      * bit-rate for example if target_percentage is 95 then the rate control will target
1097      * a bit-rate that is 95% of the maximum bit-rate
1098      */
1099     unsigned int target_percentage;
1100     /* windows size in milliseconds. For example if this is set to 500,
1101      * then the rate control will guarantee the target bit-rate over a 500 ms window
1102      */
1103     unsigned int window_size;
1104     /* initial QP at I frames */
1105     unsigned int initial_qp;
1106     unsigned int min_qp;
1107     unsigned int basic_unit_size;
1108     union
1109     {
1110         struct
1111         {
1112             unsigned int reset : 1;
1113             unsigned int disable_frame_skip : 1; /* Disable frame skip in rate control mode */
1114             unsigned int disable_bit_stuffing : 1; /* Disable bit stuffing in rate control mode */
1115         } bits;
1116         unsigned int value;
1117     } rc_flags;
1118 } VAEncMiscParameterRateControl;
1119
1120 typedef struct _VAEncMiscParameterFrameRate
1121 {
1122     unsigned int framerate;
1123 } VAEncMiscParameterFrameRate;
1124
1125 /**
1126  * Allow a maximum slice size to be specified (in bits).
1127  * The encoder will attempt to make sure that individual slices do not exceed this size
1128  * Or to signal applicate if the slice size exceed this size, see "status" of VACodedBufferSegment
1129  */
1130 typedef struct _VAEncMiscParameterMaxSliceSize
1131 {
1132     unsigned int max_slice_size;
1133 } VAEncMiscParameterMaxSliceSize;
1134
1135 typedef struct _VAEncMiscParameterAIR
1136 {
1137     unsigned int air_num_mbs;
1138     unsigned int air_threshold;
1139     unsigned int air_auto; /* if set to 1 then hardware auto-tune the AIR threshold */
1140 } VAEncMiscParameterAIR;
1141
1142 typedef struct _VAEncMiscParameterHRD
1143 {
1144     unsigned int initial_buffer_fullness;       /* in bits */
1145     unsigned int buffer_size;                   /* in bits */
1146 } VAEncMiscParameterHRD;
1147
1148 /**
1149  * \brief Defines a maximum frame size (in bits).
1150  *
1151  * This misc parameter buffer defines the maximum size of a frame (in
1152  * bits). The encoder will try to make sure that each frame does not
1153  * exceed this size. Otherwise, if the frame size exceeds this size,
1154  * the \c status flag of #VACodedBufferSegment will contain
1155  * #VA_CODED_BUF_STATUS_FRAME_SIZE_OVERFLOW.
1156  */
1157 typedef struct _VAEncMiscParameterBufferMaxFrameSize {
1158     /** \brief Type. Shall be set to #VAEncMiscParameterTypeMaxFrameSize. */
1159     VAEncMiscParameterType      type;
1160     /** \brief Maximum size of a frame (in bits). */
1161     unsigned int                max_frame_size;
1162 } VAEncMiscParameterBufferMaxFrameSize;
1163
1164 /**
1165  * \brief Encoding quality level.
1166  *
1167  * The encoding quality could be set through this structure, if the implementation
1168  * supports multiple quality levels. The quality level set through this structure is
1169  * persistent over the entire coded sequence, or until a new structure is being sent.
1170  * The quality level range can be queried through the VAConfigAttribEncQualityRange
1171  * attribute. A lower value means higher quality, and a value of 1 represents the highest
1172  * quality. The quality level setting is used as a trade-off between quality and speed/power
1173  * consumption, with higher quality corresponds to lower speed and higher power consumption.
1174  */
1175 typedef struct _VAEncMiscParameterBufferQualityLevel {
1176     /** \brief Encoding quality level setting. When set to 0, default quality
1177      * level is used.
1178      */
1179     unsigned int                quality_level;
1180 } VAEncMiscParameterBufferQualityLevel;
1181
1182 /**
1183  * \brief Encoding skip frame.
1184  *
1185  * The application may choose to skip frames externally to the encoder (e.g. drop completely or
1186  * code as all skip's). For rate control purposes the encoder will need to know the size and number
1187  * of skipped frames.  Skip frame(s) indicated through this structure is applicable only to the
1188  * current frame.  It is allowed for the application to still send in packed headers for the driver to
1189  * pack, although no frame will be encoded (e.g. for HW to encrypt the frame).
1190  */
1191 typedef struct _VAEncMiscParameterSkipFrame {
1192     /** \brief Indicates skip frames as below.
1193       * 0: Encode as normal, no skip.
1194       * 1: One or more frames were skipped prior to the current frame, encode the current frame as normal.
1195       * 2: The current frame is to be skipped, do not encode it but pack/encrypt the packed header contents
1196       *    (all except VAEncPackedHeaderSlice) which could contain actual frame contents (e.g. pack the frame
1197       *    in VAEncPackedHeaderPicture).  */
1198     unsigned char               skip_frame_flag;
1199     /** \brief The number of frames skipped prior to the current frame.  Valid when skip_frame_flag = 1. */
1200     unsigned char               num_skip_frames;
1201     /** \brief When skip_frame_flag = 1, the size of the skipped frames in bits.   When skip_frame_flag = 2,
1202       * the size of the current skipped frame that is to be packed/encrypted in bits. */
1203     unsigned int                size_skip_frames;
1204 } VAEncMiscParameterSkipFrame;
1205
1206 /*
1207  * There will be cases where the bitstream buffer will not have enough room to hold
1208  * the data for the entire slice, and the following flags will be used in the slice
1209  * parameter to signal to the server for the possible cases.
1210  * If a slice parameter buffer and slice data buffer pair is sent to the server with
1211  * the slice data partially in the slice data buffer (BEGIN and MIDDLE cases below),
1212  * then a slice parameter and data buffer needs to be sent again to complete this slice.
1213  */
1214 #define VA_SLICE_DATA_FLAG_ALL          0x00    /* whole slice is in the buffer */
1215 #define VA_SLICE_DATA_FLAG_BEGIN        0x01    /* The beginning of the slice is in the buffer but the end if not */
1216 #define VA_SLICE_DATA_FLAG_MIDDLE       0x02    /* Neither beginning nor end of the slice is in the buffer */
1217 #define VA_SLICE_DATA_FLAG_END          0x04    /* end of the slice is in the buffer */
1218
1219 /* Codec-independent Slice Parameter Buffer base */
1220 typedef struct _VASliceParameterBufferBase
1221 {
1222     unsigned int slice_data_size;       /* number of bytes in the slice data buffer for this slice */
1223     unsigned int slice_data_offset;     /* the offset to the first byte of slice data */
1224     unsigned int slice_data_flag;       /* see VA_SLICE_DATA_FLAG_XXX definitions */
1225 } VASliceParameterBufferBase;
1226
1227 /**********************************
1228  * JPEG common  data structures
1229  **********************************/
1230 /**
1231  * \brief Huffman table for JPEG decoding.
1232  *
1233  * This structure holds the complete Huffman tables. This is an
1234  * aggregation of all Huffman table (DHT) segments maintained by the
1235  * application. i.e. up to 2 Huffman tables are stored in there for
1236  * baseline profile.
1237  *
1238  * The #load_huffman_table array can be used as a hint to notify the
1239  * VA driver implementation about which table(s) actually changed
1240  * since the last submission of this buffer.
1241  */
1242 typedef struct _VAHuffmanTableBufferJPEGBaseline {
1243     /** \brief Specifies which #huffman_table is valid. */
1244     unsigned char       load_huffman_table[2];
1245     /** \brief Huffman tables indexed by table identifier (Th). */
1246     struct {
1247         /** @name DC table (up to 12 categories) */
1248         /**@{*/
1249         /** \brief Number of Huffman codes of length i + 1 (Li). */
1250         unsigned char   num_dc_codes[16];
1251         /** \brief Value associated with each Huffman code (Vij). */
1252         unsigned char   dc_values[12];
1253         /**@}*/
1254         /** @name AC table (2 special codes + up to 16 * 10 codes) */
1255         /**@{*/
1256         /** \brief Number of Huffman codes of length i + 1 (Li). */
1257         unsigned char   num_ac_codes[16];
1258         /** \brief Value associated with each Huffman code (Vij). */
1259         unsigned char   ac_values[162];
1260         /** \brief Padding to 4-byte boundaries. Must be set to zero. */
1261         unsigned char   pad[2];
1262         /**@}*/
1263     }                   huffman_table[2];
1264 } VAHuffmanTableBufferJPEGBaseline;
1265
1266 /****************************
1267  * MPEG-2 data structures
1268  ****************************/
1269
1270 /* MPEG-2 Picture Parameter Buffer */
1271 /*
1272  * For each frame or field, and before any slice data, a single
1273  * picture parameter buffer must be send.
1274  */
1275 typedef struct _VAPictureParameterBufferMPEG2
1276 {
1277     unsigned short horizontal_size;
1278     unsigned short vertical_size;
1279     VASurfaceID forward_reference_picture;
1280     VASurfaceID backward_reference_picture;
1281     /* meanings of the following fields are the same as in the standard */
1282     int picture_coding_type;
1283     int f_code; /* pack all four fcode into this */
1284     union {
1285         struct {
1286             unsigned int intra_dc_precision             : 2;
1287             unsigned int picture_structure              : 2;
1288             unsigned int top_field_first                : 1;
1289             unsigned int frame_pred_frame_dct           : 1;
1290             unsigned int concealment_motion_vectors     : 1;
1291             unsigned int q_scale_type                   : 1;
1292             unsigned int intra_vlc_format               : 1;
1293             unsigned int alternate_scan                 : 1;
1294             unsigned int repeat_first_field             : 1;
1295             unsigned int progressive_frame              : 1;
1296             unsigned int is_first_field                 : 1; /* indicate whether the current field
1297                                                               * is the first field for field picture
1298                                                               */
1299         } bits;
1300         unsigned int value;
1301     } picture_coding_extension;
1302 } VAPictureParameterBufferMPEG2;
1303
1304 /** MPEG-2 Inverse Quantization Matrix Buffer */
1305 typedef struct _VAIQMatrixBufferMPEG2
1306 {
1307     /** \brief Same as the MPEG-2 bitstream syntax element. */
1308     int load_intra_quantiser_matrix;
1309     /** \brief Same as the MPEG-2 bitstream syntax element. */
1310     int load_non_intra_quantiser_matrix;
1311     /** \brief Same as the MPEG-2 bitstream syntax element. */
1312     int load_chroma_intra_quantiser_matrix;
1313     /** \brief Same as the MPEG-2 bitstream syntax element. */
1314     int load_chroma_non_intra_quantiser_matrix;
1315     /** \brief Luminance intra matrix, in zig-zag scan order. */
1316     unsigned char intra_quantiser_matrix[64];
1317     /** \brief Luminance non-intra matrix, in zig-zag scan order. */
1318     unsigned char non_intra_quantiser_matrix[64];
1319     /** \brief Chroma intra matrix, in zig-zag scan order. */
1320     unsigned char chroma_intra_quantiser_matrix[64];
1321     /** \brief Chroma non-intra matrix, in zig-zag scan order. */
1322     unsigned char chroma_non_intra_quantiser_matrix[64];
1323 } VAIQMatrixBufferMPEG2;
1324
1325 /** MPEG-2 Slice Parameter Buffer */
1326 typedef struct _VASliceParameterBufferMPEG2
1327 {
1328     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
1329     unsigned int slice_data_offset;/* the offset to the first byte of slice data */
1330     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
1331     unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */
1332     unsigned int slice_horizontal_position;
1333     unsigned int slice_vertical_position;
1334     int quantiser_scale_code;
1335     int intra_slice_flag;
1336 } VASliceParameterBufferMPEG2;
1337
1338 /** MPEG-2 Macroblock Parameter Buffer */
1339 typedef struct _VAMacroblockParameterBufferMPEG2
1340 {
1341     unsigned short macroblock_address;
1342     /*
1343      * macroblock_address (in raster scan order)
1344      * top-left: 0
1345      * bottom-right: picture-height-in-mb*picture-width-in-mb - 1
1346      */
1347     unsigned char macroblock_type;  /* see definition below */
1348     union {
1349         struct {
1350             unsigned int frame_motion_type              : 2;
1351             unsigned int field_motion_type              : 2;
1352             unsigned int dct_type                       : 1;
1353         } bits;
1354         unsigned int value;
1355     } macroblock_modes;
1356     unsigned char motion_vertical_field_select;
1357     /*
1358      * motion_vertical_field_select:
1359      * see section 6.3.17.2 in the spec
1360      * only the lower 4 bits are used
1361      * bit 0: first vector forward
1362      * bit 1: first vector backward
1363      * bit 2: second vector forward
1364      * bit 3: second vector backward
1365      */
1366     short PMV[2][2][2]; /* see Table 7-7 in the spec */
1367     unsigned short coded_block_pattern;
1368     /*
1369      * The bitplanes for coded_block_pattern are described
1370      * in Figure 6.10-12 in the spec
1371      */
1372
1373     /* Number of skipped macroblocks after this macroblock */
1374     unsigned short num_skipped_macroblocks;
1375 } VAMacroblockParameterBufferMPEG2;
1376
1377 /*
1378  * OR'd flags for macroblock_type (section 6.3.17.1 in the spec)
1379  */
1380 #define VA_MB_TYPE_MOTION_FORWARD       0x02
1381 #define VA_MB_TYPE_MOTION_BACKWARD      0x04
1382 #define VA_MB_TYPE_MOTION_PATTERN       0x08
1383 #define VA_MB_TYPE_MOTION_INTRA         0x10
1384
1385 /**
1386  * MPEG-2 Residual Data Buffer
1387  * For each macroblock, there wil be 64 shorts (16-bit) in the
1388  * residual data buffer
1389  */
1390
1391 /****************************
1392  * MPEG-4 Part 2 data structures
1393  ****************************/
1394
1395 /* MPEG-4 Picture Parameter Buffer */
1396 /*
1397  * For each frame or field, and before any slice data, a single
1398  * picture parameter buffer must be send.
1399  */
1400 typedef struct _VAPictureParameterBufferMPEG4
1401 {
1402     unsigned short vop_width;
1403     unsigned short vop_height;
1404     VASurfaceID forward_reference_picture;
1405     VASurfaceID backward_reference_picture;
1406     union {
1407         struct {
1408             unsigned int short_video_header             : 1;
1409             unsigned int chroma_format                  : 2;
1410             unsigned int interlaced                     : 1;
1411             unsigned int obmc_disable                   : 1;
1412             unsigned int sprite_enable                  : 2;
1413             unsigned int sprite_warping_accuracy        : 2;
1414             unsigned int quant_type                     : 1;
1415             unsigned int quarter_sample                 : 1;
1416             unsigned int data_partitioned               : 1;
1417             unsigned int reversible_vlc                 : 1;
1418             unsigned int resync_marker_disable          : 1;
1419         } bits;
1420         unsigned int value;
1421     } vol_fields;
1422     unsigned char no_of_sprite_warping_points;
1423     short sprite_trajectory_du[3];
1424     short sprite_trajectory_dv[3];
1425     unsigned char quant_precision;
1426     union {
1427         struct {
1428             unsigned int vop_coding_type                : 2;
1429             unsigned int backward_reference_vop_coding_type     : 2;
1430             unsigned int vop_rounding_type              : 1;
1431             unsigned int intra_dc_vlc_thr               : 3;
1432             unsigned int top_field_first                : 1;
1433             unsigned int alternate_vertical_scan_flag   : 1;
1434         } bits;
1435         unsigned int value;
1436     } vop_fields;
1437     unsigned char vop_fcode_forward;
1438     unsigned char vop_fcode_backward;
1439     unsigned short vop_time_increment_resolution;
1440     /* short header related */
1441     unsigned char num_gobs_in_vop;
1442     unsigned char num_macroblocks_in_gob;
1443     /* for direct mode prediction */
1444     short TRB;
1445     short TRD;
1446 } VAPictureParameterBufferMPEG4;
1447
1448 /** MPEG-4 Inverse Quantization Matrix Buffer */
1449 typedef struct _VAIQMatrixBufferMPEG4
1450 {
1451     /** Same as the MPEG-4:2 bitstream syntax element. */
1452     int load_intra_quant_mat;
1453     /** Same as the MPEG-4:2 bitstream syntax element. */
1454     int load_non_intra_quant_mat;
1455     /** The matrix for intra blocks, in zig-zag scan order. */
1456     unsigned char intra_quant_mat[64];
1457     /** The matrix for non-intra blocks, in zig-zag scan order. */
1458     unsigned char non_intra_quant_mat[64];
1459 } VAIQMatrixBufferMPEG4;
1460
1461 /** MPEG-4 Slice Parameter Buffer */
1462 typedef struct _VASliceParameterBufferMPEG4
1463 {
1464     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
1465     unsigned int slice_data_offset;/* the offset to the first byte of slice data */
1466     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
1467     unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */
1468     unsigned int macroblock_number;
1469     int quant_scale;
1470 } VASliceParameterBufferMPEG4;
1471
1472 /**
1473  VC-1 data structures
1474 */
1475
1476 typedef enum   /* see 7.1.1.32 */
1477 {
1478     VAMvMode1Mv                        = 0,
1479     VAMvMode1MvHalfPel                 = 1,
1480     VAMvMode1MvHalfPelBilinear         = 2,
1481     VAMvModeMixedMv                    = 3,
1482     VAMvModeIntensityCompensation      = 4
1483 } VAMvModeVC1;
1484
1485 /** VC-1 Picture Parameter Buffer */
1486 /*
1487  * For each picture, and before any slice data, a picture parameter
1488  * buffer must be send. Multiple picture parameter buffers may be
1489  * sent for a single picture. In that case picture parameters will
1490  * apply to all slice data that follow it until a new picture
1491  * parameter buffer is sent.
1492  *
1493  * Notes:
1494  *   pic_quantizer_type should be set to the applicable quantizer
1495  *   type as defined by QUANTIZER (J.1.19) and either
1496  *   PQUANTIZER (7.1.1.8) or PQINDEX (7.1.1.6)
1497  */
1498 typedef struct _VAPictureParameterBufferVC1
1499 {
1500     VASurfaceID forward_reference_picture;
1501     VASurfaceID backward_reference_picture;
1502     /* if out-of-loop post-processing is done on the render
1503        target, then we need to keep the in-loop decoded
1504        picture as a reference picture */
1505     VASurfaceID inloop_decoded_picture;
1506
1507     /* sequence layer for AP or meta data for SP and MP */
1508     union {
1509         struct {
1510             unsigned int pulldown       : 1; /* SEQUENCE_LAYER::PULLDOWN */
1511             unsigned int interlace      : 1; /* SEQUENCE_LAYER::INTERLACE */
1512             unsigned int tfcntrflag     : 1; /* SEQUENCE_LAYER::TFCNTRFLAG */
1513             unsigned int finterpflag    : 1; /* SEQUENCE_LAYER::FINTERPFLAG */
1514             unsigned int psf            : 1; /* SEQUENCE_LAYER::PSF */
1515             unsigned int multires       : 1; /* METADATA::MULTIRES */
1516             unsigned int overlap        : 1; /* METADATA::OVERLAP */
1517             unsigned int syncmarker     : 1; /* METADATA::SYNCMARKER */
1518             unsigned int rangered       : 1; /* METADATA::RANGERED */
1519             unsigned int max_b_frames   : 3; /* METADATA::MAXBFRAMES */
1520             unsigned int profile        : 2; /* SEQUENCE_LAYER::PROFILE or The MSB of METADATA::PROFILE */
1521         } bits;
1522         unsigned int value;
1523     } sequence_fields;
1524
1525     unsigned short coded_width;         /* ENTRY_POINT_LAYER::CODED_WIDTH */
1526     unsigned short coded_height;        /* ENTRY_POINT_LAYER::CODED_HEIGHT */
1527     union {
1528         struct {
1529             unsigned int broken_link    : 1; /* ENTRY_POINT_LAYER::BROKEN_LINK */
1530             unsigned int closed_entry   : 1; /* ENTRY_POINT_LAYER::CLOSED_ENTRY */
1531             unsigned int panscan_flag   : 1; /* ENTRY_POINT_LAYER::PANSCAN_FLAG */
1532             unsigned int loopfilter     : 1; /* ENTRY_POINT_LAYER::LOOPFILTER */
1533         } bits;
1534         unsigned int value;
1535     } entrypoint_fields;
1536     unsigned char conditional_overlap_flag; /* ENTRY_POINT_LAYER::CONDOVER */
1537     unsigned char fast_uvmc_flag;       /* ENTRY_POINT_LAYER::FASTUVMC */
1538     union {
1539         struct {
1540             unsigned int luma_flag      : 1; /* ENTRY_POINT_LAYER::RANGE_MAPY_FLAG */
1541             unsigned int luma           : 3; /* ENTRY_POINT_LAYER::RANGE_MAPY */
1542             unsigned int chroma_flag    : 1; /* ENTRY_POINT_LAYER::RANGE_MAPUV_FLAG */
1543             unsigned int chroma         : 3; /* ENTRY_POINT_LAYER::RANGE_MAPUV */
1544         } bits;
1545         unsigned int value;
1546     } range_mapping_fields;
1547
1548     unsigned char b_picture_fraction;   /* PICTURE_LAYER::BFRACTION */
1549     unsigned char cbp_table;            /* PICTURE_LAYER::CBPTAB/ICBPTAB */
1550     unsigned char mb_mode_table;        /* PICTURE_LAYER::MBMODETAB */
1551     unsigned char range_reduction_frame;/* PICTURE_LAYER::RANGEREDFRM */
1552     unsigned char rounding_control;     /* PICTURE_LAYER::RNDCTRL */
1553     unsigned char post_processing;      /* PICTURE_LAYER::POSTPROC */
1554     unsigned char picture_resolution_index;     /* PICTURE_LAYER::RESPIC */
1555     unsigned char luma_scale;           /* PICTURE_LAYER::LUMSCALE */
1556     unsigned char luma_shift;           /* PICTURE_LAYER::LUMSHIFT */
1557     union {
1558         struct {
1559             unsigned int picture_type           : 3; /* PICTURE_LAYER::PTYPE */
1560             unsigned int frame_coding_mode      : 3; /* PICTURE_LAYER::FCM */
1561             unsigned int top_field_first        : 1; /* PICTURE_LAYER::TFF */
1562             unsigned int is_first_field         : 1; /* set to 1 if it is the first field */
1563             unsigned int intensity_compensation : 1; /* PICTURE_LAYER::INTCOMP */
1564         } bits;
1565         unsigned int value;
1566     } picture_fields;
1567     union {
1568         struct {
1569             unsigned int mv_type_mb     : 1;    /* PICTURE::MVTYPEMB */
1570             unsigned int direct_mb      : 1;    /* PICTURE::DIRECTMB */
1571             unsigned int skip_mb        : 1;    /* PICTURE::SKIPMB */
1572             unsigned int field_tx       : 1;    /* PICTURE::FIELDTX */
1573             unsigned int forward_mb     : 1;    /* PICTURE::FORWARDMB */
1574             unsigned int ac_pred        : 1;    /* PICTURE::ACPRED */
1575             unsigned int overflags      : 1;    /* PICTURE::OVERFLAGS */
1576         } flags;
1577         unsigned int value;
1578     } raw_coding;
1579     union {
1580         struct {
1581             unsigned int bp_mv_type_mb   : 1;    /* PICTURE::MVTYPEMB */
1582             unsigned int bp_direct_mb    : 1;    /* PICTURE::DIRECTMB */
1583             unsigned int bp_skip_mb      : 1;    /* PICTURE::SKIPMB */
1584             unsigned int bp_field_tx     : 1;    /* PICTURE::FIELDTX */
1585             unsigned int bp_forward_mb   : 1;    /* PICTURE::FORWARDMB */
1586             unsigned int bp_ac_pred      : 1;    /* PICTURE::ACPRED */
1587             unsigned int bp_overflags    : 1;    /* PICTURE::OVERFLAGS */
1588         } flags;
1589         unsigned int value;
1590     } bitplane_present; /* signal what bitplane is being passed via the bitplane buffer */
1591     union {
1592         struct {
1593             unsigned int reference_distance_flag : 1;/* PICTURE_LAYER::REFDIST_FLAG */
1594             unsigned int reference_distance     : 5;/* PICTURE_LAYER::REFDIST */
1595             unsigned int num_reference_pictures: 1;/* PICTURE_LAYER::NUMREF */
1596             unsigned int reference_field_pic_indicator  : 1;/* PICTURE_LAYER::REFFIELD */
1597         } bits;
1598         unsigned int value;
1599     } reference_fields;
1600     union {
1601         struct {
1602             unsigned int mv_mode                : 3; /* PICTURE_LAYER::MVMODE */
1603             unsigned int mv_mode2               : 3; /* PICTURE_LAYER::MVMODE2 */
1604             unsigned int mv_table               : 3; /* PICTURE_LAYER::MVTAB/IMVTAB */
1605             unsigned int two_mv_block_pattern_table: 2; /* PICTURE_LAYER::2MVBPTAB */
1606             unsigned int four_mv_switch         : 1; /* PICTURE_LAYER::4MVSWITCH */
1607             unsigned int four_mv_block_pattern_table : 2; /* PICTURE_LAYER::4MVBPTAB */
1608             unsigned int extended_mv_flag       : 1; /* ENTRY_POINT_LAYER::EXTENDED_MV */
1609             unsigned int extended_mv_range      : 2; /* PICTURE_LAYER::MVRANGE */
1610             unsigned int extended_dmv_flag      : 1; /* ENTRY_POINT_LAYER::EXTENDED_DMV */
1611             unsigned int extended_dmv_range     : 2; /* PICTURE_LAYER::DMVRANGE */
1612         } bits;
1613         unsigned int value;
1614     } mv_fields;
1615     union {
1616         struct {
1617             unsigned int dquant : 2;    /* ENTRY_POINT_LAYER::DQUANT */
1618             unsigned int quantizer     : 2;     /* ENTRY_POINT_LAYER::QUANTIZER */
1619             unsigned int half_qp        : 1;    /* PICTURE_LAYER::HALFQP */
1620             unsigned int pic_quantizer_scale : 5;/* PICTURE_LAYER::PQUANT */
1621             unsigned int pic_quantizer_type : 1;/* PICTURE_LAYER::PQUANTIZER */
1622             unsigned int dq_frame       : 1;    /* VOPDQUANT::DQUANTFRM */
1623             unsigned int dq_profile     : 2;    /* VOPDQUANT::DQPROFILE */
1624             unsigned int dq_sb_edge     : 2;    /* VOPDQUANT::DQSBEDGE */
1625             unsigned int dq_db_edge     : 2;    /* VOPDQUANT::DQDBEDGE */
1626             unsigned int dq_binary_level : 1;   /* VOPDQUANT::DQBILEVEL */
1627             unsigned int alt_pic_quantizer : 5;/* VOPDQUANT::ALTPQUANT */
1628         } bits;
1629         unsigned int value;
1630     } pic_quantizer_fields;
1631     union {
1632         struct {
1633             unsigned int variable_sized_transform_flag  : 1;/* ENTRY_POINT_LAYER::VSTRANSFORM */
1634             unsigned int mb_level_transform_type_flag   : 1;/* PICTURE_LAYER::TTMBF */
1635             unsigned int frame_level_transform_type     : 2;/* PICTURE_LAYER::TTFRM */
1636             unsigned int transform_ac_codingset_idx1    : 2;/* PICTURE_LAYER::TRANSACFRM */
1637             unsigned int transform_ac_codingset_idx2    : 2;/* PICTURE_LAYER::TRANSACFRM2 */
1638             unsigned int intra_transform_dc_table       : 1;/* PICTURE_LAYER::TRANSDCTAB */
1639         } bits;
1640         unsigned int value;
1641     } transform_fields;
1642 } VAPictureParameterBufferVC1;
1643
1644 /** VC-1 Bitplane Buffer
1645 There will be at most three bitplanes coded in any picture header. To send
1646 the bitplane data more efficiently, each byte is divided in two nibbles, with
1647 each nibble carrying three bitplanes for one macroblock.  The following table
1648 shows the bitplane data arrangement within each nibble based on the picture
1649 type.
1650
1651 Picture Type    Bit3            Bit2            Bit1            Bit0
1652 I or BI                         OVERFLAGS       ACPRED          FIELDTX
1653 P                               MYTYPEMB        SKIPMB          DIRECTMB
1654 B                               FORWARDMB       SKIPMB          DIRECTMB
1655
1656 Within each byte, the lower nibble is for the first MB and the upper nibble is
1657 for the second MB.  E.g. the lower nibble of the first byte in the bitplane
1658 buffer is for Macroblock #1 and the upper nibble of the first byte is for
1659 Macroblock #2 in the first row.
1660 */
1661
1662 /* VC-1 Slice Parameter Buffer */
1663 typedef struct _VASliceParameterBufferVC1
1664 {
1665     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
1666     unsigned int slice_data_offset;/* the offset to the first byte of slice data */
1667     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
1668     unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */
1669     unsigned int slice_vertical_position;
1670 } VASliceParameterBufferVC1;
1671
1672 /* VC-1 Slice Data Buffer */
1673 /*
1674 This is simplely a buffer containing raw bit-stream bytes
1675 */
1676
1677 /****************************
1678  * H.264/AVC data structures
1679  ****************************/
1680
1681 typedef struct _VAPictureH264
1682 {
1683     VASurfaceID picture_id;
1684     unsigned int frame_idx;
1685     unsigned int flags;
1686     signed int TopFieldOrderCnt;
1687     signed int BottomFieldOrderCnt;
1688 } VAPictureH264;
1689 /* flags in VAPictureH264 could be OR of the following */
1690 #define VA_PICTURE_H264_INVALID                 0x00000001
1691 #define VA_PICTURE_H264_TOP_FIELD               0x00000002
1692 #define VA_PICTURE_H264_BOTTOM_FIELD            0x00000004
1693 #define VA_PICTURE_H264_SHORT_TERM_REFERENCE    0x00000008
1694 #define VA_PICTURE_H264_LONG_TERM_REFERENCE     0x00000010
1695
1696 /** H.264 Picture Parameter Buffer */
1697 /*
1698  * For each picture, and before any slice data, a single
1699  * picture parameter buffer must be send.
1700  */
1701 typedef struct _VAPictureParameterBufferH264
1702 {
1703     VAPictureH264 CurrPic;
1704     VAPictureH264 ReferenceFrames[16];  /* in DPB */
1705     unsigned short picture_width_in_mbs_minus1;
1706     unsigned short picture_height_in_mbs_minus1;
1707     unsigned char bit_depth_luma_minus8;
1708     unsigned char bit_depth_chroma_minus8;
1709     unsigned char num_ref_frames;
1710     union {
1711         struct {
1712             unsigned int chroma_format_idc                      : 2;
1713             unsigned int residual_colour_transform_flag         : 1;
1714             unsigned int gaps_in_frame_num_value_allowed_flag   : 1;
1715             unsigned int frame_mbs_only_flag                    : 1;
1716             unsigned int mb_adaptive_frame_field_flag           : 1;
1717             unsigned int direct_8x8_inference_flag              : 1;
1718             unsigned int MinLumaBiPredSize8x8                   : 1; /* see A.3.3.2 */
1719             unsigned int log2_max_frame_num_minus4              : 4;
1720             unsigned int pic_order_cnt_type                     : 2;
1721             unsigned int log2_max_pic_order_cnt_lsb_minus4      : 4;
1722             unsigned int delta_pic_order_always_zero_flag       : 1;
1723         } bits;
1724         unsigned int value;
1725     } seq_fields;
1726     unsigned char num_slice_groups_minus1;
1727     unsigned char slice_group_map_type;
1728     unsigned short slice_group_change_rate_minus1;
1729     signed char pic_init_qp_minus26;
1730     signed char pic_init_qs_minus26;
1731     signed char chroma_qp_index_offset;
1732     signed char second_chroma_qp_index_offset;
1733     union {
1734         struct {
1735             unsigned int entropy_coding_mode_flag       : 1;
1736             unsigned int weighted_pred_flag             : 1;
1737             unsigned int weighted_bipred_idc            : 2;
1738             unsigned int transform_8x8_mode_flag        : 1;
1739             unsigned int field_pic_flag                 : 1;
1740             unsigned int constrained_intra_pred_flag    : 1;
1741             unsigned int pic_order_present_flag                 : 1;
1742             unsigned int deblocking_filter_control_present_flag : 1;
1743             unsigned int redundant_pic_cnt_present_flag         : 1;
1744             unsigned int reference_pic_flag                     : 1; /* nal_ref_idc != 0 */
1745         } bits;
1746         unsigned int value;
1747     } pic_fields;
1748     unsigned short frame_num;
1749 } VAPictureParameterBufferH264;
1750
1751 /** H.264 Inverse Quantization Matrix Buffer */
1752 typedef struct _VAIQMatrixBufferH264
1753 {
1754     /** \brief 4x4 scaling list, in raster scan order. */
1755     unsigned char ScalingList4x4[6][16];
1756     /** \brief 8x8 scaling list, in raster scan order. */
1757     unsigned char ScalingList8x8[2][64];
1758 } VAIQMatrixBufferH264;
1759
1760 /**
1761  * H.264 Slice Group Map Buffer
1762  * When VAPictureParameterBufferH264::num_slice_group_minus1 is not equal to 0,
1763  * A slice group map buffer should be sent for each picture if required. The buffer
1764  * is sent only when there is a change in the mapping values.
1765  * The slice group map buffer map "map units" to slice groups as specified in
1766  * section 8.2.2 of the H.264 spec. The buffer will contain one byte for each macroblock
1767  * in raster scan order
1768  */
1769
1770 /** H.264 Slice Parameter Buffer */
1771 typedef struct _VASliceParameterBufferH264
1772 {
1773     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
1774     /** \brief Byte offset to the NAL Header Unit for this slice. */
1775     unsigned int slice_data_offset;
1776     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
1777     /**
1778      * \brief Bit offset from NAL Header Unit to the begining of slice_data().
1779      *
1780      * This bit offset is relative to and includes the NAL unit byte
1781      * and represents the number of bits parsed in the slice_header()
1782      * after the removal of any emulation prevention bytes in
1783      * there. However, the slice data buffer passed to the hardware is
1784      * the original bitstream, thus including any emulation prevention
1785      * bytes.
1786      */
1787     unsigned short slice_data_bit_offset;
1788     unsigned short first_mb_in_slice;
1789     unsigned char slice_type;
1790     unsigned char direct_spatial_mv_pred_flag;
1791     unsigned char num_ref_idx_l0_active_minus1;
1792     unsigned char num_ref_idx_l1_active_minus1;
1793     unsigned char cabac_init_idc;
1794     char slice_qp_delta;
1795     unsigned char disable_deblocking_filter_idc;
1796     char slice_alpha_c0_offset_div2;
1797     char slice_beta_offset_div2;
1798     VAPictureH264 RefPicList0[32];      /* See 8.2.4.2 */
1799     VAPictureH264 RefPicList1[32];      /* See 8.2.4.2 */
1800     unsigned char luma_log2_weight_denom;
1801     unsigned char chroma_log2_weight_denom;
1802     unsigned char luma_weight_l0_flag;
1803     short luma_weight_l0[32];
1804     short luma_offset_l0[32];
1805     unsigned char chroma_weight_l0_flag;
1806     short chroma_weight_l0[32][2];
1807     short chroma_offset_l0[32][2];
1808     unsigned char luma_weight_l1_flag;
1809     short luma_weight_l1[32];
1810     short luma_offset_l1[32];
1811     unsigned char chroma_weight_l1_flag;
1812     short chroma_weight_l1[32][2];
1813     short chroma_offset_l1[32][2];
1814 } VASliceParameterBufferH264;
1815
1816 /****************************
1817  * Common encode data structures
1818  ****************************/
1819 typedef enum
1820 {
1821     VAEncPictureTypeIntra               = 0,
1822     VAEncPictureTypePredictive          = 1,
1823     VAEncPictureTypeBidirectional       = 2,
1824 } VAEncPictureType;
1825
1826 /* Encode Slice Parameter Buffer */
1827 typedef struct _VAEncSliceParameterBuffer
1828 {
1829     unsigned int start_row_number;      /* starting MB row number for this slice */
1830     unsigned int slice_height;  /* slice height measured in MB */
1831     union {
1832         struct {
1833             unsigned int is_intra       : 1;
1834             unsigned int disable_deblocking_filter_idc : 2;
1835             unsigned int uses_long_term_ref             :1;
1836             unsigned int is_long_term_ref               :1;
1837         } bits;
1838         unsigned int value;
1839     } slice_flags;
1840 } VAEncSliceParameterBuffer;
1841
1842
1843 /****************************
1844  * H.263 specific encode data structures
1845  ****************************/
1846
1847 typedef struct _VAEncSequenceParameterBufferH263
1848 {
1849     unsigned int intra_period;
1850     unsigned int bits_per_second;
1851     unsigned int frame_rate;
1852     unsigned int initial_qp;
1853     unsigned int min_qp;
1854 } VAEncSequenceParameterBufferH263;
1855
1856 typedef struct _VAEncPictureParameterBufferH263
1857 {
1858     VASurfaceID reference_picture;
1859     VASurfaceID reconstructed_picture;
1860     VABufferID coded_buf;
1861     unsigned short picture_width;
1862     unsigned short picture_height;
1863     VAEncPictureType picture_type;
1864 } VAEncPictureParameterBufferH263;
1865
1866 /****************************
1867  * MPEG-4 specific encode data structures
1868  ****************************/
1869
1870 typedef struct _VAEncSequenceParameterBufferMPEG4
1871 {
1872     unsigned char profile_and_level_indication;
1873     unsigned int intra_period;
1874     unsigned int video_object_layer_width;
1875     unsigned int video_object_layer_height;
1876     unsigned int vop_time_increment_resolution;
1877     unsigned int fixed_vop_rate;
1878     unsigned int fixed_vop_time_increment;
1879     unsigned int bits_per_second;
1880     unsigned int frame_rate;
1881     unsigned int initial_qp;
1882     unsigned int min_qp;
1883 } VAEncSequenceParameterBufferMPEG4;
1884
1885 typedef struct _VAEncPictureParameterBufferMPEG4
1886 {
1887     VASurfaceID reference_picture;
1888     VASurfaceID reconstructed_picture;
1889     VABufferID coded_buf;
1890     unsigned short picture_width;
1891     unsigned short picture_height;
1892     unsigned int modulo_time_base; /* number of 1s */
1893     unsigned int vop_time_increment;
1894     VAEncPictureType picture_type;
1895 } VAEncPictureParameterBufferMPEG4;
1896
1897
1898
1899 /** Buffer functions */
1900
1901 /**
1902  * Creates a buffer for "num_elements" elements of "size" bytes and
1903  * initalize with "data".
1904  * if "data" is null, then the contents of the buffer data store
1905  * are undefined.
1906  * Basically there are two ways to get buffer data to the server side. One is
1907  * to call vaCreateBuffer() with a non-null "data", which results the data being
1908  * copied to the data store on the server side.  A different method that
1909  * eliminates this copy is to pass null as "data" when calling vaCreateBuffer(),
1910  * and then use vaMapBuffer() to map the data store from the server side to the
1911  * client address space for access.
1912  *  Note: image buffers are created by the library, not the client. Please see
1913  *        vaCreateImage on how image buffers are managed.
1914  */
1915 VAStatus vaCreateBuffer (
1916     VADisplay dpy,
1917     VAContextID context,
1918     VABufferType type,  /* in */
1919     unsigned int size,  /* in */
1920     unsigned int num_elements, /* in */
1921     void *data,         /* in */
1922     VABufferID *buf_id  /* out */
1923 );
1924
1925 /**
1926  * Convey to the server how many valid elements are in the buffer.
1927  * e.g. if multiple slice parameters are being held in a single buffer,
1928  * this will communicate to the server the number of slice parameters
1929  * that are valid in the buffer.
1930  */
1931 VAStatus vaBufferSetNumElements (
1932     VADisplay dpy,
1933     VABufferID buf_id,  /* in */
1934     unsigned int num_elements /* in */
1935 );
1936
1937
1938 /**
1939  * device independent data structure for codedbuffer
1940  */
1941
1942 /*
1943  * FICTURE_AVE_QP(bit7-0): The average Qp value used during this frame
1944  * LARGE_SLICE(bit8):At least one slice in the current frame was large
1945  *              enough for the encoder to attempt to limit its size.
1946  * SLICE_OVERFLOW(bit9): At least one slice in the current frame has
1947  *              exceeded the maximum slice size specified.
1948  * BITRATE_OVERFLOW(bit10): The peak bitrate was exceeded for this frame.
1949  * BITRATE_HIGH(bit11): The frame size got within the safety margin of the maximum size (VCM only)
1950  * AIR_MB_OVER_THRESHOLD: the number of MBs adapted to Intra MB
1951  */
1952 #define VA_CODED_BUF_STATUS_PICTURE_AVE_QP_MASK         0xff
1953 #define VA_CODED_BUF_STATUS_LARGE_SLICE_MASK            0x100
1954 #define VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK         0x200
1955 #define VA_CODED_BUF_STATUS_BITRATE_OVERFLOW            0x400
1956 #define VA_CODED_BUF_STATUS_BITRATE_HIGH                0x800
1957 /**
1958  * \brief The frame has exceeded the maximum requested size.
1959  *
1960  * This flag indicates that the encoded frame size exceeds the value
1961  * specified through a misc parameter buffer of type
1962  * #VAEncMiscParameterTypeMaxFrameSize.
1963  */
1964 #define VA_CODED_BUF_STATUS_FRAME_SIZE_OVERFLOW         0x1000
1965 #define VA_CODED_BUF_STATUS_AIR_MB_OVER_THRESHOLD       0xff0000
1966
1967 /**
1968  * \brief The coded buffer segment contains a single NAL unit.
1969  *
1970  * This flag indicates that the coded buffer segment contains a
1971  * single NAL unit. This flag might be useful to the user for
1972  * processing the coded buffer.
1973  */
1974 #define VA_CODED_BUF_STATUS_SINGLE_NALU                 0x10000000
1975
1976 /**
1977  * \brief Coded buffer segment.
1978  *
1979  * #VACodedBufferSegment is an element of a linked list describing
1980  * some information on the coded buffer. The coded buffer segment
1981  * could contain either a single NAL unit, or more than one NAL unit.
1982  * It is recommended (but not required) to return a single NAL unit
1983  * in a coded buffer segment, and the implementation should set the
1984  * VA_CODED_BUF_STATUS_SINGLE_NALU status flag if that is the case.
1985  */
1986 typedef  struct _VACodedBufferSegment  {
1987     /**
1988      * \brief Size of the data buffer in this segment (in bytes).
1989      */
1990     unsigned int        size;
1991     /** \brief Bit offset into the data buffer where the video data starts. */
1992     unsigned int        bit_offset;
1993     /** \brief Status set by the driver. See \c VA_CODED_BUF_STATUS_*. */
1994     unsigned int        status;
1995     /** \brief Reserved for future use. */
1996     unsigned int        reserved;
1997     /** \brief Pointer to the start of the data buffer. */
1998     void               *buf;
1999     /**
2000      * \brief Pointer to the next #VACodedBufferSegment element,
2001      * or \c NULL if there is none.
2002      */
2003     void               *next;
2004 } VACodedBufferSegment;
2005
2006 /**
2007  * Map data store of the buffer into the client's address space
2008  * vaCreateBuffer() needs to be called with "data" set to NULL before
2009  * calling vaMapBuffer()
2010  *
2011  * if buffer type is VAEncCodedBufferType, pbuf points to link-list of
2012  * VACodedBufferSegment, and the list is terminated if "next" is NULL
2013  */
2014 VAStatus vaMapBuffer (
2015     VADisplay dpy,
2016     VABufferID buf_id,  /* in */
2017     void **pbuf         /* out */
2018 );
2019
2020 /**
2021  * After client making changes to a mapped data store, it needs to
2022  * "Unmap" it to let the server know that the data is ready to be
2023  * consumed by the server
2024  */
2025 VAStatus vaUnmapBuffer (
2026     VADisplay dpy,
2027     VABufferID buf_id   /* in */
2028 );
2029
2030 /**
2031  * After this call, the buffer is deleted and this buffer_id is no longer valid
2032  * Only call this if the buffer is not going to be passed to vaRenderBuffer
2033  */
2034 VAStatus vaDestroyBuffer (
2035     VADisplay dpy,
2036     VABufferID buffer_id
2037 );
2038
2039 /** \brief VA buffer information */
2040 typedef struct {
2041     /** \brief Buffer handle */
2042     uintptr_t           handle;
2043     /** \brief Buffer type (See \ref VABufferType). */
2044     uint32_t            type;
2045     /**
2046      * \brief Buffer memory type (See \ref VASurfaceAttribMemoryType).
2047      *
2048      * On input to vaAcquireBufferHandle(), this field can serve as a hint
2049      * to specify the set of memory types the caller is interested in.
2050      * On successful return from vaAcquireBufferHandle(), the field is
2051      * updated with the best matching memory type.
2052      */
2053     uint32_t            mem_type;
2054     /** \brief Size of the underlying buffer. */
2055     size_t              mem_size;
2056 } VABufferInfo;
2057
2058 /**
2059  * \brief Acquires buffer handle for external API usage
2060  *
2061  * Locks the VA buffer object \ref buf_id for external API usage like
2062  * EGL or OpenCL (OCL). This function is a synchronization point. This
2063  * means that any pending operation is guaranteed to be completed
2064  * prior to returning from the function.
2065  *
2066  * If the referenced VA buffer object is the backing store of a VA
2067  * surface, then this function acts as if vaSyncSurface() on the
2068  * parent surface was called first.
2069  *
2070  * The \ref VABufferInfo argument shall be zero'ed on input. On
2071  * successful output, the data structure is filled in with all the
2072  * necessary buffer level implementation details like handle, type,
2073  * memory type and memory size.
2074  *
2075  * Note: the external API implementation, or the application, can
2076  * express the memory types it is interested in by filling in the \ref
2077  * mem_type field accordingly. On successful output, the memory type
2078  * that fits best the request and that was used is updated in the \ref
2079  * VABufferInfo data structure. If none of the supplied memory types
2080  * is supported, then a \ref VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE
2081  * error is returned.
2082  *
2083  * The \ref VABufferInfo data is valid until vaReleaseBufferHandle()
2084  * is called. Besides, no additional operation is allowed on any of
2085  * the buffer parent object until vaReleaseBufferHandle() is called.
2086  * e.g. decoding into a VA surface backed with the supplied VA buffer
2087  * object \ref buf_id would fail with a \ref VA_STATUS_ERROR_SURFACE_BUSY
2088  * error.
2089  *
2090  * Possible errors:
2091  * - \ref VA_STATUS_ERROR_UNIMPLEMENTED: the VA driver implementation
2092  *   does not support this interface
2093  * - \ref VA_STATUS_ERROR_INVALID_DISPLAY: an invalid display was supplied
2094  * - \ref VA_STATUS_ERROR_INVALID_BUFFER: an invalid buffer was supplied
2095  * - \ref VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE: the implementation
2096  *   does not support exporting buffers of the specified type
2097  * - \ref VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE: none of the requested
2098  *   memory types in \ref VABufferInfo.mem_type was supported
2099  *
2100  * @param[in] dpy               the VA display
2101  * @param[in] buf_id            the VA buffer
2102  * @param[in,out] buf_info      the associated VA buffer information
2103  * @return VA_STATUS_SUCCESS if successful
2104  */
2105 VAStatus
2106 vaAcquireBufferHandle(VADisplay dpy, VABufferID buf_id, VABufferInfo *buf_info);
2107
2108 /**
2109  * \brief Releases buffer after usage from external API
2110  *
2111  * Unlocks the VA buffer object \ref buf_id from external API usage like
2112  * EGL or OpenCL (OCL). This function is a synchronization point. This
2113  * means that any pending operation is guaranteed to be completed
2114  * prior to returning from the function.
2115  *
2116  * The \ref VABufferInfo argument shall point to the original data
2117  * structure that was obtained from vaAcquireBufferHandle(), unaltered.
2118  * This is necessary so that the VA driver implementation could
2119  * deallocate any resources that were needed.
2120  *
2121  * In any case, returning from this function invalidates any contents
2122  * in \ref VABufferInfo. i.e. the underlyng buffer handle is no longer
2123  * valid. Therefore, VA driver implementations are free to reset this
2124  * data structure to safe defaults.
2125  *
2126  * Possible errors:
2127  * - \ref VA_STATUS_ERROR_UNIMPLEMENTED: the VA driver implementation
2128  *   does not support this interface
2129  * - \ref VA_STATUS_ERROR_INVALID_DISPLAY: an invalid display was supplied
2130  * - \ref VA_STATUS_ERROR_INVALID_BUFFER: an invalid buffer was supplied
2131  * - \ref VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE: the implementation
2132  *   does not support exporting buffers of the specified type
2133  *
2134  * @param[in] dpy               the VA display
2135  * @param[in] buf_id            the VA buffer
2136  * @return VA_STATUS_SUCCESS if successful
2137  */
2138 VAStatus
2139 vaReleaseBufferHandle(VADisplay dpy, VABufferID buf_id);
2140
2141 /*
2142 Render (Decode) Pictures
2143
2144 A picture represents either a frame or a field.
2145
2146 The Begin/Render/End sequence sends the decode buffers to the server
2147 */
2148
2149 /**
2150  * Get ready to decode a picture to a target surface
2151  */
2152 VAStatus vaBeginPicture (
2153     VADisplay dpy,
2154     VAContextID context,
2155     VASurfaceID render_target
2156 );
2157
2158 /**
2159  * Send decode buffers to the server.
2160  * Buffers are automatically destroyed afterwards
2161  */
2162 VAStatus vaRenderPicture (
2163     VADisplay dpy,
2164     VAContextID context,
2165     VABufferID *buffers,
2166     int num_buffers
2167 );
2168
2169 /**
2170  * Make the end of rendering for a picture.
2171  * The server should start processing all pending operations for this
2172  * surface. This call is non-blocking. The client can start another
2173  * Begin/Render/End sequence on a different render target.
2174  */
2175 VAStatus vaEndPicture (
2176     VADisplay dpy,
2177     VAContextID context
2178 );
2179
2180 /*
2181
2182 Synchronization
2183
2184 */
2185
2186 /**
2187  * This function blocks until all pending operations on the render target
2188  * have been completed.  Upon return it is safe to use the render target for a
2189  * different picture.
2190  */
2191 VAStatus vaSyncSurface (
2192     VADisplay dpy,
2193     VASurfaceID render_target
2194 );
2195
2196 typedef enum
2197 {
2198     VASurfaceRendering  = 1, /* Rendering in progress */
2199     VASurfaceDisplaying = 2, /* Displaying in progress (not safe to render into it) */
2200                              /* this status is useful if surface is used as the source */
2201                              /* of an overlay */
2202     VASurfaceReady      = 4, /* not being rendered or displayed */
2203     VASurfaceSkipped    = 8  /* Indicate a skipped frame during encode */
2204 } VASurfaceStatus;
2205
2206 /**
2207  * Find out any pending ops on the render target
2208  */
2209 VAStatus vaQuerySurfaceStatus (
2210     VADisplay dpy,
2211     VASurfaceID render_target,
2212     VASurfaceStatus *status     /* out */
2213 );
2214
2215 typedef enum
2216 {
2217     VADecodeSliceMissing            = 0,
2218     VADecodeMBError                 = 1,
2219 } VADecodeErrorType;
2220
2221 /**
2222  * Client calls vaQuerySurfaceError with VA_STATUS_ERROR_DECODING_ERROR, server side returns
2223  * an array of structure VASurfaceDecodeMBErrors, and the array is terminated by setting status=-1
2224 */
2225 typedef struct _VASurfaceDecodeMBErrors
2226 {
2227     int status; /* 1 if hardware has returned detailed info below, -1 means this record is invalid */
2228     unsigned int start_mb; /* start mb address with errors */
2229     unsigned int end_mb;  /* end mb address with errors */
2230     VADecodeErrorType decode_error_type;
2231 } VASurfaceDecodeMBErrors;
2232
2233 /**
2234  * After the application gets VA_STATUS_ERROR_DECODING_ERROR after calling vaSyncSurface(),
2235  * it can call vaQuerySurfaceError to find out further details on the particular error.
2236  * VA_STATUS_ERROR_DECODING_ERROR should be passed in as "error_status",
2237  * upon the return, error_info will point to an array of _VASurfaceDecodeMBErrors structure,
2238  * which is allocated and filled by libVA with detailed information on the missing or error macroblocks.
2239  * The array is terminated if "status==-1" is detected.
2240  */
2241 VAStatus vaQuerySurfaceError(
2242     VADisplay dpy,
2243     VASurfaceID surface,
2244     VAStatus error_status,
2245     void **error_info
2246 );
2247
2248 /**
2249  * Images and Subpictures
2250  * VAImage is used to either get the surface data to client memory, or
2251  * to copy image data in client memory to a surface.
2252  * Both images, subpictures and surfaces follow the same 2D coordinate system where origin
2253  * is at the upper left corner with positive X to the right and positive Y down
2254  */
2255 #define VA_FOURCC(ch0, ch1, ch2, ch3) \
2256     ((unsigned long)(unsigned char) (ch0) | ((unsigned long)(unsigned char) (ch1) << 8) | \
2257     ((unsigned long)(unsigned char) (ch2) << 16) | ((unsigned long)(unsigned char) (ch3) << 24 ))
2258
2259 /*
2260  * Pre-defined fourcc codes
2261  */
2262 #define VA_FOURCC_NV12          0x3231564E
2263 #define VA_FOURCC_AI44          0x34344149
2264 #define VA_FOURCC_RGBA          0x41424752
2265 #define VA_FOURCC_RGBX          0x58424752
2266 #define VA_FOURCC_BGRA          0x41524742
2267 #define VA_FOURCC_BGRX          0x58524742
2268 #define VA_FOURCC_ARGB          0x42475241
2269 #define VA_FOURCC_XRGB          0x42475258
2270 #define VA_FOURCC_ABGR          0x52474241
2271 #define VA_FOURCC_XBGR          0x52474258
2272 #define VA_FOURCC_UYVY          0x59565955
2273 #define VA_FOURCC_YUY2          0x32595559
2274 #define VA_FOURCC_AYUV          0x56555941
2275 #define VA_FOURCC_NV11          0x3131564e
2276 #define VA_FOURCC_YV12          0x32315659
2277 #define VA_FOURCC_P208          0x38303250
2278 #define VA_FOURCC_IYUV          0x56555949
2279 #define VA_FOURCC_YV24          0x34325659
2280 #define VA_FOURCC_YV32          0x32335659
2281 #define VA_FOURCC_Y800          0x30303859
2282 #define VA_FOURCC_IMC3          0x33434D49
2283 #define VA_FOURCC_411P          0x50313134
2284 #define VA_FOURCC_422H          0x48323234
2285 #define VA_FOURCC_422V          0x56323234
2286 #define VA_FOURCC_444P          0x50343434
2287 #define VA_FOURCC_RGBP          0x50424752
2288 #define VA_FOURCC_BGRP          0x50524742
2289 #define VA_FOURCC_411R          0x52313134 /* rotated 411P */
2290 /**
2291  * Planar YUV 4:2:2.
2292  * 8-bit Y plane, followed by 8-bit 2x1 subsampled V and U planes
2293  */
2294 #define VA_FOURCC_YV16          0x36315659
2295 /**
2296  * 10-bit and 16-bit Planar YUV 4:2:0.
2297  */
2298 #define VA_FOURCC_P010          0x30313050
2299 #define VA_FOURCC_P016          0x36313050
2300
2301 /* byte order */
2302 #define VA_LSB_FIRST            1
2303 #define VA_MSB_FIRST            2
2304
2305 typedef struct _VAImageFormat
2306 {
2307     unsigned int        fourcc;
2308     unsigned int        byte_order; /* VA_LSB_FIRST, VA_MSB_FIRST */
2309     unsigned int        bits_per_pixel;
2310     /* for RGB formats */
2311     unsigned int        depth; /* significant bits per pixel */
2312     unsigned int        red_mask;
2313     unsigned int        green_mask;
2314     unsigned int        blue_mask;
2315     unsigned int        alpha_mask;
2316 } VAImageFormat;
2317
2318 typedef VAGenericID VAImageID;
2319
2320 typedef struct _VAImage
2321 {
2322     VAImageID           image_id; /* uniquely identify this image */
2323     VAImageFormat       format;
2324     VABufferID          buf;    /* image data buffer */
2325     /*
2326      * Image data will be stored in a buffer of type VAImageBufferType to facilitate
2327      * data store on the server side for optimal performance. The buffer will be
2328      * created by the CreateImage function, and proper storage allocated based on the image
2329      * size and format. This buffer is managed by the library implementation, and
2330      * accessed by the client through the buffer Map/Unmap functions.
2331      */
2332     unsigned short      width;
2333     unsigned short      height;
2334     unsigned int        data_size;
2335     unsigned int        num_planes;     /* can not be greater than 3 */
2336     /*
2337      * An array indicating the scanline pitch in bytes for each plane.
2338      * Each plane may have a different pitch. Maximum 3 planes for planar formats
2339      */
2340     unsigned int        pitches[3];
2341     /*
2342      * An array indicating the byte offset from the beginning of the image data
2343      * to the start of each plane.
2344      */
2345     unsigned int        offsets[3];
2346
2347     /* The following fields are only needed for paletted formats */
2348     int num_palette_entries;   /* set to zero for non-palette images */
2349     /*
2350      * Each component is one byte and entry_bytes indicates the number of components in
2351      * each entry (eg. 3 for YUV palette entries). set to zero for non-palette images
2352      */
2353     int entry_bytes;
2354     /*
2355      * An array of ascii characters describing the order of the components within the bytes.
2356      * Only entry_bytes characters of the string are used.
2357      */
2358     char component_order[4];
2359 } VAImage;
2360
2361 /** Get maximum number of image formats supported by the implementation */
2362 int vaMaxNumImageFormats (
2363     VADisplay dpy
2364 );
2365
2366 /**
2367  * Query supported image formats
2368  * The caller must provide a "format_list" array that can hold at
2369  * least vaMaxNumImageFormats() entries. The actual number of formats
2370  * returned in "format_list" is returned in "num_formats".
2371  */
2372 VAStatus vaQueryImageFormats (
2373     VADisplay dpy,
2374     VAImageFormat *format_list, /* out */
2375     int *num_formats            /* out */
2376 );
2377
2378 /**
2379  * Create a VAImage structure
2380  * The width and height fields returned in the VAImage structure may get
2381  * enlarged for some YUV formats. Upon return from this function,
2382  * image->buf has been created and proper storage allocated by the library.
2383  * The client can access the image through the Map/Unmap calls.
2384  */
2385 VAStatus vaCreateImage (
2386     VADisplay dpy,
2387     VAImageFormat *format,
2388     int width,
2389     int height,
2390     VAImage *image      /* out */
2391 );
2392
2393 /**
2394  * Should call DestroyImage before destroying the surface it is bound to
2395  */
2396 VAStatus vaDestroyImage (
2397     VADisplay dpy,
2398     VAImageID image
2399 );
2400
2401 VAStatus vaSetImagePalette (
2402     VADisplay dpy,
2403     VAImageID image,
2404     /*
2405      * pointer to an array holding the palette data.  The size of the array is
2406      * num_palette_entries * entry_bytes in size.  The order of the components
2407      * in the palette is described by the component_order in VAImage struct
2408      */
2409     unsigned char *palette
2410 );
2411
2412 /**
2413  * Retrive surface data into a VAImage
2414  * Image must be in a format supported by the implementation
2415  */
2416 VAStatus vaGetImage (
2417     VADisplay dpy,
2418     VASurfaceID surface,
2419     int x,      /* coordinates of the upper left source pixel */
2420     int y,
2421     unsigned int width, /* width and height of the region */
2422     unsigned int height,
2423     VAImageID image
2424 );
2425
2426 /**
2427  * Copy data from a VAImage to a surface
2428  * Image must be in a format supported by the implementation
2429  * Returns a VA_STATUS_ERROR_SURFACE_BUSY if the surface
2430  * shouldn't be rendered into when this is called
2431  */
2432 VAStatus vaPutImage (
2433     VADisplay dpy,
2434     VASurfaceID surface,
2435     VAImageID image,
2436     int src_x,
2437     int src_y,
2438     unsigned int src_width,
2439     unsigned int src_height,
2440     int dest_x,
2441     int dest_y,
2442     unsigned int dest_width,
2443     unsigned int dest_height
2444 );
2445
2446 /**
2447  * Derive an VAImage from an existing surface.
2448  * This interface will derive a VAImage and corresponding image buffer from
2449  * an existing VA Surface. The image buffer can then be mapped/unmapped for
2450  * direct CPU access. This operation is only possible on implementations with
2451  * direct rendering capabilities and internal surface formats that can be
2452  * represented with a VAImage. When the operation is not possible this interface
2453  * will return VA_STATUS_ERROR_OPERATION_FAILED. Clients should then fall back
2454  * to using vaCreateImage + vaPutImage to accomplish the same task in an
2455  * indirect manner.
2456  *
2457  * Implementations should only return success when the resulting image buffer
2458  * would be useable with vaMap/Unmap.
2459  *
2460  * When directly accessing a surface special care must be taken to insure
2461  * proper synchronization with the graphics hardware. Clients should call
2462  * vaQuerySurfaceStatus to insure that a surface is not the target of concurrent
2463  * rendering or currently being displayed by an overlay.
2464  *
2465  * Additionally nothing about the contents of a surface should be assumed
2466  * following a vaPutSurface. Implementations are free to modify the surface for
2467  * scaling or subpicture blending within a call to vaPutImage.
2468  *
2469  * Calls to vaPutImage or vaGetImage using the same surface from which the image
2470  * has been derived will return VA_STATUS_ERROR_SURFACE_BUSY. vaPutImage or
2471  * vaGetImage with other surfaces is supported.
2472  *
2473  * An image created with vaDeriveImage should be freed with vaDestroyImage. The
2474  * image and image buffer structures will be destroyed; however, the underlying
2475  * surface will remain unchanged until freed with vaDestroySurfaces.
2476  */
2477 VAStatus vaDeriveImage (
2478     VADisplay dpy,
2479     VASurfaceID surface,
2480     VAImage *image      /* out */
2481 );
2482
2483 /**
2484  * Subpictures
2485  * Subpicture is a special type of image that can be blended
2486  * with a surface during vaPutSurface(). Subpicture can be used to render
2487  * DVD sub-titles or closed captioning text etc.
2488  */
2489
2490 typedef VAGenericID VASubpictureID;
2491
2492 /** Get maximum number of subpicture formats supported by the implementation */
2493 int vaMaxNumSubpictureFormats (
2494     VADisplay dpy
2495 );
2496
2497 /** flags for subpictures */
2498 #define VA_SUBPICTURE_CHROMA_KEYING                     0x0001
2499 #define VA_SUBPICTURE_GLOBAL_ALPHA                      0x0002
2500 #define VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD       0x0004
2501 /**
2502  * Query supported subpicture formats
2503  * The caller must provide a "format_list" array that can hold at
2504  * least vaMaxNumSubpictureFormats() entries. The flags arrary holds the flag
2505  * for each format to indicate additional capabilities for that format. The actual
2506  * number of formats returned in "format_list" is returned in "num_formats".
2507  *  flags: returned value to indicate addtional capabilities
2508  *         VA_SUBPICTURE_CHROMA_KEYING - supports chroma-keying
2509  *         VA_SUBPICTURE_GLOBAL_ALPHA - supports global alpha
2510  *         VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD - supports unscaled screen relative subpictures for On Screen Display
2511  */
2512
2513 VAStatus vaQuerySubpictureFormats (
2514     VADisplay dpy,
2515     VAImageFormat *format_list, /* out */
2516     unsigned int *flags,        /* out */
2517     unsigned int *num_formats   /* out */
2518 );
2519
2520 /**
2521  * Subpictures are created with an image associated.
2522  */
2523 VAStatus vaCreateSubpicture (
2524     VADisplay dpy,
2525     VAImageID image,
2526     VASubpictureID *subpicture  /* out */
2527 );
2528
2529 /**
2530  * Destroy the subpicture before destroying the image it is assocated to
2531  */
2532 VAStatus vaDestroySubpicture (
2533     VADisplay dpy,
2534     VASubpictureID subpicture
2535 );
2536
2537 /**
2538  * Bind an image to the subpicture. This image will now be associated with
2539  * the subpicture instead of the one at creation.
2540  */
2541 VAStatus vaSetSubpictureImage (
2542     VADisplay dpy,
2543     VASubpictureID subpicture,
2544     VAImageID image
2545 );
2546
2547 /**
2548  * If chromakey is enabled, then the area where the source value falls within
2549  * the chromakey [min, max] range is transparent
2550  * The chromakey component format is the following:
2551  *  For RGB: [0:7] Red [8:15] Blue [16:23] Green
2552  *  For YUV: [0:7] V [8:15] U [16:23] Y
2553  * The chromakey mask can be used to mask out certain components for chromakey
2554  * comparision
2555  */
2556 VAStatus vaSetSubpictureChromakey (
2557     VADisplay dpy,
2558     VASubpictureID subpicture,
2559     unsigned int chromakey_min,
2560     unsigned int chromakey_max,
2561     unsigned int chromakey_mask
2562 );
2563
2564 /**
2565  * Global alpha value is between 0 and 1. A value of 1 means fully opaque and
2566  * a value of 0 means fully transparent. If per-pixel alpha is also specified then
2567  * the overall alpha is per-pixel alpha multiplied by the global alpha
2568  */
2569 VAStatus vaSetSubpictureGlobalAlpha (
2570     VADisplay dpy,
2571     VASubpictureID subpicture,
2572     float global_alpha
2573 );
2574
2575 /**
2576  * vaAssociateSubpicture associates the subpicture with target_surfaces.
2577  * It defines the region mapping between the subpicture and the target
2578  * surfaces through source and destination rectangles (with the same width and height).
2579  * Both will be displayed at the next call to vaPutSurface.  Additional
2580  * associations before the call to vaPutSurface simply overrides the association.
2581  */
2582 VAStatus vaAssociateSubpicture (
2583     VADisplay dpy,
2584     VASubpictureID subpicture,
2585     VASurfaceID *target_surfaces,
2586     int num_surfaces,
2587     short src_x, /* upper left offset in subpicture */
2588     short src_y,
2589     unsigned short src_width,
2590     unsigned short src_height,
2591     short dest_x, /* upper left offset in surface */
2592     short dest_y,
2593     unsigned short dest_width,
2594     unsigned short dest_height,
2595     /*
2596      * whether to enable chroma-keying, global-alpha, or screen relative mode
2597      * see VA_SUBPICTURE_XXX values
2598      */
2599     unsigned int flags
2600 );
2601
2602 /**
2603  * vaDeassociateSubpicture removes the association of the subpicture with target_surfaces.
2604  */
2605 VAStatus vaDeassociateSubpicture (
2606     VADisplay dpy,
2607     VASubpictureID subpicture,
2608     VASurfaceID *target_surfaces,
2609     int num_surfaces
2610 );
2611
2612 typedef struct _VARectangle
2613 {
2614     short x;
2615     short y;
2616     unsigned short width;
2617     unsigned short height;
2618 } VARectangle;
2619
2620 /**
2621  * Display attributes
2622  * Display attributes are used to control things such as contrast, hue, saturation,
2623  * brightness etc. in the rendering process.  The application can query what
2624  * attributes are supported by the driver, and then set the appropriate attributes
2625  * before calling vaPutSurface()
2626  */
2627 /* PowerVR IEP Lite attributes */
2628 typedef enum
2629 {
2630     VADISPLAYATTRIB_BLE_OFF              = 0x00,
2631     VADISPLAYATTRIB_BLE_LOW,
2632     VADISPLAYATTRIB_BLE_MEDIUM,
2633     VADISPLAYATTRIB_BLE_HIGH,
2634     VADISPLAYATTRIB_BLE_NONE,
2635 } VADisplayAttribBLEMode;
2636
2637 /** attribute value for VADisplayAttribRotation   */
2638 #define VA_ROTATION_NONE        0x00000000
2639 #define VA_ROTATION_90          0x00000001
2640 #define VA_ROTATION_180         0x00000002
2641 #define VA_ROTATION_270         0x00000003
2642
2643 /** attribute value for VADisplayAttribOutOfLoopDeblock */
2644 #define VA_OOL_DEBLOCKING_FALSE 0x00000000
2645 #define VA_OOL_DEBLOCKING_TRUE  0x00000001
2646
2647 /** Render mode */
2648 #define VA_RENDER_MODE_UNDEFINED           0
2649 #define VA_RENDER_MODE_LOCAL_OVERLAY       1
2650 #define VA_RENDER_MODE_LOCAL_GPU           2
2651 #define VA_RENDER_MODE_EXTERNAL_OVERLAY    4
2652 #define VA_RENDER_MODE_EXTERNAL_GPU        8
2653
2654 /** Render device */
2655 #define VA_RENDER_DEVICE_UNDEFINED  0
2656 #define VA_RENDER_DEVICE_LOCAL      1
2657 #define VA_RENDER_DEVICE_EXTERNAL   2
2658
2659 /** Currently defined display attribute types */
2660 typedef enum
2661 {
2662     VADisplayAttribBrightness           = 0,
2663     VADisplayAttribContrast             = 1,
2664     VADisplayAttribHue                  = 2,
2665     VADisplayAttribSaturation           = 3,
2666     /* client can specifiy a background color for the target window
2667      * the new feature of video conference,
2668      * the uncovered area of the surface is filled by this color
2669      * also it will blend with the decoded video color
2670      */
2671     VADisplayAttribBackgroundColor      = 4,
2672     /*
2673      * this is a gettable only attribute. For some implementations that use the
2674      * hardware overlay, after PutSurface is called, the surface can not be
2675      * re-used until after the subsequent PutSurface call. If this is the case
2676      * then the value for this attribute will be set to 1 so that the client
2677      * will not attempt to re-use the surface right after returning from a call
2678      * to PutSurface.
2679      *
2680      * Don't use it, use flag VASurfaceDisplaying of vaQuerySurfaceStatus since
2681      * driver may use overlay or GPU alternatively
2682      */
2683     VADisplayAttribDirectSurface       = 5,
2684     VADisplayAttribRotation            = 6,
2685     VADisplayAttribOutofLoopDeblock    = 7,
2686
2687     /* PowerVR IEP Lite specific attributes */
2688     VADisplayAttribBLEBlackMode        = 8,
2689     VADisplayAttribBLEWhiteMode        = 9,
2690     VADisplayAttribBlueStretch         = 10,
2691     VADisplayAttribSkinColorCorrection = 11,
2692     /*
2693      * For type VADisplayAttribCSCMatrix, "value" field is a pointer to the color
2694      * conversion matrix. Each element in the matrix is float-point
2695      */
2696     VADisplayAttribCSCMatrix           = 12,
2697     /* specify the constant color used to blend with video surface
2698      * Cd = Cv*Cc*Ac + Cb *(1 - Ac) C means the constant RGB
2699      *      d: the final color to overwrite into the frame buffer
2700      *      v: decoded video after color conversion,
2701      *      c: video color specified by VADisplayAttribBlendColor
2702      *      b: background color of the drawable
2703      */
2704     VADisplayAttribBlendColor          = 13,
2705     /*
2706      * Indicate driver to skip painting color key or not.
2707      * only applicable if the render is overlay
2708      */
2709     VADisplayAttribOverlayAutoPaintColorKey   = 14,
2710     /*
2711      * customized overlay color key, the format is RGB888
2712      * [23:16] = Red, [15:08] = Green, [07:00] = Blue.
2713      */
2714     VADisplayAttribOverlayColorKey      = 15,
2715     /*
2716      * The hint for the implementation of vaPutSurface
2717      * normally, the driver could use an overlay or GPU to render the surface on the screen
2718      * this flag provides APP the flexibity to switch the render dynamically
2719      */
2720     VADisplayAttribRenderMode           = 16,
2721     /*
2722      * specify if vaPutSurface needs to render into specified monitors
2723      * one example is that one external monitor (e.g. HDMI) is enabled,
2724      * but the window manager is not aware of it, and there is no associated drawable
2725      */
2726     VADisplayAttribRenderDevice        = 17,
2727     /*
2728      * specify vaPutSurface render area if there is no drawable on the monitor
2729      */
2730     VADisplayAttribRenderRect          = 18,
2731 } VADisplayAttribType;
2732
2733 /* flags for VADisplayAttribute */
2734 #define VA_DISPLAY_ATTRIB_NOT_SUPPORTED 0x0000
2735 #define VA_DISPLAY_ATTRIB_GETTABLE      0x0001
2736 #define VA_DISPLAY_ATTRIB_SETTABLE      0x0002
2737
2738 typedef struct _VADisplayAttribute
2739 {
2740     VADisplayAttribType type;
2741     int min_value;
2742     int max_value;
2743     int value;  /* used by the set/get attribute functions */
2744 /* flags can be VA_DISPLAY_ATTRIB_GETTABLE or VA_DISPLAY_ATTRIB_SETTABLE or OR'd together */
2745     unsigned int flags;
2746 } VADisplayAttribute;
2747
2748 /** Get maximum number of display attributs supported by the implementation */
2749 int vaMaxNumDisplayAttributes (
2750     VADisplay dpy
2751 );
2752
2753 /**
2754  * Query display attributes
2755  * The caller must provide a "attr_list" array that can hold at
2756  * least vaMaxNumDisplayAttributes() entries. The actual number of attributes
2757  * returned in "attr_list" is returned in "num_attributes".
2758  */
2759 VAStatus vaQueryDisplayAttributes (
2760     VADisplay dpy,
2761     VADisplayAttribute *attr_list,      /* out */
2762     int *num_attributes                 /* out */
2763 );
2764
2765 /**
2766  * Get display attributes
2767  * This function returns the current attribute values in "attr_list".
2768  * Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
2769  * from vaQueryDisplayAttributes() can have their values retrieved.
2770  */
2771 VAStatus vaGetDisplayAttributes (
2772     VADisplay dpy,
2773     VADisplayAttribute *attr_list,      /* in/out */
2774     int num_attributes
2775 );
2776
2777 /**
2778  * Set display attributes
2779  * Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
2780  * from vaQueryDisplayAttributes() can be set.  If the attribute is not settable or
2781  * the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
2782  */
2783 VAStatus vaSetDisplayAttributes (
2784     VADisplay dpy,
2785     VADisplayAttribute *attr_list,
2786     int num_attributes
2787 );
2788
2789 /****************************
2790  * HEVC data structures
2791  ****************************/
2792 /**
2793  * \brief Description of picture properties of those in DPB surfaces.
2794  *
2795  * If only progressive scan is supported, each surface contains one whole
2796  * frame picture.
2797  * Otherwise, each surface contains two fields of whole picture.
2798  * In this case, two entries of ReferenceFrames[] may share same picture_id
2799  * value.
2800  */
2801 typedef struct _VAPictureHEVC
2802 {
2803     /** \brief reconstructed picture buffer surface index
2804      * invalid when taking value VA_INVALID_SURFACE.
2805      */
2806     VASurfaceID             picture_id;
2807     /** \brief picture order count.
2808      * in HEVC, POCs for top and bottom fields of same picture should
2809      * take different values.
2810      */
2811     int32_t                 pic_order_cnt;
2812     /* described below */
2813     uint32_t                flags;
2814 } VAPictureHEVC;
2815
2816 /* flags in VAPictureHEVC could be OR of the following */
2817 #define VA_PICTURE_HEVC_INVALID                 0x00000001
2818 /** \brief indication of interlace scan picture.
2819  * should take same value for all the pictures in sequence.
2820  */
2821 #define VA_PICTURE_HEVC_FIELD_PIC               0x00000002
2822 /** \brief polarity of the field picture.
2823  * top field takes even lines of buffer surface.
2824  * bottom field takes odd lines of buffer surface.
2825  */
2826 #define VA_PICTURE_HEVC_BOTTOM_FIELD            0x00000004
2827 /** \brief Long term reference picture */
2828 #define VA_PICTURE_HEVC_LONG_TERM_REFERENCE     0x00000008
2829 /**
2830  * VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE, VA_PICTURE_HEVC_RPS_ST_CURR_AFTER
2831  * and VA_PICTURE_HEVC_RPS_LT_CURR of any picture in ReferenceFrames[] should
2832  * be exclusive. No more than one of them can be set for any picture.
2833  * Sum of NumPocStCurrBefore, NumPocStCurrAfter and NumPocLtCurr
2834  * equals NumPocTotalCurr, which should be equal to or smaller than 8.
2835  * Application should provide valid values for both short format and long format.
2836  * The pictures in DPB with any of these three flags turned on are referred by
2837  * the current picture.
2838  */
2839 /** \brief RefPicSetStCurrBefore of HEVC spec variable
2840  * Number of ReferenceFrames[] entries with this bit set equals
2841  * NumPocStCurrBefore.
2842  */
2843 #define VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE      0x00000010
2844 /** \brief RefPicSetStCurrAfter of HEVC spec variable
2845  * Number of ReferenceFrames[] entries with this bit set equals
2846  * NumPocStCurrAfter.
2847  */
2848 #define VA_PICTURE_HEVC_RPS_ST_CURR_AFTER       0x00000020
2849 /** \brief RefPicSetLtCurr of HEVC spec variable
2850  * Number of ReferenceFrames[] entries with this bit set equals
2851  * NumPocLtCurr.
2852  */
2853 #define VA_PICTURE_HEVC_RPS_LT_CURR             0x00000040
2854
2855 #include <va/va_dec_hevc.h>
2856 #include <va/va_dec_jpeg.h>
2857 #include <va/va_dec_vp8.h>
2858 #include <va/va_dec_vp9.h>
2859 #include <va/va_enc_hevc.h>
2860 #include <va/va_enc_h264.h>
2861 #include <va/va_enc_jpeg.h>
2862 #include <va/va_enc_mpeg2.h>
2863 #include <va/va_enc_vp8.h>
2864 #include <va/va_vpp.h>
2865
2866 /**@}*/
2867
2868 #ifdef __cplusplus
2869 }
2870 #endif
2871
2872 #endif /* _VA_H_ */