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