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