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 #ifndef _VA_H_
  72 #define _VA_H_
  73
  74 #include <va/va_version.h>
  75
  76 #ifdef __cplusplus
  77 extern "C" {
  78 #endif
  79
  80 /*
  81 Overview
  82
  83 The VA API is intended to provide an interface between a video decode/encode/display
  84 application (client) and a hardware accelerator (server), to off-load
  85 video decode/encode/display operations from the host to the hardware accelerator at various
  86 entry-points.
  87
  88 The basic operation steps are:
  89
  90 - Negotiate a mutually acceptable configuration with the server to lock
  91   down profile, entrypoints, and other attributes that will not change on
  92   a frame-by-frame basis.
  93 - Create a decode context which represents a "virtualized" hardware decode
  94   device
  95 - Get and fill decode buffers with picture level, slice level and macroblock
  96   level data (depending on entrypoints)
  97 - Pass the decode buffers to the server to decode the current frame
  98
  99 Initialization & Configuration Management
 100
 101 - Find out supported profiles
 102 - Find out entrypoints for a given profile
 103 - Find out configuration attributes for a given profile/entrypoint pair
 104 - Create a configuration for use by the decoder
 105
 106 */
 107
 108 typedef void* VADisplay;        /* window system dependent */
 109
 110 typedef int VAStatus;   /* Return status type from functions */
 111 /* Values for the return status */
 112 #define VA_STATUS_SUCCESS                       0x00000000
 113 #define VA_STATUS_ERROR_OPERATION_FAILED        0x00000001
 114 #define VA_STATUS_ERROR_ALLOCATION_FAILED       0x00000002
 115 #define VA_STATUS_ERROR_INVALID_DISPLAY         0x00000003
 116 #define VA_STATUS_ERROR_INVALID_CONFIG          0x00000004
 117 #define VA_STATUS_ERROR_INVALID_CONTEXT         0x00000005
 118 #define VA_STATUS_ERROR_INVALID_SURFACE         0x00000006
 119 #define VA_STATUS_ERROR_INVALID_BUFFER          0x00000007
 120 #define VA_STATUS_ERROR_INVALID_IMAGE           0x00000008
 121 #define VA_STATUS_ERROR_INVALID_SUBPICTURE      0x00000009
 122 #define VA_STATUS_ERROR_ATTR_NOT_SUPPORTED      0x0000000a
 123 #define VA_STATUS_ERROR_MAX_NUM_EXCEEDED        0x0000000b
 124 #define VA_STATUS_ERROR_UNSUPPORTED_PROFILE     0x0000000c
 125 #define VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT  0x0000000d
 126 #define VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT   0x0000000e
 127 #define VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE  0x0000000f
 128 #define VA_STATUS_ERROR_SURFACE_BUSY            0x00000010
 129 #define VA_STATUS_ERROR_FLAG_NOT_SUPPORTED      0x00000011
 130 #define VA_STATUS_ERROR_INVALID_PARAMETER       0x00000012
 131 #define VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED 0x00000013
 132 #define VA_STATUS_ERROR_UNIMPLEMENTED           0x00000014
 133 #define VA_STATUS_ERROR_SURFACE_IN_DISPLAYING   0x00000015
 134 #define VA_STATUS_ERROR_INVALID_IMAGE_FORMAT    0x00000016
 135 #define VA_STATUS_ERROR_DECODING_ERROR          0x00000017
 136 #define VA_STATUS_ERROR_ENCODING_ERROR          0x00000018
 137 /**
 138  * \brief An invalid/unsupported value was supplied.
 139  *
 140  * This is a catch-all error code for invalid or unsupported values.
 141  * e.g. value exceeding the valid range, invalid type in the context
 142  * of generic attribute values.
 143  */
 144 #define VA_STATUS_ERROR_INVALID_VALUE           0x00000019
 145 #define VA_STATUS_ERROR_UNKNOWN                 0xFFFFFFFF
 146
 147 /* De-interlacing flags for vaPutSurface() */
 148 #define VA_FRAME_PICTURE        0x00000000
 149 #define VA_TOP_FIELD            0x00000001
 150 #define VA_BOTTOM_FIELD         0x00000002
 151
 152 /*
 153  * Enabled the positioning/cropping/blending feature:
 154  * 1, specify the video playback position in the isurface
 155  * 2, specify the cropping info for video playback
 156  * 3, encoded video will blend with background color
 157  */
 158 #define VA_ENABLE_BLEND         0x00000004 /* video area blend with the constant color */
 159
 160 /*
 161  * Clears the drawable with background color.
 162  * for hardware overlay based implementation this flag
 163  * can be used to turn off the overlay
 164  */
 165 #define VA_CLEAR_DRAWABLE       0x00000008
 166
 167 /* Color space conversion flags for vaPutSurface() */
 168 #define VA_SRC_BT601            0x00000010
 169 #define VA_SRC_BT709            0x00000020
 170 #define VA_SRC_SMPTE_240        0x00000040
 171
 172 /* Scaling flags for vaPutSurface() */
 173 #define VA_FILTER_SCALING_DEFAULT       0x00000000
 174 #define VA_FILTER_SCALING_FAST          0x00000100
 175 #define VA_FILTER_SCALING_HQ            0x00000200
 176 #define VA_FILTER_SCALING_NL_ANAMORPHIC 0x00000300
 177 #define VA_FILTER_SCALING_MASK          0x00000f00
 178
 179 /*
 180  * Returns a short english description of error_status
 181  */
 182 const char *vaErrorStr(VAStatus error_status);
 183
 184 /*
 185  * Initialization:
 186  * A display must be obtained by calling vaGetDisplay() before calling
 187  * vaInitialize() and other functions. This connects the API to the
 188  * native window system.
 189  * For X Windows, native_dpy would be from XOpenDisplay()
 190  */
 191 typedef void* VANativeDisplay;  /* window system dependent */
 192
 193 int vaDisplayIsValid(VADisplay dpy);
 194
 195 /*
 196  * Initialize the library
 197  */
 198 VAStatus vaInitialize (
 199     VADisplay dpy,
 200     int *major_version,  /* out */
 201     int *minor_version   /* out */
 202 );
 203
 204 /*
 205  * After this call, all library internal resources will be cleaned up
 206  */
 207 VAStatus vaTerminate (
 208     VADisplay dpy
 209 );
 210
 211 /*
 212  * vaQueryVendorString returns a pointer to a zero-terminated string
 213  * describing some aspects of the VA implemenation on a specific
 214  * hardware accelerator. The format of the returned string is vendor
 215  * specific and at the discretion of the implementer.
 216  * e.g. for the Intel GMA500 implementation, an example would be:
 217  * "Intel GMA500 - 2.0.0.32L.0005"
 218  */
 219 const char *vaQueryVendorString (
 220     VADisplay dpy
 221 );
 222
 223 typedef int (*VAPrivFunc)();
 224
 225 /*
 226  * Return a function pointer given a function name in the library.
 227  * This allows private interfaces into the library
 228  */
 229 VAPrivFunc vaGetLibFunc (
 230     VADisplay dpy,
 231     const char *func
 232 );
 233
 234 /* Currently defined profiles */
 235 typedef enum
 236 {
 237     VAProfileMPEG2Simple                = 0,
 238     VAProfileMPEG2Main                  = 1,
 239     VAProfileMPEG4Simple                = 2,
 240     VAProfileMPEG4AdvancedSimple        = 3,
 241     VAProfileMPEG4Main                  = 4,
 242     VAProfileH264Baseline               = 5,
 243     VAProfileH264Main                   = 6,
 244     VAProfileH264High                   = 7,
 245     VAProfileVC1Simple                  = 8,
 246     VAProfileVC1Main                    = 9,
 247     VAProfileVC1Advanced                = 10,
 248     VAProfileH263Baseline               = 11,
 249     VAProfileJPEGBaseline               = 12,
 250     VAProfileH264ConstrainedBaseline = 13
 251 } VAProfile;
 252
 253 /*
 254  *  Currently defined entrypoints
 255  */
 256 typedef enum
 257 {
 258     VAEntrypointVLD             = 1,
 259     VAEntrypointIZZ             = 2,
 260     VAEntrypointIDCT            = 3,
 261     VAEntrypointMoComp          = 4,
 262     VAEntrypointDeblocking      = 5,
 263     VAEntrypointEncSlice        = 6,    /* slice level encode */
 264     VAEntrypointEncPicture      = 7     /* pictuer encode, JPEG, etc */
 265 } VAEntrypoint;
 266
 267 /* Currently defined configuration attribute types */
 268 typedef enum
 269 {
 270     VAConfigAttribRTFormat              = 0,
 271     VAConfigAttribSpatialResidual       = 1,
 272     VAConfigAttribSpatialClipping       = 2,
 273     VAConfigAttribIntraResidual         = 3,
 274     VAConfigAttribEncryption            = 4,
 275     VAConfigAttribRateControl           = 5,
 276
 277     /** @name Attributes for encoding */
 278     /**@{*/
 279     /**
 280      * \brief Packed headers mode. Read/write.
 281      *
 282      * This attribute determines what packed headers the driver supports,
 283      * through vaGetConfigAttributes(); and what packed headers the user
 284      * will be providing to the driver, through vaCreateConfig(), if the
 285      * driver supports those.
 286      *
 287      * See \c VA_ENC_PACKED_HEADER_xxx for the list of packed headers.
 288      */
 289     VAConfigAttribEncPackedHeaders      = 6,
 290     /**
 291      * \brief Interlaced mode. Read/write.
 292      *
 293      * This attribute determines what kind of interlaced encoding mode
 294      * the driver supports.
 295      *
 296      * See \c VA_ENC_INTERLACED_xxx for the list of interlaced modes.
 297      */
 298     VAConfigAttribEncInterlaced         = 7,
 299     /**
 300      * \brief Max number of reference frames. Read-only.
 301      *
 302      * This attribute determines the maximum number of reference
 303      * frames supported for encoding.
 304      *
 305      * Note: for H.264 encoding, the value represents the maximum
 306      * number of reference frames for both the reference picture list
 307      * 0 (top 16 bits) and the reference picture list 1 (bottom 16
 308      * bits).
 309      */
 310     VAConfigAttribEncMaxRefFrames       = 8,
 311     /**@}*/
 312 } VAConfigAttribType;
 313
 314 /*
 315  * Configuration attributes
 316  * If there is more than one value for an attribute, a default
 317  * value will be assigned to the attribute if the client does not
 318  * specify the attribute when creating a configuration
 319  */
 320 typedef struct _VAConfigAttrib {
 321     VAConfigAttribType type;
 322     unsigned int value; /* OR'd flags (bits) for this attribute */
 323 } VAConfigAttrib;
 324
 325 /* attribute value for VAConfigAttribRTFormat */
 326 #define VA_RT_FORMAT_YUV420     0x00000001
 327 #define VA_RT_FORMAT_YUV422     0x00000002
 328 #define VA_RT_FORMAT_YUV444     0x00000004
 329 #define VA_RT_FORMAT_PROTECTED  0x80000000
 330
 331 /* attribute value for VAConfigAttribRateControl */
 332 #define VA_RC_NONE      0x00000001
 333 #define VA_RC_CBR       0x00000002
 334 #define VA_RC_VBR       0x00000004
 335 #define VA_RC_VCM       0x00000008 /* video conference mode */
 336
 337 /** @name Attribute values for VAConfigAttribuEncPackedHeaders */
 338 /**@{*/
 339 /** \brief Driver does not support any packed headers mode. */
 340 #define VA_ENC_PACKED_HEADER_NONE       0x00000000
 341 /** \brief Driver supports packed sequence headers. e.g. SPS for H.264. */
 342 #define VA_ENC_PACKED_HEADER_SEQUENCE   0x00000001
 343 /** \brief Driver supports packed picture headers. e.g. PPS for H.264. */
 344 #define VA_ENC_PACKED_HEADER_PICTURE    0x00000002
 345 /** \brief Driver supports packed slice headers. e.g. \c slice_header() for H.264. */
 346 #define VA_ENC_PACKED_HEADER_SLICE      0x00000004
 347 /**@}*/
 348
 349 /** @name Attribute values for VAConfigAttributeEncInterlaced */
 350 /**@{*/
 351 /** \brief Driver does not support interlaced coding. */
 352 #define VA_ENC_INTERLACED_NONE          0x00000000
 353 /** \brief Driver supports interlaced frame coding. */
 354 #define VA_ENC_INTERLACED_FRAME         0x00000001
 355 /** \brief Driver supports interlaced field coding. */
 356 #define VA_ENC_INTERLACED_FIELD         0x00000002
 357 /** \brief Driver supports macroblock adaptive frame field coding. */
 358 #define VA_ENC_INTERLACED_MBAFF         0x00000004
 359 /** \brief Driver support picture adaptive frame field coding. */
 360 #define VA_ENC_INTERLACED_PAFF          0x00000008
 361 /**@}*/
 362
 363 /*
 364  * if an attribute is not applicable for a given
 365  * profile/entrypoint pair, then set the value to the following
 366  */
 367 #define VA_ATTRIB_NOT_SUPPORTED 0x80000000
 368
 369 /* Get maximum number of profiles supported by the implementation */
 370 int vaMaxNumProfiles (
 371     VADisplay dpy
 372 );
 373
 374 /* Get maximum number of entrypoints supported by the implementation */
 375 int vaMaxNumEntrypoints (
 376     VADisplay dpy
 377 );
 378
 379 /* Get maximum number of attributs supported by the implementation */
 380 int vaMaxNumConfigAttributes (
 381     VADisplay dpy
 382 );
 383
 384 /*
 385  * Query supported profiles
 386  * The caller must provide a "profile_list" array that can hold at
 387  * least vaMaxNumProfile() entries. The actual number of profiles
 388  * returned in "profile_list" is returned in "num_profile".
 389  */
 390 VAStatus vaQueryConfigProfiles (
 391     VADisplay dpy,
 392     VAProfile *profile_list,    /* out */
 393     int *num_profiles           /* out */
 394 );
 395
 396 /*
 397  * Query supported entrypoints for a given profile
 398  * The caller must provide an "entrypoint_list" array that can hold at
 399  * least vaMaxNumEntrypoints() entries. The actual number of entrypoints
 400  * returned in "entrypoint_list" is returned in "num_entrypoints".
 401  */
 402 VAStatus vaQueryConfigEntrypoints (
 403     VADisplay dpy,
 404     VAProfile profile,
 405     VAEntrypoint *entrypoint_list,      /* out */
 406     int *num_entrypoints                /* out */
 407 );
 408
 409 /*
 410  * Get attributes for a given profile/entrypoint pair
 411  * The caller must provide an "attrib_list" with all attributes to be
 412  * retrieved.  Upon return, the attributes in "attrib_list" have been
 413  * updated with their value.  Unknown attributes or attributes that are
 414  * not supported for the given profile/entrypoint pair will have their
 415  * value set to VA_ATTRIB_NOT_SUPPORTED
 416  */
 417 VAStatus vaGetConfigAttributes (
 418     VADisplay dpy,
 419     VAProfile profile,
 420     VAEntrypoint entrypoint,
 421     VAConfigAttrib *attrib_list, /* in/out */
 422     int num_attribs
 423 );
 424
 425 /* Generic ID type, can be re-typed for specific implementation */
 426 typedef unsigned int VAGenericID;
 427
 428 typedef VAGenericID VAConfigID;
 429
 430 /*
 431  * Create a configuration for the decode pipeline
 432  * it passes in the attribute list that specifies the attributes it cares
 433  * about, with the rest taking default values.
 434  */
 435 VAStatus vaCreateConfig (
 436     VADisplay dpy,
 437     VAProfile profile,
 438     VAEntrypoint entrypoint,
 439     VAConfigAttrib *attrib_list,
 440     int num_attribs,
 441     VAConfigID *config_id /* out */
 442 );
 443
 444 /*
 445  * Free resources associdated with a given config
 446  */
 447 VAStatus vaDestroyConfig (
 448     VADisplay dpy,
 449     VAConfigID config_id
 450 );
 451
 452 /*
 453  * Query all attributes for a given configuration
 454  * The profile of the configuration is returned in "profile"
 455  * The entrypoint of the configuration is returned in "entrypoint"
 456  * The caller must provide an "attrib_list" array that can hold at least
 457  * vaMaxNumConfigAttributes() entries. The actual number of attributes
 458  * returned in "attrib_list" is returned in "num_attribs"
 459  */
 460 VAStatus vaQueryConfigAttributes (
 461     VADisplay dpy,
 462     VAConfigID config_id,
 463     VAProfile *profile,         /* out */
 464     VAEntrypoint *entrypoint,   /* out */
 465     VAConfigAttrib *attrib_list,/* out */
 466     int *num_attribs            /* out */
 467 );
 468
 469
 470 /*
 471  * Contexts and Surfaces
 472  *
 473  * Context represents a "virtual" video decode pipeline. Surfaces are render
 474  * targets for a given context. The data in the surfaces are not accessible
 475  * to the client and the internal data format of the surface is implementatin
 476  * specific.
 477  *
 478  * Surfaces will be bound to a context when the context is created. Once
 479  * a surface is bound to a given context, it can not be used to create
 480  * another context. The association is removed when the context is destroyed
 481  *
 482  * Both contexts and surfaces are identified by unique IDs and its
 483  * implementation specific internals are kept opaque to the clients
 484  */
 485
 486 typedef VAGenericID VAContextID;
 487
 488 typedef VAGenericID VASurfaceID;
 489
 490 #define VA_INVALID_ID           0xffffffff
 491 #define VA_INVALID_SURFACE      VA_INVALID_ID
 492
 493 /** \brief Generic value types. */
 494 typedef enum  {
 495     VAGenericValueTypeInteger = 1,      /**< 32-bit signed integer. */
 496     VAGenericValueTypeFloat,            /**< 32-bit floating-point value. */
 497     VAGenericValueTypePointer,          /**< Generic pointer type */
 498     VAGenericValueTypeFunc              /**< Pointer to function */
 499 } VAGenericValueType;
 500
 501 /** \brief Generic function type. */
 502 typedef void (*VAGenericFunc)(void);
 503
 504 /** \brief Generic value. */
 505 typedef struct _VAGenericValue {
 506     /** \brief Value type. See #VAGenericValueType. */
 507     VAGenericValueType  type;
 508     /** \brief Value holder. */
 509     union {
 510         /** \brief 32-bit signed integer. */
 511         int             i;
 512         /** \brief 32-bit float. */
 513         float           f;
 514         /** \brief Generic pointer. */
 515         void           *p;
 516         /** \brief Pointer to function. */
 517         VAGenericFunc   fn;
 518     }                   value;
 519 } VAGenericValue;
 520
 521 /*
 522  * vaCreateSurfaces - Create an array of surfaces used for decode and display
 523  *  dpy: display
 524  *  width: surface width
 525  *  height: surface height
 526  *  format: VA_RT_FORMAT_YUV420, VA_RT_FORMAT_YUV422 or VA_RT_FORMAT_YUV444
 527  *  num_surfaces: number of surfaces to be created
 528  *  surfaces: array of surfaces created upon return
 529  */
 530 VAStatus vaCreateSurfaces (
 531     VADisplay dpy,
 532     int width,
 533     int height,
 534     int format,
 535     int num_surfaces,
 536     VASurfaceID *surfaces       /* out */
 537 );
 538
 539
 540 /*
 541  * vaDestroySurfaces - Destroy resources associated with surfaces.
 542  *  Surfaces can only be destroyed after the context associated has been
 543  *  destroyed.
 544  *  dpy: display
 545  *  surfaces: array of surfaces to destroy
 546  *  num_surfaces: number of surfaces in the array to be destroyed.
 547  */
 548 VAStatus vaDestroySurfaces (
 549     VADisplay dpy,
 550     VASurfaceID *surfaces,
 551     int num_surfaces
 552 );
 553
 554 #define VA_PROGRESSIVE 0x1
 555 /*
 556  * vaCreateContext - Create a context
 557  *  dpy: display
 558  *  config_id: configuration for the context
 559  *  picture_width: coded picture width
 560  *  picture_height: coded picture height
 561  *  flag: any combination of the following:
 562  *    VA_PROGRESSIVE (only progressive frame pictures in the sequence when set)
 563  *  render_targets: render targets (surfaces) tied to the context
 564  *  num_render_targets: number of render targets in the above array
 565  *  context: created context id upon return
 566  */
 567 VAStatus vaCreateContext (
 568     VADisplay dpy,
 569     VAConfigID config_id,
 570     int picture_width,
 571     int picture_height,
 572     int flag,
 573     VASurfaceID *render_targets,
 574     int num_render_targets,
 575     VAContextID *context                /* out */
 576 );
 577
 578 /*
 579  * vaDestroyContext - Destroy a context
 580  *  dpy: display
 581  *  context: context to be destroyed
 582  */
 583 VAStatus vaDestroyContext (
 584     VADisplay dpy,
 585     VAContextID context
 586 );
 587
 588 /*
 589  * Buffers
 590  * Buffers are used to pass various types of data from the
 591  * client to the server. The server maintains a data store
 592  * for each buffer created, and the client idenfies a buffer
 593  * through a unique buffer id assigned by the server.
 594  */
 595
 596 typedef VAGenericID VABufferID;
 597
 598 typedef enum
 599 {
 600     VAPictureParameterBufferType        = 0,
 601     VAIQMatrixBufferType                = 1,
 602     VABitPlaneBufferType                = 2,
 603     VASliceGroupMapBufferType           = 3,
 604     VASliceParameterBufferType          = 4,
 605     VASliceDataBufferType               = 5,
 606     VAMacroblockParameterBufferType     = 6,
 607     VAResidualDataBufferType            = 7,
 608     VADeblockingParameterBufferType     = 8,
 609     VAImageBufferType                   = 9,
 610     VAProtectedSliceDataBufferType      = 10,
 611     VAQMatrixBufferType                 = 11,
 612     VAHuffmanTableBufferType            = 12,
 613
 614 /* Following are encode buffer types */
 615     VAEncCodedBufferType                = 21,
 616     VAEncSequenceParameterBufferType    = 22,
 617     VAEncPictureParameterBufferType     = 23,
 618     VAEncSliceParameterBufferType       = 24,
 619     VAEncPackedHeaderParameterBufferType = 25,
 620     VAEncPackedHeaderDataBufferType     = 26,
 621     VAEncMiscParameterBufferType        = 27,
 622     VAEncMacroblockParameterBufferType  = 28,
 623     VABufferTypeMax                     = 0xff
 624 } VABufferType;
 625
 626 typedef enum
 627 {
 628     VAEncMiscParameterTypeFrameRate     = 0,
 629     VAEncMiscParameterTypeRateControl   = 1,
 630     VAEncMiscParameterTypeMaxSliceSize  = 2,
 631     VAEncMiscParameterTypeAIR           = 3,
 632 } VAEncMiscParameterType;
 633
 634 /** \brief Packed header type. */
 635 typedef enum {
 636     VAEncPackedHeaderSequence           = 1, /**< Packed sequence header. */
 637     VAEncPackedHeaderPicture            = 2, /**< Packed picture header. */
 638     VAEncPackedHeaderSlice              = 3, /**< Packed slice header. */
 639 } VAEncPackedHeaderType;
 640
 641 /** \brief Packed header parameter. */
 642 typedef struct _VAEncPackedHeaderParameterBuffer {
 643     /** Type of the packed header buffer. See #VAEncPackedHeaderType. */
 644     VAEncPackedHeaderType       type;
 645     /** \brief Size of the #VAEncPackedHeaderDataBuffer in bits. */
 646     unsigned int                bit_length;
 647     /** \brief Flag: buffer contains start code emulation prevention bytes? */
 648     unsigned char               has_emulation_bytes;
 649 } VAEncPackedHeaderParameterBuffer;
 650
 651 /*
 652  *  For application, e.g. set a new bitrate
 653  *    VABufferID buf_id;
 654  *    VAEncMiscParameterBuffer *misc_param;
 655  *    VAEncMiscParameterRateControl *misc_rate_ctrl;
 656  *
 657  *    vaCreateBuffer(dpy, context, VAEncMiscParameterBufferType,
 658  *              sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterRateControl),
 659  *              1, NULL, &buf_id);
 660  *
 661  *    vaMapBuffer(dpy,buf_id,(void **)&misc_param);
 662  *    misc_param->type = VAEncMiscParameterTypeRateControl;
 663  *    misc_rate_ctrl= (VAEncMiscParameterRateControl *)misc_param->data;
 664  *    misc_rate_ctrl->bits_per_second = 6400000;
 665  *    vaUnmapBuffer(dpy, buf_id);
 666  *    vaRenderPicture(dpy, context, &buf_id, 1);
 667  */
 668 typedef struct _VAEncMiscParameterBuffer
 669 {
 670     VAEncMiscParameterType type;
 671     unsigned int data[0];
 672 } VAEncMiscParameterBuffer;
 673
 674 typedef struct _VAEncMiscParameterRateControl
 675 {
 676     unsigned int bits_per_second; /* this is the maximum bit-rate to be constrained by the rate control implementation */
 677     unsigned int target_percentage; /* this is the bit-rate the rate control is targeting, as a percentage of the maximum bit-rate */
 678                                     /* for example if target_percentage is 95 then the rate control will target a bit-rate that is */
 679                                     /* 95% of the maximum bit-rate */
 680     unsigned int window_size; /* windows size in milliseconds. For example if this is set to 500, then the rate control will guarantee the */
 681                               /* target bit-rate over a 500 ms window */
 682     unsigned int initial_qp;  /* initial QP at I frames */
 683     unsigned int min_qp;
 684 } VAEncMiscParameterRateControl;
 685
 686 typedef struct _VAEncMiscParameterFrameRate
 687 {
 688     unsigned int framerate;
 689 } VAEncMiscParameterFrameRate;
 690
 691 /*
 692  * Allow a maximum slice size to be specified (in bits).
 693  * The encoder will attempt to make sure that individual slices do not exceed this size
 694  * Or to signal applicate if the slice size exceed this size, see "status" of VACodedBufferSegment
 695  */
 696 typedef struct _VAEncMiscParameterMaxSliceSize
 697 {
 698     unsigned int max_slice_size;
 699 } VAEncMiscParameterMaxSliceSize;
 700
 701 typedef struct _VAEncMiscParameterAIR
 702 {
 703     unsigned int air_num_mbs;
 704     unsigned int air_threshold;
 705     unsigned int air_auto; /* if set to 1 then hardware auto-tune the AIR threshold */
 706 } VAEncMiscParameterAIR;
 707
 708
 709 /*
 710  * There will be cases where the bitstream buffer will not have enough room to hold
 711  * the data for the entire slice, and the following flags will be used in the slice
 712  * parameter to signal to the server for the possible cases.
 713  * If a slice parameter buffer and slice data buffer pair is sent to the server with
 714  * the slice data partially in the slice data buffer (BEGIN and MIDDLE cases below),
 715  * then a slice parameter and data buffer needs to be sent again to complete this slice.
 716  */
 717 #define VA_SLICE_DATA_FLAG_ALL          0x00    /* whole slice is in the buffer */
 718 #define VA_SLICE_DATA_FLAG_BEGIN        0x01    /* The beginning of the slice is in the buffer but the end if not */
 719 #define VA_SLICE_DATA_FLAG_MIDDLE       0x02    /* Neither beginning nor end of the slice is in the buffer */
 720 #define VA_SLICE_DATA_FLAG_END          0x04    /* end of the slice is in the buffer */
 721
 722 /* Codec-independent Slice Parameter Buffer base */
 723 typedef struct _VASliceParameterBufferBase
 724 {
 725     unsigned int slice_data_size;       /* number of bytes in the slice data buffer for this slice */
 726     unsigned int slice_data_offset;     /* the offset to the first byte of slice data */
 727     unsigned int slice_data_flag;       /* see VA_SLICE_DATA_FLAG_XXX definitions */
 728 } VASliceParameterBufferBase;
 729
 730
 731 /****************************
 732  * JEPG data structure
 733  ***************************/
 734 typedef struct _VAQMatrixBufferJPEG
 735 {
 736     int load_lum_quantiser_matrix;
 737     int load_chroma_quantiser_matrix;
 738     unsigned char lum_quantiser_matrix[64];
 739     unsigned char chroma_quantiser_matrix[64];
 740 } VAQMatrixBufferJPEG;
 741
 742 typedef struct _VAEncPictureParameterBufferJPEG
 743 {
 744     VASurfaceID reconstructed_picture;
 745     unsigned short picture_width;
 746     unsigned short picture_height;
 747     VABufferID coded_buf;
 748 } VAEncPictureParameterBufferJPEG;
 749
 750 #include <va/va_dec_jpeg.h>
 751
 752 /****************************
 753  * MPEG-2 data structures
 754  ****************************/
 755
 756 /* MPEG-2 Picture Parameter Buffer */
 757 /*
 758  * For each frame or field, and before any slice data, a single
 759  * picture parameter buffer must be send.
 760  */
 761 typedef struct _VAPictureParameterBufferMPEG2
 762 {
 763     unsigned short horizontal_size;
 764     unsigned short vertical_size;
 765     VASurfaceID forward_reference_picture;
 766     VASurfaceID backward_reference_picture;
 767     /* meanings of the following fields are the same as in the standard */
 768     int picture_coding_type;
 769     int f_code; /* pack all four fcode into this */
 770     union {
 771         struct {
 772             unsigned int intra_dc_precision             : 2;
 773             unsigned int picture_structure              : 2;
 774             unsigned int top_field_first                : 1;
 775             unsigned int frame_pred_frame_dct           : 1;
 776             unsigned int concealment_motion_vectors     : 1;
 777             unsigned int q_scale_type                   : 1;
 778             unsigned int intra_vlc_format               : 1;
 779             unsigned int alternate_scan                 : 1;
 780             unsigned int repeat_first_field             : 1;
 781             unsigned int progressive_frame              : 1;
 782             unsigned int is_first_field                 : 1; /* indicate whether the current field
 783                                                               * is the first field for field picture
 784                                                               */
 785         } bits;
 786         unsigned int value;
 787     } picture_coding_extension;
 788 } VAPictureParameterBufferMPEG2;
 789
 790 /* MPEG-2 Inverse Quantization Matrix Buffer */
 791 typedef struct _VAIQMatrixBufferMPEG2
 792 {
 793     int load_intra_quantiser_matrix;
 794     int load_non_intra_quantiser_matrix;
 795     int load_chroma_intra_quantiser_matrix;
 796     int load_chroma_non_intra_quantiser_matrix;
 797     unsigned char intra_quantiser_matrix[64];
 798     unsigned char non_intra_quantiser_matrix[64];
 799     unsigned char chroma_intra_quantiser_matrix[64];
 800     unsigned char chroma_non_intra_quantiser_matrix[64];
 801 } VAIQMatrixBufferMPEG2;
 802
 803 /* MPEG-2 Slice Parameter Buffer */
 804 typedef struct _VASliceParameterBufferMPEG2
 805 {
 806     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
 807     unsigned int slice_data_offset;/* the offset to the first byte of slice data */
 808     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
 809     unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */
 810     unsigned int slice_horizontal_position;
 811     unsigned int slice_vertical_position;
 812     int quantiser_scale_code;
 813     int intra_slice_flag;
 814 } VASliceParameterBufferMPEG2;
 815
 816 /* MPEG-2 Macroblock Parameter Buffer */
 817 typedef struct _VAMacroblockParameterBufferMPEG2
 818 {
 819     unsigned short macroblock_address;
 820     /*
 821      * macroblock_address (in raster scan order)
 822      * top-left: 0
 823      * bottom-right: picture-height-in-mb*picture-width-in-mb - 1
 824      */
 825     unsigned char macroblock_type;  /* see definition below */
 826     union {
 827         struct {
 828             unsigned int frame_motion_type              : 2;
 829             unsigned int field_motion_type              : 2;
 830             unsigned int dct_type                       : 1;
 831         } bits;
 832         unsigned int value;
 833     } macroblock_modes;
 834     unsigned char motion_vertical_field_select;
 835     /*
 836      * motion_vertical_field_select:
 837      * see section 6.3.17.2 in the spec
 838      * only the lower 4 bits are used
 839      * bit 0: first vector forward
 840      * bit 1: first vector backward
 841      * bit 2: second vector forward
 842      * bit 3: second vector backward
 843      */
 844     short PMV[2][2][2]; /* see Table 7-7 in the spec */
 845     unsigned short coded_block_pattern;
 846     /*
 847      * The bitplanes for coded_block_pattern are described
 848      * in Figure 6.10-12 in the spec
 849      */
 850
 851     /* Number of skipped macroblocks after this macroblock */
 852     unsigned short num_skipped_macroblocks;
 853 } VAMacroblockParameterBufferMPEG2;
 854
 855 /*
 856  * OR'd flags for macroblock_type (section 6.3.17.1 in the spec)
 857  */
 858 #define VA_MB_TYPE_MOTION_FORWARD       0x02
 859 #define VA_MB_TYPE_MOTION_BACKWARD      0x04
 860 #define VA_MB_TYPE_MOTION_PATTERN       0x08
 861 #define VA_MB_TYPE_MOTION_INTRA         0x10
 862
 863 /*
 864  * MPEG-2 Residual Data Buffer
 865  * For each macroblock, there wil be 64 shorts (16-bit) in the
 866  * residual data buffer
 867  */
 868
 869 /****************************
 870  * MPEG-4 Part 2 data structures
 871  ****************************/
 872
 873 /* MPEG-4 Picture Parameter Buffer */
 874 /*
 875  * For each frame or field, and before any slice data, a single
 876  * picture parameter buffer must be send.
 877  */
 878 typedef struct _VAPictureParameterBufferMPEG4
 879 {
 880     unsigned short vop_width;
 881     unsigned short vop_height;
 882     VASurfaceID forward_reference_picture;
 883     VASurfaceID backward_reference_picture;
 884     union {
 885         struct {
 886             unsigned int short_video_header             : 1;
 887             unsigned int chroma_format                  : 2;
 888             unsigned int interlaced                     : 1;
 889             unsigned int obmc_disable                   : 1;
 890             unsigned int sprite_enable                  : 2;
 891             unsigned int sprite_warping_accuracy        : 2;
 892             unsigned int quant_type                     : 1;
 893             unsigned int quarter_sample                 : 1;
 894             unsigned int data_partitioned               : 1;
 895             unsigned int reversible_vlc                 : 1;
 896             unsigned int resync_marker_disable          : 1;
 897         } bits;
 898         unsigned int value;
 899     } vol_fields;
 900     unsigned char no_of_sprite_warping_points;
 901     short sprite_trajectory_du[3];
 902     short sprite_trajectory_dv[3];
 903     unsigned char quant_precision;
 904     union {
 905         struct {
 906             unsigned int vop_coding_type                : 2;
 907             unsigned int backward_reference_vop_coding_type     : 2;
 908             unsigned int vop_rounding_type              : 1;
 909             unsigned int intra_dc_vlc_thr               : 3;
 910             unsigned int top_field_first                : 1;
 911             unsigned int alternate_vertical_scan_flag   : 1;
 912         } bits;
 913         unsigned int value;
 914     } vop_fields;
 915     unsigned char vop_fcode_forward;
 916     unsigned char vop_fcode_backward;
 917     unsigned short vop_time_increment_resolution;
 918     /* short header related */
 919     unsigned char num_gobs_in_vop;
 920     unsigned char num_macroblocks_in_gob;
 921     /* for direct mode prediction */
 922     short TRB;
 923     short TRD;
 924 } VAPictureParameterBufferMPEG4;
 925
 926 /* MPEG-4 Inverse Quantization Matrix Buffer */
 927 typedef struct _VAIQMatrixBufferMPEG4
 928 {
 929     int load_intra_quant_mat;
 930     int load_non_intra_quant_mat;
 931     unsigned char intra_quant_mat[64];
 932     unsigned char non_intra_quant_mat[64];
 933 } VAIQMatrixBufferMPEG4;
 934
 935 /* MPEG-4 Slice Parameter Buffer */
 936 typedef struct _VASliceParameterBufferMPEG4
 937 {
 938     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
 939     unsigned int slice_data_offset;/* the offset to the first byte of slice data */
 940     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
 941     unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */
 942     unsigned int macroblock_number;
 943     int quant_scale;
 944 } VASliceParameterBufferMPEG4;
 945
 946 /*
 947  VC-1 data structures
 948 */
 949
 950 typedef enum   /* see 7.1.1.32 */
 951 {
 952     VAMvMode1Mv                        = 0,
 953     VAMvMode1MvHalfPel                 = 1,
 954     VAMvMode1MvHalfPelBilinear         = 2,
 955     VAMvModeMixedMv                    = 3,
 956     VAMvModeIntensityCompensation      = 4
 957 } VAMvModeVC1;
 958
 959 /* VC-1 Picture Parameter Buffer */
 960 /*
 961  * For each picture, and before any slice data, a picture parameter
 962  * buffer must be send. Multiple picture parameter buffers may be
 963  * sent for a single picture. In that case picture parameters will
 964  * apply to all slice data that follow it until a new picture
 965  * parameter buffer is sent.
 966  *
 967  * Notes:
 968  *   pic_quantizer_type should be set to the applicable quantizer
 969  *   type as defined by QUANTIZER (J.1.19) and either
 970  *   PQUANTIZER (7.1.1.8) or PQINDEX (7.1.1.6)
 971  */
 972 typedef struct _VAPictureParameterBufferVC1
 973 {
 974     VASurfaceID forward_reference_picture;
 975     VASurfaceID backward_reference_picture;
 976     /* if out-of-loop post-processing is done on the render
 977        target, then we need to keep the in-loop decoded
 978        picture as a reference picture */
 979     VASurfaceID inloop_decoded_picture;
 980
 981     /* sequence layer for AP or meta data for SP and MP */
 982     union {
 983         struct {
 984             unsigned int pulldown       : 1; /* SEQUENCE_LAYER::PULLDOWN */
 985             unsigned int interlace      : 1; /* SEQUENCE_LAYER::INTERLACE */
 986             unsigned int tfcntrflag     : 1; /* SEQUENCE_LAYER::TFCNTRFLAG */
 987             unsigned int finterpflag    : 1; /* SEQUENCE_LAYER::FINTERPFLAG */
 988             unsigned int psf            : 1; /* SEQUENCE_LAYER::PSF */
 989             unsigned int multires       : 1; /* METADATA::MULTIRES */
 990             unsigned int overlap        : 1; /* METADATA::OVERLAP */
 991             unsigned int syncmarker     : 1; /* METADATA::SYNCMARKER */
 992             unsigned int rangered       : 1; /* METADATA::RANGERED */
 993             unsigned int max_b_frames   : 3; /* METADATA::MAXBFRAMES */
 994             unsigned int profile        : 2; /* SEQUENCE_LAYER::PROFILE or The MSB of METADATA::PROFILE */
 995         } bits;
 996         unsigned int value;
 997     } sequence_fields;
 998
 999     unsigned short coded_width;         /* ENTRY_POINT_LAYER::CODED_WIDTH */
1000     unsigned short coded_height;        /* ENTRY_POINT_LAYER::CODED_HEIGHT */
1001     union {
1002         struct {
1003             unsigned int broken_link    : 1; /* ENTRY_POINT_LAYER::BROKEN_LINK */
1004             unsigned int closed_entry   : 1; /* ENTRY_POINT_LAYER::CLOSED_ENTRY */
1005             unsigned int panscan_flag   : 1; /* ENTRY_POINT_LAYER::PANSCAN_FLAG */
1006             unsigned int loopfilter     : 1; /* ENTRY_POINT_LAYER::LOOPFILTER */
1007         } bits;
1008         unsigned int value;
1009     } entrypoint_fields;
1010     unsigned char conditional_overlap_flag; /* ENTRY_POINT_LAYER::CONDOVER */
1011     unsigned char fast_uvmc_flag;       /* ENTRY_POINT_LAYER::FASTUVMC */
1012     union {
1013         struct {
1014             unsigned int luma_flag      : 1; /* ENTRY_POINT_LAYER::RANGE_MAPY_FLAG */
1015             unsigned int luma           : 3; /* ENTRY_POINT_LAYER::RANGE_MAPY */
1016             unsigned int chroma_flag    : 1; /* ENTRY_POINT_LAYER::RANGE_MAPUV_FLAG */
1017             unsigned int chroma         : 3; /* ENTRY_POINT_LAYER::RANGE_MAPUV */
1018         } bits;
1019         unsigned int value;
1020     } range_mapping_fields;
1021
1022     unsigned char b_picture_fraction;   /* PICTURE_LAYER::BFRACTION */
1023     unsigned char cbp_table;            /* PICTURE_LAYER::CBPTAB/ICBPTAB */
1024     unsigned char mb_mode_table;        /* PICTURE_LAYER::MBMODETAB */
1025     unsigned char range_reduction_frame;/* PICTURE_LAYER::RANGEREDFRM */
1026     unsigned char rounding_control;     /* PICTURE_LAYER::RNDCTRL */
1027     unsigned char post_processing;      /* PICTURE_LAYER::POSTPROC */
1028     unsigned char picture_resolution_index;     /* PICTURE_LAYER::RESPIC */
1029     unsigned char luma_scale;           /* PICTURE_LAYER::LUMSCALE */
1030     unsigned char luma_shift;           /* PICTURE_LAYER::LUMSHIFT */
1031     union {
1032         struct {
1033             unsigned int picture_type           : 3; /* PICTURE_LAYER::PTYPE */
1034             unsigned int frame_coding_mode      : 3; /* PICTURE_LAYER::FCM */
1035             unsigned int top_field_first        : 1; /* PICTURE_LAYER::TFF */
1036             unsigned int is_first_field         : 1; /* set to 1 if it is the first field */
1037             unsigned int intensity_compensation : 1; /* PICTURE_LAYER::INTCOMP */
1038         } bits;
1039         unsigned int value;
1040     } picture_fields;
1041     union {
1042         struct {
1043             unsigned int mv_type_mb     : 1;    /* PICTURE::MVTYPEMB */
1044             unsigned int direct_mb      : 1;    /* PICTURE::DIRECTMB */
1045             unsigned int skip_mb        : 1;    /* PICTURE::SKIPMB */
1046             unsigned int field_tx       : 1;    /* PICTURE::FIELDTX */
1047             unsigned int forward_mb     : 1;    /* PICTURE::FORWARDMB */
1048             unsigned int ac_pred        : 1;    /* PICTURE::ACPRED */
1049             unsigned int overflags      : 1;    /* PICTURE::OVERFLAGS */
1050         } flags;
1051         unsigned int value;
1052     } raw_coding;
1053     union {
1054         struct {
1055             unsigned int bp_mv_type_mb   : 1;    /* PICTURE::MVTYPEMB */
1056             unsigned int bp_direct_mb    : 1;    /* PICTURE::DIRECTMB */
1057             unsigned int bp_skip_mb      : 1;    /* PICTURE::SKIPMB */
1058             unsigned int bp_field_tx     : 1;    /* PICTURE::FIELDTX */
1059             unsigned int bp_forward_mb   : 1;    /* PICTURE::FORWARDMB */
1060             unsigned int bp_ac_pred      : 1;    /* PICTURE::ACPRED */
1061             unsigned int bp_overflags    : 1;    /* PICTURE::OVERFLAGS */
1062         } flags;
1063         unsigned int value;
1064     } bitplane_present; /* signal what bitplane is being passed via the bitplane buffer */
1065     union {
1066         struct {
1067             unsigned int reference_distance_flag : 1;/* PICTURE_LAYER::REFDIST_FLAG */
1068             unsigned int reference_distance     : 5;/* PICTURE_LAYER::REFDIST */
1069             unsigned int num_reference_pictures: 1;/* PICTURE_LAYER::NUMREF */
1070             unsigned int reference_field_pic_indicator  : 1;/* PICTURE_LAYER::REFFIELD */
1071         } bits;
1072         unsigned int value;
1073     } reference_fields;
1074     union {
1075         struct {
1076             unsigned int mv_mode                : 3; /* PICTURE_LAYER::MVMODE */
1077             unsigned int mv_mode2               : 3; /* PICTURE_LAYER::MVMODE2 */
1078             unsigned int mv_table               : 3; /* PICTURE_LAYER::MVTAB/IMVTAB */
1079             unsigned int two_mv_block_pattern_table: 2; /* PICTURE_LAYER::2MVBPTAB */
1080             unsigned int four_mv_switch         : 1; /* PICTURE_LAYER::4MVSWITCH */
1081             unsigned int four_mv_block_pattern_table : 2; /* PICTURE_LAYER::4MVBPTAB */
1082             unsigned int extended_mv_flag       : 1; /* ENTRY_POINT_LAYER::EXTENDED_MV */
1083             unsigned int extended_mv_range      : 2; /* PICTURE_LAYER::MVRANGE */
1084             unsigned int extended_dmv_flag      : 1; /* ENTRY_POINT_LAYER::EXTENDED_DMV */
1085             unsigned int extended_dmv_range     : 2; /* PICTURE_LAYER::DMVRANGE */
1086         } bits;
1087         unsigned int value;
1088     } mv_fields;
1089     union {
1090         struct {
1091             unsigned int dquant : 2;    /* ENTRY_POINT_LAYER::DQUANT */
1092             unsigned int quantizer     : 2;     /* ENTRY_POINT_LAYER::QUANTIZER */
1093             unsigned int half_qp        : 1;    /* PICTURE_LAYER::HALFQP */
1094             unsigned int pic_quantizer_scale : 5;/* PICTURE_LAYER::PQUANT */
1095             unsigned int pic_quantizer_type : 1;/* PICTURE_LAYER::PQUANTIZER */
1096             unsigned int dq_frame       : 1;    /* VOPDQUANT::DQUANTFRM */
1097             unsigned int dq_profile     : 2;    /* VOPDQUANT::DQPROFILE */
1098             unsigned int dq_sb_edge     : 2;    /* VOPDQUANT::DQSBEDGE */
1099             unsigned int dq_db_edge     : 2;    /* VOPDQUANT::DQDBEDGE */
1100             unsigned int dq_binary_level : 1;   /* VOPDQUANT::DQBILEVEL */
1101             unsigned int alt_pic_quantizer : 5;/* VOPDQUANT::ALTPQUANT */
1102         } bits;
1103         unsigned int value;
1104     } pic_quantizer_fields;
1105     union {
1106         struct {
1107             unsigned int variable_sized_transform_flag  : 1;/* ENTRY_POINT_LAYER::VSTRANSFORM */
1108             unsigned int mb_level_transform_type_flag   : 1;/* PICTURE_LAYER::TTMBF */
1109             unsigned int frame_level_transform_type     : 2;/* PICTURE_LAYER::TTFRM */
1110             unsigned int transform_ac_codingset_idx1    : 2;/* PICTURE_LAYER::TRANSACFRM */
1111             unsigned int transform_ac_codingset_idx2    : 2;/* PICTURE_LAYER::TRANSACFRM2 */
1112             unsigned int intra_transform_dc_table       : 1;/* PICTURE_LAYER::TRANSDCTAB */
1113         } bits;
1114         unsigned int value;
1115     } transform_fields;
1116 } VAPictureParameterBufferVC1;
1117
1118 /* VC-1 Bitplane Buffer
1119 There will be at most three bitplanes coded in any picture header. To send
1120 the bitplane data more efficiently, each byte is divided in two nibbles, with
1121 each nibble carrying three bitplanes for one macroblock.  The following table
1122 shows the bitplane data arrangement within each nibble based on the picture
1123 type.
1124
1125 Picture Type    Bit3            Bit2            Bit1            Bit0
1126 I or BI                         OVERFLAGS       ACPRED          FIELDTX
1127 P                               MYTYPEMB        SKIPMB          DIRECTMB
1128 B                               FORWARDMB       SKIPMB          DIRECTMB
1129
1130 Within each byte, the lower nibble is for the first MB and the upper nibble is
1131 for the second MB.  E.g. the lower nibble of the first byte in the bitplane
1132 buffer is for Macroblock #1 and the upper nibble of the first byte is for
1133 Macroblock #2 in the first row.
1134 */
1135
1136 /* VC-1 Slice Parameter Buffer */
1137 typedef struct _VASliceParameterBufferVC1
1138 {
1139     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
1140     unsigned int slice_data_offset;/* the offset to the first byte of slice data */
1141     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
1142     unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */
1143     unsigned int slice_vertical_position;
1144 } VASliceParameterBufferVC1;
1145
1146 /* VC-1 Slice Data Buffer */
1147 /*
1148 This is simplely a buffer containing raw bit-stream bytes
1149 */
1150
1151 /****************************
1152  * H.264/AVC data structures
1153  ****************************/
1154
1155 typedef struct _VAPictureH264
1156 {
1157     VASurfaceID picture_id;
1158     unsigned int frame_idx;
1159     unsigned int flags;
1160     signed int TopFieldOrderCnt;
1161     signed int BottomFieldOrderCnt;
1162 } VAPictureH264;
1163 /* flags in VAPictureH264 could be OR of the following */
1164 #define VA_PICTURE_H264_INVALID                 0x00000001
1165 #define VA_PICTURE_H264_TOP_FIELD               0x00000002
1166 #define VA_PICTURE_H264_BOTTOM_FIELD            0x00000004
1167 #define VA_PICTURE_H264_SHORT_TERM_REFERENCE    0x00000008
1168 #define VA_PICTURE_H264_LONG_TERM_REFERENCE     0x00000010
1169
1170 /* H.264 Picture Parameter Buffer */
1171 /*
1172  * For each picture, and before any slice data, a single
1173  * picture parameter buffer must be send.
1174  */
1175 typedef struct _VAPictureParameterBufferH264
1176 {
1177     VAPictureH264 CurrPic;
1178     VAPictureH264 ReferenceFrames[16];  /* in DPB */
1179     unsigned short picture_width_in_mbs_minus1;
1180     unsigned short picture_height_in_mbs_minus1;
1181     unsigned char bit_depth_luma_minus8;
1182     unsigned char bit_depth_chroma_minus8;
1183     unsigned char num_ref_frames;
1184     union {
1185         struct {
1186             unsigned int chroma_format_idc                      : 2;
1187             unsigned int residual_colour_transform_flag         : 1;
1188             unsigned int gaps_in_frame_num_value_allowed_flag   : 1;
1189             unsigned int frame_mbs_only_flag                    : 1;
1190             unsigned int mb_adaptive_frame_field_flag           : 1;
1191             unsigned int direct_8x8_inference_flag              : 1;
1192             unsigned int MinLumaBiPredSize8x8                   : 1; /* see A.3.3.2 */
1193             unsigned int log2_max_frame_num_minus4              : 4;
1194             unsigned int pic_order_cnt_type                     : 2;
1195             unsigned int log2_max_pic_order_cnt_lsb_minus4      : 4;
1196             unsigned int delta_pic_order_always_zero_flag       : 1;
1197         } bits;
1198         unsigned int value;
1199     } seq_fields;
1200     unsigned char num_slice_groups_minus1;
1201     unsigned char slice_group_map_type;
1202     unsigned short slice_group_change_rate_minus1;
1203     signed char pic_init_qp_minus26;
1204     signed char pic_init_qs_minus26;
1205     signed char chroma_qp_index_offset;
1206     signed char second_chroma_qp_index_offset;
1207     union {
1208         struct {
1209             unsigned int entropy_coding_mode_flag       : 1;
1210             unsigned int weighted_pred_flag             : 1;
1211             unsigned int weighted_bipred_idc            : 2;
1212             unsigned int transform_8x8_mode_flag        : 1;
1213             unsigned int field_pic_flag                 : 1;
1214             unsigned int constrained_intra_pred_flag    : 1;
1215             unsigned int pic_order_present_flag                 : 1;
1216             unsigned int deblocking_filter_control_present_flag : 1;
1217             unsigned int redundant_pic_cnt_present_flag         : 1;
1218             unsigned int reference_pic_flag                     : 1; /* nal_ref_idc != 0 */
1219         } bits;
1220         unsigned int value;
1221     } pic_fields;
1222     unsigned short frame_num;
1223 } VAPictureParameterBufferH264;
1224
1225 /* H.264 Inverse Quantization Matrix Buffer */
1226 typedef struct _VAIQMatrixBufferH264
1227 {
1228     unsigned char ScalingList4x4[6][16];
1229     unsigned char ScalingList8x8[2][64];
1230 } VAIQMatrixBufferH264;
1231
1232 /*
1233  * H.264 Slice Group Map Buffer
1234  * When VAPictureParameterBufferH264::num_slice_group_minus1 is not equal to 0,
1235  * A slice group map buffer should be sent for each picture if required. The buffer
1236  * is sent only when there is a change in the mapping values.
1237  * The slice group map buffer map "map units" to slice groups as specified in
1238  * section 8.2.2 of the H.264 spec. The buffer will contain one byte for each macroblock
1239  * in raster scan order
1240  */
1241
1242 /* H.264 Slice Parameter Buffer */
1243 typedef struct _VASliceParameterBufferH264
1244 {
1245     unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
1246     /** \brief Byte offset to the NAL Header Unit for this slice. */
1247     unsigned int slice_data_offset;
1248     unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
1249     /**
1250      * \brief Bit offset from NAL Header Unit to the begining of slice_data().
1251      *
1252      * This bit offset is relative to and includes the NAL unit byte
1253      * and represents the number of bits parsed in the slice_header()
1254      * after the removal of any emulation prevention bytes in
1255      * there. However, the slice data buffer passed to the hardware is
1256      * the original bitstream, thus including any emulation prevention
1257      * bytes.
1258      */
1259     unsigned short slice_data_bit_offset;
1260     unsigned short first_mb_in_slice;
1261     unsigned char slice_type;
1262     unsigned char direct_spatial_mv_pred_flag;
1263     unsigned char num_ref_idx_l0_active_minus1;
1264     unsigned char num_ref_idx_l1_active_minus1;
1265     unsigned char cabac_init_idc;
1266     char slice_qp_delta;
1267     unsigned char disable_deblocking_filter_idc;
1268     char slice_alpha_c0_offset_div2;
1269     char slice_beta_offset_div2;
1270     VAPictureH264 RefPicList0[32];      /* See 8.2.4.2 */
1271     VAPictureH264 RefPicList1[32];      /* See 8.2.4.2 */
1272     unsigned char luma_log2_weight_denom;
1273     unsigned char chroma_log2_weight_denom;
1274     unsigned char luma_weight_l0_flag;
1275     short luma_weight_l0[32];
1276     short luma_offset_l0[32];
1277     unsigned char chroma_weight_l0_flag;
1278     short chroma_weight_l0[32][2];
1279     short chroma_offset_l0[32][2];
1280     unsigned char luma_weight_l1_flag;
1281     short luma_weight_l1[32];
1282     short luma_offset_l1[32];
1283     unsigned char chroma_weight_l1_flag;
1284     short chroma_weight_l1[32][2];
1285     short chroma_offset_l1[32][2];
1286 } VASliceParameterBufferH264;
1287
1288 /****************************
1289  * Common encode data structures
1290  ****************************/
1291 typedef enum
1292 {
1293     VAEncPictureTypeIntra               = 0,
1294     VAEncPictureTypePredictive          = 1,
1295     VAEncPictureTypeBidirectional       = 2,
1296 } VAEncPictureType;
1297
1298 /* Encode Slice Parameter Buffer */
1299 typedef struct _VAEncSliceParameterBuffer
1300 {
1301     unsigned int start_row_number;      /* starting MB row number for this slice */
1302     unsigned int slice_height;  /* slice height measured in MB */
1303     union {
1304         struct {
1305             unsigned int is_intra       : 1;
1306             unsigned int disable_deblocking_filter_idc : 2;
1307             unsigned int uses_long_term_ref             :1;
1308             unsigned int is_long_term_ref               :1;
1309         } bits;
1310         unsigned int value;
1311     } slice_flags;
1312 } VAEncSliceParameterBuffer;
1313
1314 /****************************
1315  * H.264 specific encode data structures
1316  ****************************/
1317
1318 typedef struct _VAEncSequenceParameterBufferH264Baseline
1319 {
1320     unsigned char seq_parameter_set_id;
1321     unsigned char level_idc;
1322     unsigned int intra_period;
1323     unsigned int intra_idr_period;
1324     unsigned int max_num_ref_frames;
1325     unsigned int picture_width_in_mbs;
1326     unsigned int picture_height_in_mbs;
1327     unsigned int bits_per_second;
1328     unsigned int frame_rate;
1329     unsigned int initial_qp;
1330     unsigned int min_qp;
1331     unsigned int basic_unit_size;
1332     unsigned char vui_flag;
1333 } VAEncSequenceParameterBufferH264Baseline;
1334
1335 #define H264_LAST_PICTURE_EOSEQ     0x01 /* the last picture in the sequence */
1336 #define H264_LAST_PICTURE_EOSTREAM  0x02 /* the last picture in the stream */
1337 typedef struct _VAEncPictureParameterBufferH264Baseline
1338 {
1339     VASurfaceID reference_picture;
1340     VASurfaceID reconstructed_picture;
1341     VABufferID coded_buf;
1342     unsigned short picture_width;
1343     unsigned short picture_height;
1344     unsigned char last_picture;
1345 } VAEncPictureParameterBufferH264Baseline;
1346
1347 /****************************
1348  * H.263 specific encode data structures
1349  ****************************/
1350
1351 typedef struct _VAEncSequenceParameterBufferH263
1352 {
1353     unsigned int intra_period;
1354     unsigned int bits_per_second;
1355     unsigned int frame_rate;
1356     unsigned int initial_qp;
1357     unsigned int min_qp;
1358 } VAEncSequenceParameterBufferH263;
1359
1360 typedef struct _VAEncPictureParameterBufferH263
1361 {
1362     VASurfaceID reference_picture;
1363     VASurfaceID reconstructed_picture;
1364     VABufferID coded_buf;
1365     unsigned short picture_width;
1366     unsigned short picture_height;
1367     VAEncPictureType picture_type;
1368 } VAEncPictureParameterBufferH263;
1369
1370 /****************************
1371  * MPEG-4 specific encode data structures
1372  ****************************/
1373
1374 typedef struct _VAEncSequenceParameterBufferMPEG4
1375 {
1376     unsigned char profile_and_level_indication;
1377     unsigned int intra_period;
1378     unsigned int video_object_layer_width;
1379     unsigned int video_object_layer_height;
1380     unsigned int vop_time_increment_resolution;
1381     unsigned int fixed_vop_rate;
1382     unsigned int fixed_vop_time_increment;
1383     unsigned int bits_per_second;
1384     unsigned int frame_rate;
1385     unsigned int initial_qp;
1386     unsigned int min_qp;
1387 } VAEncSequenceParameterBufferMPEG4;
1388
1389 typedef struct _VAEncPictureParameterBufferMPEG4
1390 {
1391     VASurfaceID reference_picture;
1392     VASurfaceID reconstructed_picture;
1393     VABufferID coded_buf;
1394     unsigned short picture_width;
1395     unsigned short picture_height;
1396     unsigned int modulo_time_base; /* number of 1s */
1397     unsigned int vop_time_increment;
1398     VAEncPictureType picture_type;
1399 } VAEncPictureParameterBufferMPEG4;
1400
1401
1402
1403 /* Buffer functions */
1404
1405 /*
1406  * Creates a buffer for "num_elements" elements of "size" bytes and
1407  * initalize with "data".
1408  * if "data" is null, then the contents of the buffer data store
1409  * are undefined.
1410  * Basically there are two ways to get buffer data to the server side. One is
1411  * to call vaCreateBuffer() with a non-null "data", which results the data being
1412  * copied to the data store on the server side.  A different method that
1413  * eliminates this copy is to pass null as "data" when calling vaCreateBuffer(),
1414  * and then use vaMapBuffer() to map the data store from the server side to the
1415  * client address space for access.
1416  *  Note: image buffers are created by the library, not the client. Please see
1417  *        vaCreateImage on how image buffers are managed.
1418  */
1419 VAStatus vaCreateBuffer (
1420     VADisplay dpy,
1421     VAContextID context,
1422     VABufferType type,  /* in */
1423     unsigned int size,  /* in */
1424     unsigned int num_elements, /* in */
1425     void *data,         /* in */
1426     VABufferID *buf_id  /* out */
1427 );
1428
1429 /*
1430  * Convey to the server how many valid elements are in the buffer.
1431  * e.g. if multiple slice parameters are being held in a single buffer,
1432  * this will communicate to the server the number of slice parameters
1433  * that are valid in the buffer.
1434  */
1435 VAStatus vaBufferSetNumElements (
1436     VADisplay dpy,
1437     VABufferID buf_id,  /* in */
1438     unsigned int num_elements /* in */
1439 );
1440
1441
1442 /*
1443  * device independent data structure for codedbuffer
1444  */
1445
1446 /*
1447  * FICTURE_AVE_QP(bit7-0): The average Qp value used during this frame
1448  * LARGE_SLICE(bit8):At least one slice in the current frame was large
1449  *              enough for the encoder to attempt to limit its size.
1450  * SLICE_OVERFLOW(bit9): At least one slice in the current frame has
1451  *              exceeded the maximum slice size specified.
1452  * BITRATE_OVERFLOW(bit10): The peak bitrate was exceeded for this frame.
1453  * BITRATE_HIGH(bit11): The frame size got within the safety margin of the maximum size (VCM only)
1454  * AIR_MB_OVER_THRESHOLD: the number of MBs adapted to Intra MB
1455  */
1456 #define VA_CODED_BUF_STATUS_PICTURE_AVE_QP_MASK         0xff
1457 #define VA_CODED_BUF_STATUS_LARGE_SLICE_MASK            0x100
1458 #define VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK         0x200
1459 #define VA_CODED_BUF_STATUS_BITRATE_OVERFLOW            0x400
1460 #define VA_CODED_BUF_STATUS_BITRATE_HIGH                0x800
1461 #define VA_CODED_BUF_STATUS_AIR_MB_OVER_THRESHOLD       0xff0000
1462
1463 /*
1464  * device independent data structure for codedbuffer
1465  */
1466 typedef  struct _VACodedBufferSegment  {
1467     unsigned int size;/* size of the data buffer in the coded buffer segment, in bytes */
1468     unsigned int bit_offset; /* bit offset into the data buffer where valid bitstream data begins */
1469     unsigned int status; /* status set by the driver on the coded buffer*/
1470     unsigned int reserved; /* for future use */
1471     void *buf; /* pointer to the beginning of the data buffer in the coded buffer segment */
1472     void *next; /* pointer to the next VACodedBufferSegment */
1473 } VACodedBufferSegment;
1474
1475 /*
1476  * Map data store of the buffer into the client's address space
1477  * vaCreateBuffer() needs to be called with "data" set to NULL before
1478  * calling vaMapBuffer()
1479  *
1480  * if buffer type is VAEncCodedBufferType, pbuf points to link-list of
1481  * VACodedBufferSegment, and the list is terminated if "next" is NULL
1482  */
1483 VAStatus vaMapBuffer (
1484     VADisplay dpy,
1485     VABufferID buf_id,  /* in */
1486     void **pbuf         /* out */
1487 );
1488
1489 /*
1490  * After client making changes to a mapped data store, it needs to
1491  * "Unmap" it to let the server know that the data is ready to be
1492  * consumed by the server
1493  */
1494 VAStatus vaUnmapBuffer (
1495     VADisplay dpy,
1496     VABufferID buf_id   /* in */
1497 );
1498
1499 /*
1500  * After this call, the buffer is deleted and this buffer_id is no longer valid
1501  * Only call this if the buffer is not going to be passed to vaRenderBuffer
1502  */
1503 VAStatus vaDestroyBuffer (
1504     VADisplay dpy,
1505     VABufferID buffer_id
1506 );
1507
1508 /*
1509 Render (Decode) Pictures
1510
1511 A picture represents either a frame or a field.
1512
1513 The Begin/Render/End sequence sends the decode buffers to the server
1514 */
1515
1516 /*
1517  * Get ready to decode a picture to a target surface
1518  */
1519 VAStatus vaBeginPicture (
1520     VADisplay dpy,
1521     VAContextID context,
1522     VASurfaceID render_target
1523 );
1524
1525 /*
1526  * Send decode buffers to the server.
1527  * Buffers are automatically destroyed afterwards
1528  */
1529 VAStatus vaRenderPicture (
1530     VADisplay dpy,
1531     VAContextID context,
1532     VABufferID *buffers,
1533     int num_buffers
1534 );
1535
1536 /*
1537  * Make the end of rendering for a picture.
1538  * The server should start processing all pending operations for this
1539  * surface. This call is non-blocking. The client can start another
1540  * Begin/Render/End sequence on a different render target.
1541  */
1542 VAStatus vaEndPicture (
1543     VADisplay dpy,
1544     VAContextID context
1545 );
1546
1547 /*
1548
1549 Synchronization
1550
1551 */
1552
1553 /*
1554  * This function blocks until all pending operations on the render target
1555  * have been completed.  Upon return it is safe to use the render target for a
1556  * different picture.
1557  */
1558 VAStatus vaSyncSurface (
1559     VADisplay dpy,
1560     VASurfaceID render_target
1561 );
1562
1563 typedef enum
1564 {
1565     VASurfaceRendering  = 1, /* Rendering in progress */
1566     VASurfaceDisplaying = 2, /* Displaying in progress (not safe to render into it) */
1567                              /* this status is useful if surface is used as the source */
1568                              /* of an overlay */
1569     VASurfaceReady      = 4, /* not being rendered or displayed */
1570     VASurfaceSkipped    = 8  /* Indicate a skipped frame during encode */
1571 } VASurfaceStatus;
1572
1573 /*
1574  * Find out any pending ops on the render target
1575  */
1576 VAStatus vaQuerySurfaceStatus (
1577     VADisplay dpy,
1578     VASurfaceID render_target,
1579     VASurfaceStatus *status     /* out */
1580 );
1581
1582 typedef enum
1583 {
1584     VADecodeSliceMissing            = 0,
1585     VADecodeMBError                 = 1,
1586 } VADecodeErrorType;
1587
1588 /*
1589  * Client calls vaQuerySurfaceError with VA_STATUS_ERROR_DECODING_ERROR, server side returns
1590  * an array of structure VASurfaceDecodeMBErrors, and the array is terminated by setting status=-1
1591 */
1592 typedef struct _VASurfaceDecodeMBErrors
1593 {
1594     int status; /* 1 if hardware has returned detailed info below, -1 means this record is invalid */
1595     unsigned int start_mb; /* start mb address with errors */
1596     unsigned int end_mb;  /* end mb address with errors */
1597     VADecodeErrorType decode_error_type;
1598 } VASurfaceDecodeMBErrors;
1599
1600 /*
1601  * After the application gets VA_STATUS_ERROR_DECODING_ERROR after calling vaSyncSurface(),
1602  * it can call vaQuerySurfaceError to find out further details on the particular error.
1603  * VA_STATUS_ERROR_DECODING_ERROR should be passed in as "error_status",
1604  * upon the return, error_info will point to an array of _VASurfaceDecodeMBErrors structure,
1605  * which is allocated and filled by libVA with detailed information on the missing or error macroblocks.
1606  * The array is terminated if "status==-1" is detected.
1607  */
1608 VAStatus vaQuerySurfaceError(
1609     VADisplay dpy,
1610     VASurfaceID surface,
1611     VAStatus error_status,
1612     void **error_info
1613 );
1614
1615 /*
1616  * Images and Subpictures
1617  * VAImage is used to either get the surface data to client memory, or
1618  * to copy image data in client memory to a surface.
1619  * Both images, subpictures and surfaces follow the same 2D coordinate system where origin
1620  * is at the upper left corner with positive X to the right and positive Y down
1621  */
1622 #define VA_FOURCC(ch0, ch1, ch2, ch3) \
1623     ((unsigned long)(unsigned char) (ch0) | ((unsigned long)(unsigned char) (ch1) << 8) | \
1624     ((unsigned long)(unsigned char) (ch2) << 16) | ((unsigned long)(unsigned char) (ch3) << 24 ))
1625
1626 /* a few common FourCCs */
1627 #define VA_FOURCC_NV12          0x3231564E
1628 #define VA_FOURCC_AI44          0x34344149
1629 #define VA_FOURCC_RGBA          0x41424752
1630 #define VA_FOURCC_BGRA          0x41524742
1631 #define VA_FOURCC_UYVY          0x59565955
1632 #define VA_FOURCC_YUY2          0x32595559
1633 #define VA_FOURCC_AYUV          0x56555941
1634 #define VA_FOURCC_NV11          0x3131564e
1635 #define VA_FOURCC_YV12          0x32315659
1636 #define VA_FOURCC_P208          0x38303250
1637 #define VA_FOURCC_IYUV          0x56555949
1638
1639 /* byte order */
1640 #define VA_LSB_FIRST            1
1641 #define VA_MSB_FIRST            2
1642
1643 typedef struct _VAImageFormat
1644 {
1645     unsigned int        fourcc;
1646     unsigned int        byte_order; /* VA_LSB_FIRST, VA_MSB_FIRST */
1647     unsigned int        bits_per_pixel;
1648     /* for RGB formats */
1649     unsigned int        depth; /* significant bits per pixel */
1650     unsigned int        red_mask;
1651     unsigned int        green_mask;
1652     unsigned int        blue_mask;
1653     unsigned int        alpha_mask;
1654 } VAImageFormat;
1655
1656 typedef VAGenericID VAImageID;
1657
1658 typedef struct _VAImage
1659 {
1660     VAImageID           image_id; /* uniquely identify this image */
1661     VAImageFormat       format;
1662     VABufferID          buf;    /* image data buffer */
1663     /*
1664      * Image data will be stored in a buffer of type VAImageBufferType to facilitate
1665      * data store on the server side for optimal performance. The buffer will be
1666      * created by the CreateImage function, and proper storage allocated based on the image
1667      * size and format. This buffer is managed by the library implementation, and
1668      * accessed by the client through the buffer Map/Unmap functions.
1669      */
1670     unsigned short      width;
1671     unsigned short      height;
1672     unsigned int        data_size;
1673     unsigned int        num_planes;     /* can not be greater than 3 */
1674     /*
1675      * An array indicating the scanline pitch in bytes for each plane.
1676      * Each plane may have a different pitch. Maximum 3 planes for planar formats
1677      */
1678     unsigned int        pitches[3];
1679     /*
1680      * An array indicating the byte offset from the beginning of the image data
1681      * to the start of each plane.
1682      */
1683     unsigned int        offsets[3];
1684
1685     /* The following fields are only needed for paletted formats */
1686     int num_palette_entries;   /* set to zero for non-palette images */
1687     /*
1688      * Each component is one byte and entry_bytes indicates the number of components in
1689      * each entry (eg. 3 for YUV palette entries). set to zero for non-palette images
1690      */
1691     int entry_bytes;
1692     /*
1693      * An array of ascii characters describing the order of the components within the bytes.
1694      * Only entry_bytes characters of the string are used.
1695      */
1696     char component_order[4];
1697 } VAImage;
1698
1699 /* Get maximum number of image formats supported by the implementation */
1700 int vaMaxNumImageFormats (
1701     VADisplay dpy
1702 );
1703
1704 /*
1705  * Query supported image formats
1706  * The caller must provide a "format_list" array that can hold at
1707  * least vaMaxNumImageFormats() entries. The actual number of formats
1708  * returned in "format_list" is returned in "num_formats".
1709  */
1710 VAStatus vaQueryImageFormats (
1711     VADisplay dpy,
1712     VAImageFormat *format_list, /* out */
1713     int *num_formats            /* out */
1714 );
1715
1716 /*
1717  * Create a VAImage structure
1718  * The width and height fields returned in the VAImage structure may get
1719  * enlarged for some YUV formats. Upon return from this function,
1720  * image->buf has been created and proper storage allocated by the library.
1721  * The client can access the image through the Map/Unmap calls.
1722  */
1723 VAStatus vaCreateImage (
1724     VADisplay dpy,
1725     VAImageFormat *format,
1726     int width,
1727     int height,
1728     VAImage *image      /* out */
1729 );
1730
1731 /*
1732  * Should call DestroyImage before destroying the surface it is bound to
1733  */
1734 VAStatus vaDestroyImage (
1735     VADisplay dpy,
1736     VAImageID image
1737 );
1738
1739 VAStatus vaSetImagePalette (
1740     VADisplay dpy,
1741     VAImageID image,
1742     /*
1743      * pointer to an array holding the palette data.  The size of the array is
1744      * num_palette_entries * entry_bytes in size.  The order of the components
1745      * in the palette is described by the component_order in VAImage struct
1746      */
1747     unsigned char *palette
1748 );
1749
1750 /*
1751  * Retrive surface data into a VAImage
1752  * Image must be in a format supported by the implementation
1753  */
1754 VAStatus vaGetImage (
1755     VADisplay dpy,
1756     VASurfaceID surface,
1757     int x,      /* coordinates of the upper left source pixel */
1758     int y,
1759     unsigned int width, /* width and height of the region */
1760     unsigned int height,
1761     VAImageID image
1762 );
1763
1764 /*
1765  * Copy data from a VAImage to a surface
1766  * Image must be in a format supported by the implementation
1767  * Returns a VA_STATUS_ERROR_SURFACE_BUSY if the surface
1768  * shouldn't be rendered into when this is called
1769  */
1770 VAStatus vaPutImage (
1771     VADisplay dpy,
1772     VASurfaceID surface,
1773     VAImageID image,
1774     int src_x,
1775     int src_y,
1776     unsigned int src_width,
1777     unsigned int src_height,
1778     int dest_x,
1779     int dest_y,
1780     unsigned int dest_width,
1781     unsigned int dest_height
1782 );
1783
1784 /*
1785  * Derive an VAImage from an existing surface.
1786  * This interface will derive a VAImage and corresponding image buffer from
1787  * an existing VA Surface. The image buffer can then be mapped/unmapped for
1788  * direct CPU access. This operation is only possible on implementations with
1789  * direct rendering capabilities and internal surface formats that can be
1790  * represented with a VAImage. When the operation is not possible this interface
1791  * will return VA_STATUS_ERROR_OPERATION_FAILED. Clients should then fall back
1792  * to using vaCreateImage + vaPutImage to accomplish the same task in an
1793  * indirect manner.
1794  *
1795  * Implementations should only return success when the resulting image buffer
1796  * would be useable with vaMap/Unmap.
1797  *
1798  * When directly accessing a surface special care must be taken to insure
1799  * proper synchronization with the graphics hardware. Clients should call
1800  * vaQuerySurfaceStatus to insure that a surface is not the target of concurrent
1801  * rendering or currently being displayed by an overlay.
1802  *
1803  * Additionally nothing about the contents of a surface should be assumed
1804  * following a vaPutSurface. Implementations are free to modify the surface for
1805  * scaling or subpicture blending within a call to vaPutImage.
1806  *
1807  * Calls to vaPutImage or vaGetImage using the same surface from which the image
1808  * has been derived will return VA_STATUS_ERROR_SURFACE_BUSY. vaPutImage or
1809  * vaGetImage with other surfaces is supported.
1810  *
1811  * An image created with vaDeriveImage should be freed with vaDestroyImage. The
1812  * image and image buffer structures will be destroyed; however, the underlying
1813  * surface will remain unchanged until freed with vaDestroySurfaces.
1814  */
1815 VAStatus vaDeriveImage (
1816     VADisplay dpy,
1817     VASurfaceID surface,
1818     VAImage *image      /* out */
1819 );
1820
1821 /*
1822  * Subpictures
1823  * Subpicture is a special type of image that can be blended
1824  * with a surface during vaPutSurface(). Subpicture can be used to render
1825  * DVD sub-titles or closed captioning text etc.
1826  */
1827
1828 typedef VAGenericID VASubpictureID;
1829
1830 /* Get maximum number of subpicture formats supported by the implementation */
1831 int vaMaxNumSubpictureFormats (
1832     VADisplay dpy
1833 );
1834
1835 /* flags for subpictures */
1836 #define VA_SUBPICTURE_CHROMA_KEYING                     0x0001
1837 #define VA_SUBPICTURE_GLOBAL_ALPHA                      0x0002
1838 #define VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD       0x0004
1839 /*
1840  * Query supported subpicture formats
1841  * The caller must provide a "format_list" array that can hold at
1842  * least vaMaxNumSubpictureFormats() entries. The flags arrary holds the flag
1843  * for each format to indicate additional capabilities for that format. The actual
1844  * number of formats returned in "format_list" is returned in "num_formats".
1845  *  flags: returned value to indicate addtional capabilities
1846  *         VA_SUBPICTURE_CHROMA_KEYING - supports chroma-keying
1847  *         VA_SUBPICTURE_GLOBAL_ALPHA - supports global alpha
1848  *         VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD - supports unscaled screen relative subpictures for On Screen Display
1849  */
1850
1851 VAStatus vaQuerySubpictureFormats (
1852     VADisplay dpy,
1853     VAImageFormat *format_list, /* out */
1854     unsigned int *flags,        /* out */
1855     unsigned int *num_formats   /* out */
1856 );
1857
1858 /*
1859  * Subpictures are created with an image associated.
1860  */
1861 VAStatus vaCreateSubpicture (
1862     VADisplay dpy,
1863     VAImageID image,
1864     VASubpictureID *subpicture  /* out */
1865 );
1866
1867 /*
1868  * Destroy the subpicture before destroying the image it is assocated to
1869  */
1870 VAStatus vaDestroySubpicture (
1871     VADisplay dpy,
1872     VASubpictureID subpicture
1873 );
1874
1875 /*
1876  * Bind an image to the subpicture. This image will now be associated with
1877  * the subpicture instead of the one at creation.
1878  */
1879 VAStatus vaSetSubpictureImage (
1880     VADisplay dpy,
1881     VASubpictureID subpicture,
1882     VAImageID image
1883 );
1884
1885 /*
1886  * If chromakey is enabled, then the area where the source value falls within
1887  * the chromakey [min, max] range is transparent
1888  * The chromakey component format is the following:
1889  *  For RGB: [0:7] Red [8:15] Blue [16:23] Green
1890  *  For YUV: [0:7] V [8:15] U [16:23] Y
1891  * The chromakey mask can be used to mask out certain components for chromakey
1892  * comparision
1893  */
1894 VAStatus vaSetSubpictureChromakey (
1895     VADisplay dpy,
1896     VASubpictureID subpicture,
1897     unsigned int chromakey_min,
1898     unsigned int chromakey_max,
1899     unsigned int chromakey_mask
1900 );
1901
1902 /*
1903  * Global alpha value is between 0 and 1. A value of 1 means fully opaque and
1904  * a value of 0 means fully transparent. If per-pixel alpha is also specified then
1905  * the overall alpha is per-pixel alpha multiplied by the global alpha
1906  */
1907 VAStatus vaSetSubpictureGlobalAlpha (
1908     VADisplay dpy,
1909     VASubpictureID subpicture,
1910     float global_alpha
1911 );
1912
1913 /*
1914  * vaAssociateSubpicture associates the subpicture with target_surfaces.
1915  * It defines the region mapping between the subpicture and the target
1916  * surfaces through source and destination rectangles (with the same width and height).
1917  * Both will be displayed at the next call to vaPutSurface.  Additional
1918  * associations before the call to vaPutSurface simply overrides the association.
1919  */
1920 VAStatus vaAssociateSubpicture (
1921     VADisplay dpy,
1922     VASubpictureID subpicture,
1923     VASurfaceID *target_surfaces,
1924     int num_surfaces,
1925     short src_x, /* upper left offset in subpicture */
1926     short src_y,
1927     unsigned short src_width,
1928     unsigned short src_height,
1929     short dest_x, /* upper left offset in surface */
1930     short dest_y,
1931     unsigned short dest_width,
1932     unsigned short dest_height,
1933     /*
1934      * whether to enable chroma-keying, global-alpha, or screen relative mode
1935      * see VA_SUBPICTURE_XXX values
1936      */
1937     unsigned int flags
1938 );
1939
1940 /*
1941  * vaDeassociateSubpicture removes the association of the subpicture with target_surfaces.
1942  */
1943 VAStatus vaDeassociateSubpicture (
1944     VADisplay dpy,
1945     VASubpictureID subpicture,
1946     VASurfaceID *target_surfaces,
1947     int num_surfaces
1948 );
1949
1950 typedef struct _VARectangle
1951 {
1952     short x;
1953     short y;
1954     unsigned short width;
1955     unsigned short height;
1956 } VARectangle;
1957
1958 /*
1959  * Display attributes
1960  * Display attributes are used to control things such as contrast, hue, saturation,
1961  * brightness etc. in the rendering process.  The application can query what
1962  * attributes are supported by the driver, and then set the appropriate attributes
1963  * before calling vaPutSurface()
1964  */
1965 /* PowerVR IEP Lite attributes */
1966 typedef enum
1967 {
1968     VADISPLAYATTRIB_BLE_OFF              = 0x00,
1969     VADISPLAYATTRIB_BLE_LOW,
1970     VADISPLAYATTRIB_BLE_MEDIUM,
1971     VADISPLAYATTRIB_BLE_HIGH,
1972     VADISPLAYATTRIB_BLE_NONE,
1973 } VADisplayAttribBLEMode;
1974
1975 /* attribute value for VADisplayAttribRotation   */
1976 #define VA_ROTATION_NONE        0x00000000
1977 #define VA_ROTATION_90          0x00000001
1978 #define VA_ROTATION_180         0x00000002
1979 #define VA_ROTATION_270         0x00000003
1980
1981 /* attribute value for VADisplayAttribOutOfLoopDeblock */
1982 #define VA_OOL_DEBLOCKING_FALSE 0x00000000
1983 #define VA_OOL_DEBLOCKING_TRUE  0x00000001
1984
1985 /* Render mode */
1986 #define VA_RENDER_MODE_UNDEFINED           0
1987 #define VA_RENDER_MODE_LOCAL_OVERLAY       1
1988 #define VA_RENDER_MODE_LOCAL_GPU           2
1989 #define VA_RENDER_MODE_EXTERNAL_OVERLAY    4
1990 #define VA_RENDER_MODE_EXTERNAL_GPU        8
1991
1992 /* Render device */
1993 #define VA_RENDER_DEVICE_UNDEFINED  0
1994 #define VA_RENDER_DEVICE_LOCAL      1
1995 #define VA_RENDER_DEVICE_EXTERNAL   2
1996
1997 /* Currently defined display attribute types */
1998 typedef enum
1999 {
2000     VADisplayAttribBrightness           = 0,
2001     VADisplayAttribContrast             = 1,
2002     VADisplayAttribHue                  = 2,
2003     VADisplayAttribSaturation           = 3,
2004     /* client can specifiy a background color for the target window
2005      * the new feature of video conference,
2006      * the uncovered area of the surface is filled by this color
2007      * also it will blend with the decoded video color
2008      */
2009     VADisplayAttribBackgroundColor      = 4,
2010     /*
2011      * this is a gettable only attribute. For some implementations that use the
2012      * hardware overlay, after PutSurface is called, the surface can not be
2013      * re-used until after the subsequent PutSurface call. If this is the case
2014      * then the value for this attribute will be set to 1 so that the client
2015      * will not attempt to re-use the surface right after returning from a call
2016      * to PutSurface.
2017      *
2018      * Don't use it, use flag VASurfaceDisplaying of vaQuerySurfaceStatus since
2019      * driver may use overlay or GPU alternatively
2020      */
2021     VADisplayAttribDirectSurface       = 5,
2022     VADisplayAttribRotation            = 6,
2023     VADisplayAttribOutofLoopDeblock    = 7,
2024
2025     /* PowerVR IEP Lite specific attributes */
2026     VADisplayAttribBLEBlackMode        = 8,
2027     VADisplayAttribBLEWhiteMode        = 9,
2028     VADisplayAttribBlueStretch         = 10,
2029     VADisplayAttribSkinColorCorrection = 11,
2030     /*
2031      * For type VADisplayAttribCSCMatrix, "value" field is a pointer to the color
2032      * conversion matrix. Each element in the matrix is float-point
2033      */
2034     VADisplayAttribCSCMatrix           = 12,
2035     /* specify the constant color used to blend with video surface
2036      * Cd = Cv*Cc*Ac + Cb *(1 - Ac) C means the constant RGB
2037      *      d: the final color to overwrite into the frame buffer
2038      *      v: decoded video after color conversion,
2039      *      c: video color specified by VADisplayAttribBlendColor
2040      *      b: background color of the drawable
2041      */
2042     VADisplayAttribBlendColor          = 13,
2043     /*
2044      * Indicate driver to skip painting color key or not.
2045      * only applicable if the render is overlay
2046      */
2047     VADisplayAttribOverlayAutoPaintColorKey   = 14,
2048     /*
2049      * customized overlay color key, the format is RGB888
2050      * [23:16] = Red, [15:08] = Green, [07:00] = Blue.
2051      */
2052     VADisplayAttribOverlayColorKey      = 15,
2053     /*
2054      * The hint for the implementation of vaPutSurface
2055      * normally, the driver could use an overlay or GPU to render the surface on the screen
2056      * this flag provides APP the flexibity to switch the render dynamically
2057      */
2058     VADisplayAttribRenderMode           = 16,
2059     /*
2060      * specify if vaPutSurface needs to render into specified monitors
2061      * one example is that one external monitor (e.g. HDMI) is enabled,
2062      * but the window manager is not aware of it, and there is no associated drawable
2063      */
2064     VADisplayAttribRenderDevice        = 17,
2065     /*
2066      * specify vaPutSurface render area if there is no drawable on the monitor
2067      */
2068     VADisplayAttribRenderRect          = 18,
2069 } VADisplayAttribType;
2070
2071 /* flags for VADisplayAttribute */
2072 #define VA_DISPLAY_ATTRIB_NOT_SUPPORTED 0x0000
2073 #define VA_DISPLAY_ATTRIB_GETTABLE      0x0001
2074 #define VA_DISPLAY_ATTRIB_SETTABLE      0x0002
2075
2076 typedef struct _VADisplayAttribute
2077 {
2078     VADisplayAttribType type;
2079     int min_value;
2080     int max_value;
2081     int value;  /* used by the set/get attribute functions */
2082 /* flags can be VA_DISPLAY_ATTRIB_GETTABLE or VA_DISPLAY_ATTRIB_SETTABLE or OR'd together */
2083     unsigned int flags;
2084 } VADisplayAttribute;
2085
2086 /* Get maximum number of display attributs supported by the implementation */
2087 int vaMaxNumDisplayAttributes (
2088     VADisplay dpy
2089 );
2090
2091 /*
2092  * Query display attributes
2093  * The caller must provide a "attr_list" array that can hold at
2094  * least vaMaxNumDisplayAttributes() entries. The actual number of attributes
2095  * returned in "attr_list" is returned in "num_attributes".
2096  */
2097 VAStatus vaQueryDisplayAttributes (
2098     VADisplay dpy,
2099     VADisplayAttribute *attr_list,      /* out */
2100     int *num_attributes                 /* out */
2101 );
2102
2103 /*
2104  * Get display attributes
2105  * This function returns the current attribute values in "attr_list".
2106  * Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
2107  * from vaQueryDisplayAttributes() can have their values retrieved.
2108  */
2109 VAStatus vaGetDisplayAttributes (
2110     VADisplay dpy,
2111     VADisplayAttribute *attr_list,      /* in/out */
2112     int num_attributes
2113 );
2114
2115 /*
2116  * Set display attributes
2117  * Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
2118  * from vaQueryDisplayAttributes() can be set.  If the attribute is not settable or
2119  * the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
2120  */
2121 VAStatus vaSetDisplayAttributes (
2122     VADisplay dpy,
2123     VADisplayAttribute *attr_list,
2124     int num_attributes
2125 );
2126
2127 #ifdef __cplusplus
2128 }
2129 #endif
2130
2131 #endif /* _VA_H_ */