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