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