recipes/qt4/files/0001-wsegl2-support.patch

   1 diff -Nurp qt-everywhere-opensource-src-4.6.3-orig//src/3rdparty/powervr/wsegl2/pvr2d.h qt-everywhere-opensource-src-4.6.3/src/3rdparty/powervr/wsegl2/pvr2d.h
   2 --- qt-everywhere-opensource-src-4.6.3-orig//src/3rdparty/powervr/wsegl2/pvr2d.h        1970-01-01 00:00:00.000000000 +0000
   3 +++ qt-everywhere-opensource-src-4.6.3/src/3rdparty/powervr/wsegl2/pvr2d.h      2011-05-16 22:51:43.158564336 +0000
   4 @@ -0,0 +1,669 @@
   5 +/**********************************************************************
   6 +*
   7 +* Copyright(c) Imagination Technologies Ltd.
   8 +*
   9 +* The contents of this file are subject to the MIT license as set out below.
  10 +*
  11 +* Permission is hereby granted, free of charge, to any person obtaining a copy
  12 +* of this software and associated documentation files (the "Software"),
  13 +* to deal in the Software without restriction, including without limitation
  14 +* the rights to use, copy, modify, merge, publish, distribute, sublicense,
  15 +* and/or sell copies of the Software, and to permit persons to whom the
  16 +* Software is furnished to do so, subject to the following conditions:
  17 +*
  18 +* The above copyright notice and this permission notice shall be included
  19 +* in all copies or substantial portions of the Software.
  20 +*
  21 +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22 +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23 +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  24 +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  25 +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
  26 +* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
  27 +* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 +*
  29 +* This License is also included in this distribution in the file called
  30 +* "COPYING".
  31 +*
  32 +******************************************************************************/
  33 +
  34 +
  35 +
  36 +/******************************************************************************
  37 +Modifications :-
  38 +$Log: pvr2d.h $
  39 +
  40 + --- Revision Logs Removed ---
  41 +******************************************************************************/
  42 +
  43 +#ifndef _PVR2D_H_
  44 +#define _PVR2D_H_
  45 +
  46 +#ifdef __cplusplus
  47 +extern "C" {
  48 +#endif
  49 +
  50 +/* PVR2D Platform-specific definitions */
  51 +#if defined (__linux__)
  52 +#define PVR2D_EXPORT __attribute__((visibility("default")))
  53 +#define PVR2D_IMPORT
  54 +#else
  55 +#define PVR2D_EXPORT
  56 +#define PVR2D_IMPORT
  57 +#endif
  58 +
  59 +/* PVR2D header revision */
  60 +#define PVR2D_REV_MAJOR                3
  61 +#define PVR2D_REV_MINOR                5
  62 +
  63 +/* Basic types */
  64 +typedef enum
  65 +{
  66 +       PVR2D_FALSE = 0,
  67 +       PVR2D_TRUE
  68 +} PVR2D_BOOL;
  69 +
  70 +typedef void* PVR2D_HANDLE;
  71 +
  72 +typedef char             PVR2D_CHAR,   *PVR2D_PCHAR;
  73 +typedef unsigned char    PVR2D_UCHAR,  *PVR2D_PUCHAR;
  74 +typedef int              PVR2D_INT,            *PVR2D_PINT;
  75 +typedef unsigned int     PVR2D_UINT,   *PVR2D_PUINT;
  76 +typedef long             PVR2D_LONG,   *PVR2D_PLONG;
  77 +typedef unsigned long    PVR2D_ULONG,  *PVR2D_PULONG;
  78 +
  79 +typedef void             PVR2D_VOID,   *PVR2D_PVOID;
  80 +
  81 +
  82 +/* error codes */
  83 +typedef enum
  84 +{
  85 +       PVR2D_OK = 0,
  86 +       PVR2DERROR_INVALID_PARAMETER = -1,
  87 +       PVR2DERROR_DEVICE_UNAVAILABLE = -2,
  88 +       PVR2DERROR_INVALID_CONTEXT = -3,
  89 +       PVR2DERROR_MEMORY_UNAVAILABLE = -4,
  90 +       PVR2DERROR_DEVICE_NOT_PRESENT = -5,
  91 +       PVR2DERROR_IOCTL_ERROR = -6,
  92 +       PVR2DERROR_GENERIC_ERROR = -7,
  93 +       PVR2DERROR_BLT_NOTCOMPLETE = -8,
  94 +       PVR2DERROR_HW_FEATURE_NOT_SUPPORTED = -9,
  95 +       PVR2DERROR_NOT_YET_IMPLEMENTED = -10,
  96 +       PVR2DERROR_MAPPING_FAILED = -11
  97 +}PVR2DERROR;
  98 +
  99 +/* 32 bit PVR2D pixel format specifier */
 100 +typedef unsigned long PVR2DFORMAT;
 101 +
 102 +/* Standard PVR2D pixel formats */
 103 +#define        PVR2D_1BPP                                              0x00UL // 1bpp mask surface or palletized 1 bit source with 2x32 bit CLUT
 104 +#define        PVR2D_RGB565                                    0x01UL // Common rgb 565 format
 105 +#define        PVR2D_ARGB4444                                  0x02UL // Common argb 4444 format
 106 +#define        PVR2D_RGB888                                    0x03UL // Common rgb 888 format (not supported)
 107 +#define        PVR2D_ARGB8888                                  0x04UL // Common argb 8888 format
 108 +#define        PVR2D_ARGB1555                                  0x05UL // Common argb 1555 format
 109 +#define        PVR2D_ALPHA8                                    0x06UL // Alpha-only 8 bit per pixel (used with a constant fill colour)
 110 +#define        PVR2D_ALPHA4                                    0x07UL // Alpha-only 4 bits per pixel (used with a constant fill colour)
 111 +#define        PVR2D_PAL2                                              0x08UL // Palletized 2 bit format (requires   4x32 bit CLUT)
 112 +#define        PVR2D_PAL4                                              0x09UL // Palletized 4 bit format (requires  16x32 bit CLUT)
 113 +#define        PVR2D_PAL8                                              0x0AUL // Palletized 8 bit format (requires 256x32 bit CLUT)
 114 +#define PVR2D_U8                                               0x10UL // monochrome unsigned 8 bit
 115 +#define PVR2D_U88                                              0x11UL // monochrome unsigned 16 bit
 116 +#define PVR2D_S8                                               0x12UL // signed 8 bit
 117 +#define PVR2D_YUV422_YUYV                              0x13UL // YUV 422 low-high byte order Y0UY1V
 118 +#define PVR2D_YUV422_UYVY                              0x14UL // YUV 422 low-high byte order UY0VY1
 119 +#define PVR2D_YUV422_YVYU                              0x15UL // YUV 422 low-high byte order Y0VY1U
 120 +#define PVR2D_YUV422_VYUY                              0x16UL // YUV 422 low-high byte order VY0UY1
 121 +#define PVR2D_YUV420_2PLANE                            0x17UL // YUV420 2 Plane
 122 +#define PVR2D_YUV420_3PLANE                            0x18UL // YUV420 3 Plane
 123 +#define PVR2D_2101010ARGB                              0x19UL // 32 bit 2 10 10 10
 124 +#define PVR2D_888RSGSBS                                        0x1AUL
 125 +#define PVR2D_16BPP_RAW                                        0x1BUL // 16 bit raw (no format conversion)
 126 +#define PVR2D_32BPP_RAW                                        0x1CUL // 32 bit raw
 127 +#define PVR2D_64BPP_RAW                                        0x1DUL // 64 bit raw
 128 +#define PVR2D_128BPP_RAW                               0x1EUL // 128 bit raw
 129 +
 130 +#define        PVR2D_NO_OF_FORMATS                             0x1FUL
 131 +
 132 +/* Format modifier bit field (DstFormat and SrcFormat bits 16..23) */
 133 +#define PVR2D_FORMAT_MASK                              0x0000FFFFUL    // PVR2D Format bits
 134 +#define PVR2D_FORMAT_LAYOUT_MASK               0x000F0000UL    // Format layout (strided / twiddled / tiled)
 135 +#define PVR2D_FORMAT_FLAGS_MASK                        0x0FF00000UL    // Surface Flags mask
 136 +
 137 +/* Layout */
 138 +#define PVR2D_FORMAT_LAYOUT_SHIFT              16
 139 +#define PVR2D_FORMAT_LAYOUT_STRIDED            0x00000000UL
 140 +#define PVR2D_FORMAT_LAYOUT_TILED              0x00010000UL
 141 +#define PVR2D_FORMAT_LAYOUT_TWIDDLED   0x00020000UL
 142 +
 143 +/*
 144 +       PVR2D_SURFACE_PDUMP
 145 +       This flag requests a surface pdump, to capture the pixel state after host writes.
 146 +       Not needed if the surface state has resulted from previous SGX 2D/3D core writes.
 147 +*/
 148 +#define PVR2D_SURFACE_PDUMP                            0x00100000UL    // calls PVRSRVPDumpMem to capture the surface (pdump builds only)
 149 +
 150 +/*
 151 +       Low level 3D format extension - for blts via the 3D core only.
 152 +       If the top bit of the format field is set then PVR2D reads it as a PVRSRV_PIXEL_FORMAT.
 153 +       The outcome is hardware dependant.
 154 +       There is no guarantee that any specific PVRSRV format will be supported.
 155 +*/
 156 +#define PVR2D_FORMAT_PVRSRV                            0x80000000
 157 +
 158 +/* wrap surface type */
 159 +typedef enum
 160 +{
 161 +       PVR2D_WRAPFLAG_NONCONTIGUOUS = 0,
 162 +       PVR2D_WRAPFLAG_CONTIGUOUS = 1,
 163 +
 164 +}PVR2DWRAPFLAGS;
 165 +
 166 +#define        PVR2D_CONTEXT_FLAGS_PRIORITY_MASK                       0x00000003
 167 +
 168 +#define        PVR2D_CONTEXT_FLAGS_LOW_PRIORITY_CONTEXT        1
 169 +#define        PVR2D_CONTEXT_FLAGS_NORMAL_PRIORITY_CONTEXT     0
 170 +#define        PVR2D_CONTEXT_FLAGS_HIGH_PRIORITY_CONTEXT       2
 171 +
 172 +/* flags for control information of additional blits */
 173 +typedef enum
 174 +{
 175 +       PVR2D_BLIT_DISABLE_ALL                                  = 0x00000000,   /* disable all additional controls */
 176 +       PVR2D_BLIT_CK_ENABLE                                    = 0x00000001,   /* enable colour key */
 177 +       PVR2D_BLIT_GLOBAL_ALPHA_ENABLE                  = 0x00000002,   /* enable standard global alpha */
 178 +       PVR2D_BLIT_PERPIXEL_ALPHABLEND_ENABLE   = 0x00000004,   /* enable per-pixel alpha bleding */
 179 +       PVR2D_BLIT_PAT_SURFACE_ENABLE                   = 0x00000008,   /* enable pattern surf (disable fill) */
 180 +       PVR2D_BLIT_FULLY_SPECIFIED_ALPHA_ENABLE = 0x00000010,   /* enable fully specified alpha */
 181 +       PVR2D_BLIT_ROT_90                                               = 0x00000020,   /* apply 90 degree rotation to the blt */
 182 +       PVR2D_BLIT_ROT_180                                              = 0x00000040,   /* apply 180 degree rotation to the blt */
 183 +       PVR2D_BLIT_ROT_270                                              = 0x00000080,   /* apply 270 degree rotation to the blt */
 184 +       PVR2D_BLIT_COPYORDER_TL2BR                              = 0x00000100,   /* copy order overrides */
 185 +       PVR2D_BLIT_COPYORDER_BR2TL                              = 0x00000200,
 186 +       PVR2D_BLIT_COPYORDER_TR2BL                              = 0x00000400,
 187 +       PVR2D_BLIT_COPYORDER_BL2TR                              = 0x00000800,
 188 +       PVR2D_BLIT_COLKEY_SOURCE                                = 0x00001000,   /* Key colour is on the source surface */
 189 +       PVR2D_BLIT_COLKEY_DEST                                  = 0x00002000,   /* Key colour is on the destination surface */
 190 +       PVR2D_BLIT_COLKEY_MASKED                                = 0x00004000,   /* Mask enabled for colour key */
 191 +       PVR2D_BLIT_COLKEY_OP_PASS                               = 0x00008000,   /* Colour key op = pass */
 192 +       PVR2D_BLIT_COLKEY_OP_REJECT                             = 0x00010000,   /* Colour key op = reject */
 193 +       PVR2D_BLIT_PATH_2DCORE                                  = 0x00100000,   /* Blt via dedicated 2D Core or PTLA */
 194 +       PVR2D_BLIT_PATH_3DCORE                                  = 0x00200000,   /* Blt via 3D Core */
 195 +       PVR2D_BLIT_PATH_SWBLT                                   = 0x00400000,   /* Blt via host software */
 196 +       PVR2D_BLIT_NO_SRC_SYNC_INFO                             = 0x00800000,   /* Dont send a source sync info*/
 197 +       PVR2D_BLIT_ISSUE_STATUS_UPDATES                 = 0x01000000,   /* Issue status updates */
 198 +
 199 +} PVR2DBLITFLAGS;
 200 +
 201 +/* standard alpha-blending functions, AlphaBlendingFunc field of PVR2DBLTINFO */
 202 +typedef enum
 203 +{
 204 +       PVR2D_ALPHA_OP_SRC_DSTINV = 1,  /* source alpha : Cdst = Csrc*Asrc + Cdst*(1-Asrc) */
 205 +       PVR2D_ALPHA_OP_SRCP_DSTINV = 2  /* premultiplied source alpha : Cdst = Csrc + Cdst*(1-Asrc) */
 206 +} PVR2D_ALPHABLENDFUNC;
 207 +
 208 +/* blend ops for fully specified alpha (SGX 2D Core only) */
 209 +typedef enum
 210 +{
 211 +       PVR2D_BLEND_OP_ZERO = 0,
 212 +       PVR2D_BLEND_OP_ONE = 1,
 213 +       PVR2D_BLEND_OP_SRC = 2,
 214 +       PVR2D_BLEND_OP_DST = 3,
 215 +       PVR2D_BLEND_OP_GLOBAL = 4,
 216 +       PVR2D_BLEND_OP_SRC_PLUS_GLOBAL = 5,
 217 +       PVR2D_BLEND_OP_DST_PLUS_GLOBAL = 6
 218 +}PVR2D_BLEND_OP;
 219 +
 220 +/* SGX 2D Core Fully specified alpha blend :   pAlpha field of PVR2DBLTINFO structure          */
 221 +/* a fully specified Alpha Blend operation is defined as                                                                       */
 222 +/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (ALPHA_3 * DST (ALPHA))                                                     */
 223 +/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (ALPHA_4 * DST (RGB))                                                         */
 224 +/* if the pre-multiplication stage is enabled then the equations become the following:         */
 225 +/* PRE_MUL     = ((SRC(A)) * (Global Alpha Value))                                                                                     */
 226 +/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (PRE_MUL * DST (ALPHA))                                                     */
 227 +/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (PRE_MUL * DST (RGB))                                                         */
 228 +/* if the transparent source alpha stage is enabled then a source alpha of zero forces the     */
 229 +/* source to be transparent for that pixel regardless of the blend equation being used.                */
 230 +typedef struct _PVR2D_ALPHABLT
 231 +{
 232 +       PVR2D_BLEND_OP  eAlpha1;
 233 +       PVR2D_BOOL              bAlpha1Invert;
 234 +       PVR2D_BLEND_OP  eAlpha2;
 235 +       PVR2D_BOOL              bAlpha2Invert;
 236 +       PVR2D_BLEND_OP  eAlpha3;
 237 +       PVR2D_BOOL              bAlpha3Invert;
 238 +       PVR2D_BLEND_OP  eAlpha4;
 239 +       PVR2D_BOOL              bAlpha4Invert;
 240 +       PVR2D_BOOL              bPremulAlpha;                   /* enable pre-multiplication stage */
 241 +       PVR2D_BOOL              bTransAlpha;                    /* enable transparent source alpha stage */
 242 +       PVR2D_BOOL              bUpdateAlphaLookup;             /* enable and update the 1555-Lookup alpha table */
 243 +       PVR2D_UCHAR             uAlphaLookup0;                  /* 8 bit alpha when A=0 in a 1555-Lookup surface */
 244 +       PVR2D_UCHAR             uAlphaLookup1;                  /* 8 bit alpha when A=1 in a 1555-Lookup surface */
 245 +       PVR2D_UCHAR             uGlobalRGB;                             /* Global Alpha Value for RGB, 0=transparent 255=opaque */
 246 +       PVR2D_UCHAR             uGlobalA;                               /* Global Alpha Value for Alpha */
 247 +
 248 +} PVR2D_ALPHABLT, *PPVR2D_ALPHABLT;
 249 +
 250 +
 251 +/* surface memory info structure */
 252 +typedef struct _PVR2DMEMINFO
 253 +{
 254 +       PVR2D_VOID                      *pBase;
 255 +       PVR2D_ULONG                     ui32MemSize;
 256 +       PVR2D_ULONG                     ui32DevAddr;
 257 +       PVR2D_ULONG                     ulFlags;
 258 +       PVR2D_VOID                      *hPrivateData;
 259 +       PVR2D_VOID                      *hPrivateMapData;
 260 +
 261 +}PVR2DMEMINFO, *PPVR2DMEMINFO;
 262 +
 263 +
 264 +#define PVR2D_MAX_DEVICE_NAME 20
 265 +
 266 +typedef struct _PVR2DDEVICEINFO
 267 +{
 268 +       PVR2D_ULONG             ulDevID;
 269 +       PVR2D_CHAR              szDeviceName[PVR2D_MAX_DEVICE_NAME];
 270 +}PVR2DDEVICEINFO;
 271 +
 272 +
 273 +typedef struct _PVR2DISPLAYINFO
 274 +{
 275 +       PVR2D_ULONG     ulMaxFlipChains;
 276 +       PVR2D_ULONG     ulMaxBuffersInChain;
 277 +       PVR2DFORMAT     eFormat;
 278 +       PVR2D_ULONG     ulWidth;
 279 +       PVR2D_ULONG     ulHeight;
 280 +       PVR2D_LONG      lStride;
 281 +       PVR2D_ULONG     ulMinFlipInterval;
 282 +       PVR2D_ULONG     ulMaxFlipInterval;
 283 +
 284 +}PVR2DDISPLAYINFO;
 285 +
 286 +
 287 +typedef struct _PVR2MISCDISPLAYINFO
 288 +{
 289 +       PVR2D_ULONG ulPhysicalWidthmm;
 290 +       PVR2D_ULONG ulPhysicalHeightmm;
 291 +       PVR2D_ULONG ulUnused[10];
 292 +
 293 +}PVR2DMISCDISPLAYINFO;
 294 +
 295 +
 296 +typedef struct _PVR2DBLTINFO
 297 +{
 298 +       PVR2D_ULONG             CopyCode;                       /* rop code  */
 299 +       PVR2D_ULONG             Colour;                         /* fill colour */
 300 +       PVR2D_ULONG             ColourKey;                      /* colour key argb8888 (see CKEY_ defs below) */
 301 +       PVR2D_UCHAR             GlobalAlphaValue;       /* global alpha blending */
 302 +       PVR2D_UCHAR             AlphaBlendingFunc;      /* per-pixel alpha-blending function */
 303 +
 304 +       PVR2DBLITFLAGS  BlitFlags;                      /* additional blit control information */
 305 +
 306 +       PVR2DMEMINFO    *pDstMemInfo;           /* destination memory */
 307 +       PVR2D_ULONG             DstOffset;                      /* byte offset from start of allocation to destination surface pixel 0,0 */
 308 +       PVR2D_LONG              DstStride;                      /* signed stride, the number of bytes from pixel 0,0 to 0,1 */
 309 +       PVR2D_LONG              DstX, DstY;                     /* pixel offset from start of dest surface to start of blt rectangle */
 310 +       PVR2D_LONG              DSizeX,DSizeY;          /* blt size */
 311 +       PVR2DFORMAT             DstFormat;                      /* dest format */
 312 +       PVR2D_ULONG             DstSurfWidth;           /* size of dest surface in pixels */
 313 +       PVR2D_ULONG             DstSurfHeight;          /* size of dest surface in pixels */
 314 +
 315 +       PVR2DMEMINFO    *pSrcMemInfo;           /* source mem, (source fields are also used for patterns) */
 316 +       PVR2D_ULONG             SrcOffset;                      /* byte offset from start of allocation to src/pat surface pixel 0,0 */
 317 +       PVR2D_LONG              SrcStride;                      /* signed stride, the number of bytes from pixel 0,0 to 0,1 */
 318 +       PVR2D_LONG              SrcX, SrcY;                     /* pixel offset from start of surface to start of source rectangle */
 319 +                                                                               /* for patterns this is the start offset within the pattern */
 320 +       PVR2D_LONG              SizeX,SizeY;            /* source rectangle size or pattern size in pixels */
 321 +       PVR2DFORMAT             SrcFormat;                      /* source/pattern format */
 322 +       PVR2DMEMINFO    *pPalMemInfo;           /* source/pattern palette memory containing argb8888 colour table */
 323 +       PVR2D_ULONG             PalOffset;                      /* byte offset from start of allocation to start of palette */
 324 +       PVR2D_ULONG             SrcSurfWidth;           /* size of source surface in pixels */
 325 +       PVR2D_ULONG             SrcSurfHeight;          /* size of source surface in pixels */
 326 +
 327 +       PVR2DMEMINFO    *pMaskMemInfo;          /* mask memory, 1bpp format implied */
 328 +       PVR2D_ULONG             MaskOffset;                     /* byte offset from start of allocation to mask surface pixel 0,0 */
 329 +       PVR2D_LONG              MaskStride;                     /* signed stride, the number of bytes from pixel 0,0 to 0,1 */
 330 +       PVR2D_LONG              MaskX, MaskY;           /* mask rect top left (mask size = blt size) */
 331 +       PVR2D_ULONG             MaskSurfWidth;          /* size of mask surface in pixels */
 332 +       PVR2D_ULONG             MaskSurfHeight;         /* size of mask surface in pixels */
 333 +
 334 +       PPVR2D_ALPHABLT pAlpha;                         /* fully specified alpha blend (2DCore only) */
 335 +
 336 +       PVR2D_ULONG             uSrcChromaPlane1;       /* mem offset from start of source alloc to chroma plane 1 */
 337 +       PVR2D_ULONG             uSrcChromaPlane2;       /* mem offset from start of source alloc to chroma plane 2 */
 338 +       PVR2D_ULONG             uDstChromaPlane1;       /* mem offset from start of dest alloc to chroma plane 1 */
 339 +       PVR2D_ULONG             uDstChromaPlane2;       /* mem offset from start of dest alloc to chroma plane 2 */
 340 +
 341 +       PVR2D_ULONG             ColourKeyMask;          /* 32 bit colour key mask, only valid when PVR2D_BLIT_COLKEY_MASKED is set */
 342 +
 343 +}PVR2DBLTINFO, *PPVR2DBLTINFO;
 344 +
 345 +typedef struct _PVR2DRECT
 346 +{
 347 +       PVR2D_LONG left, top;
 348 +       PVR2D_LONG right, bottom;
 349 +} PVR2DRECT;
 350 +
 351 +typedef struct
 352 +{
 353 +       PVR2DMEMINFO    *pSurfMemInfo;          /* surface memory */
 354 +       PVR2D_ULONG             SurfOffset;                     /* byte offset from start of allocation to destination surface pixel 0,0 */
 355 +       PVR2D_LONG              Stride;                         /* signed stride */
 356 +       PVR2DFORMAT             Format;                         /* format */
 357 +       PVR2D_ULONG             SurfWidth;                      /* surface width in pixels */
 358 +       PVR2D_ULONG             SurfHeight;                     /* surface height in pixels */
 359 +
 360 +} PVR2D_SURFACE, *PPVR2D_SURFACE;
 361 +
 362 +typedef struct
 363 +{
 364 +       PVR2D_ULONG             uChromaPlane1;          /* YUV multiplane - byte offset from start of alloc to chroma plane 1 */
 365 +       PVR2D_ULONG             uChromaPlane2;          /* YUV multiplane - byte offset from start of alloc to chroma plane 2 */
 366 +       PVR2D_LONG              Reserved[2];            /* Reserved, must be zero */
 367 +
 368 +} PVR2D_SURFACE_EXT, *PPVR2D_SURFACE_EXT;
 369 +
 370 +typedef struct
 371 +{
 372 +       PVR2D_ULONG             *pUseCode;                                      /* USSE code */
 373 +       PVR2D_ULONG             UseCodeSize;                            /* usse code size in bytes */
 374 +
 375 +} PVR2D_USECODE, *PPVR2D_USECODE;
 376 +
 377 +typedef struct
 378 +{
 379 +       PVR2D_SURFACE                   sDst;                           /* destination surface */
 380 +       PVR2D_SURFACE                   sSrc;                           /* source surface */
 381 +       PVR2DRECT                               rcDest;                         /* destination rectangle */
 382 +       PVR2DRECT                               rcSource;                       /* source rectangle */
 383 +       PVR2D_HANDLE                    hUseCode;                       /* custom USE code (NULL implies source copy) */
 384 +       PVR2D_ULONG                             UseParams[2];           /* per-blt params for use code */
 385 +
 386 +} PVR2D_3DBLT, *PPVR2D_3DBLT;
 387 +
 388 +typedef struct
 389 +{
 390 +       PVR2D_SURFACE                   sDst;                                           /* destination surface */
 391 +       PVR2DRECT                               rcDest;                                         /* destination rectangle; scaling is supported */
 392 +       PVR2D_SURFACE                   sSrc;                                           /* source surface */
 393 +       PVR2DRECT                               rcSource;                                       /* source rectangle; scaling is supported */
 394 +       PPVR2D_SURFACE                  pSrc2;                                          /* optional second source surface (NULL if not required) */
 395 +       PVR2DRECT*                              prcSource2;                                     /* optional pSrc2 rectangle */
 396 +       PVR2D_HANDLE                    hUseCode;                                       /* custom USSE shader code (NULL implies default source copy) */
 397 +       PVR2D_ULONG                             UseParams[2];                           /* per-blt params for usse code */
 398 +       PVR2D_ULONG                             uiNumTemporaryRegisters;        /* no. of temporary registers used in custom shader code */
 399 +       PVR2D_BOOL                              bDisableDestInput;                      /* set true if the destination is output only */
 400 +       PPVR2D_SURFACE_EXT              pDstExt;                                        /* Extended format params for dest */
 401 +       PPVR2D_SURFACE_EXT              pSrcExt[2];                                     /* Extended format params for source 1 and 2 */
 402 +       PVR2D_LONG                              Reserved[4];                            /* Reserved, must be zero */
 403 +
 404 +} PVR2D_3DBLT_EXT, *PPVR2D_3DBLT_EXT;
 405 +
 406 +
 407 +#define MAKE_COPY_BLIT(src,soff,dest,doff,sx,sy,dx,dy,sz)
 408 +
 409 +typedef void* PVR2DCONTEXTHANDLE;
 410 +typedef void* PVR2DFLIPCHAINHANDLE;
 411 +
 412 +
 413 +// CopyCode field of PVR2DBLTINFO structure:
 414 +// the CopyCode field of the PVR2DBLTINFO structure should contain a rop3 or rop4 code.
 415 +// a rop3 is an 8 bit code that describes a blt with three inputs : source dest and pattern
 416 +// rop4 is a 16 bit code that describes a blt with four inputs : source dest pattern and mask
 417 +// common rop3 codes are defined below
 418 +// a colour fill blt is processed in the pattern channel as a constant colour with a rop code of 0xF0
 419 +// PVR2D_BLIT_PAT_SURFACE_ENABLE defines whether the pattern channel is a surface or a fill colour.
 420 +// a rop4 is defined by two rop3 codes, and the 1 bit-per-pixel mask surface defines which is used.
 421 +// a common rop4 is 0xAAF0 which is the mask copy blt used for text glyphs.
 422 +// CopyCode is taken to be a rop4 when pMaskMemInfo is non zero, otherwise it is assumed to be a rop3
 423 +// use the PVR2DMASKROP4 macro below to construct a rop4 from two rop3's
 424 +// rop3a is the rop used when mask pixel = 1, and rop3b when mask = 0
 425 +#define PVR2DROP4(rop3b, rop3a)                        ((rop3b<<8)|rop3a)
 426 +
 427 +/* common rop codes */
 428 +#define PVR2DROPclear                          0x00       /* 0 (whiteness) */
 429 +#define PVR2DROPset                                    0xFF       /* 1 (blackness) */
 430 +#define PVR2DROPnoop                           0xAA       /* dst (used for masked blts) */
 431 +
 432 +/* source and  dest rop codes */
 433 +#define PVR2DROPand                                    0x88       /* src AND dst */
 434 +#define PVR2DROPandReverse                     0x44       /* src AND NOT dst */
 435 +#define PVR2DROPcopy                           0xCC       /* src (used for source copy and alpha blts) */
 436 +#define PVR2DROPandInverted                    0x22       /* NOT src AND dst */
 437 +#define PVR2DROPxor                                    0x66       /* src XOR dst */
 438 +#define PVR2DROPor                                     0xEE       /* src OR dst */
 439 +#define PVR2DROPnor                                    0x11       /* NOT src AND NOT dst */
 440 +#define PVR2DROPequiv                          0x99       /* NOT src XOR dst */
 441 +#define PVR2DROPinvert                         0x55       /* NOT dst */
 442 +#define PVR2DROPorReverse                      0xDD       /* src OR NOT dst */
 443 +#define PVR2DROPcopyInverted           0x33       /* NOT src */
 444 +#define PVR2DROPorInverted                     0xBB       /* NOT src OR dst */
 445 +#define PVR2DROPnand                           0x77       /* NOT src OR NOT dst */
 446 +
 447 +/* pattern rop codes */
 448 +#define PVR2DPATROPand                         0xA0       /* pat AND dst */
 449 +#define PVR2DPATROPandReverse          0x50       /* pat AND NOT dst */
 450 +#define PVR2DPATROPcopy                                0xF0       /* pat (used for solid color fills and pattern blts) */
 451 +#define PVR2DPATROPandInverted         0x0A       /* NOT pat AND dst */
 452 +#define PVR2DPATROPxor                         0x5A       /* pat XOR dst */
 453 +#define PVR2DPATROPor                          0xFA       /* pat OR dst */
 454 +#define PVR2DPATROPnor                         0x05       /* NOT pat AND NOT dst */
 455 +#define PVR2DPATROPequiv                       0xA5       /* NOT pat XOR dst */
 456 +#define PVR2DPATROPinvert                      0x55       /* NOT dst */
 457 +#define PVR2DPATROPorReverse           0xF5       /* pat OR NOT dst */
 458 +#define PVR2DPATROPcopyInverted                0x0F       /* NOT pat */
 459 +#define PVR2DPATROPorInverted          0xAF       /* NOT pat OR dst */
 460 +#define PVR2DPATROPnand                                0x5F       /* NOT pat OR NOT dst */
 461 +
 462 +/* common rop4 codes */
 463 +#define PVR2DROP4MaskedCopy              PVR2DROP4(PVR2DROPnoop,PVR2DROPcopy)          /* masked source copy blt (used for rounded window corners etc) */
 464 +#define PVR2DROP4MaskedFill              PVR2DROP4(PVR2DROPnoop,PVR2DPATROPcopy)       /* masked colour fill blt (used for text) */
 465 +
 466 +/* Legacy support */
 467 +#define PVR2DROP3_PATMASK                      PVR2DPATROPcopy
 468 +#define PVR2DROP3_SRCMASK                      PVR2DROPcopy
 469 +
 470 +/* pixmap memory alignment */
 471 +#define PVR2D_ALIGNMENT_4                      4                       /* DWORD alignment */
 472 +#define PVR2D_ALIGNMENT_ANY                    0                       /* no alignment    */
 473 +#define PVR2D_ALIGNMENT_PALETTE                16                      /* 16 byte alignment is required for palettes */
 474 +
 475 +/* Heap number for PVR2DGetFrameBuffer */
 476 +#define PVR2D_FB_PRIMARY_SURFACE 0
 477 +
 478 +#define PVR2D_PRESENT_PROPERTY_SRCSTRIDE       (1UL << 0)
 479 +#define PVR2D_PRESENT_PROPERTY_DSTSIZE         (1UL << 1)
 480 +#define PVR2D_PRESENT_PROPERTY_DSTPOS          (1UL << 2)
 481 +#define PVR2D_PRESENT_PROPERTY_CLIPRECTS       (1UL << 3)
 482 +#define PVR2D_PRESENT_PROPERTY_INTERVAL                (1UL << 4)
 483 +
 484 +#define PVR2D_CREATE_FLIPCHAIN_SHARED          (1UL << 0)
 485 +#define PVR2D_CREATE_FLIPCHAIN_QUERY           (1UL << 1)
 486 +#define PVR2D_CREATE_FLIPCHAIN_OEMOVERLAY   (1UL << 2)
 487 +#define PVR2D_CREATE_FLIPCHAIN_AS_BLITCHAIN (1UL << 3)
 488 +
 489 +/* Colour-key colour must be translated into argb8888 format */
 490 +#define CKEY_8888(P)           (P)
 491 +#define CKEY_4444(P)           (((P&0xF000UL)<<16) | ((P&0x0F00UL)<<12) | ((P&0x00F0UL)<<8) | ((P&0x000FUL)<<4))
 492 +#define CKEY_1555(P)           (((P&0x8000UL)<<16) | ((P&0x7C00UL)<<9)  | ((P&0x3E0UL)<<6)  | ((P&0x1FUL)<<3))
 493 +#define CKEY_565(P)                    (((P&0xF800UL)<<8)  | ((P&0x7E0UL)<<5)   | ((P&0x1FUL)<<3))
 494 +#define CKEY_MASK_8888         0x00FFFFFFUL
 495 +#define CKEY_MASK_4444         0x00F0F0F0UL
 496 +#define CKEY_MASK_1555         0x00F8F8F8UL    /* Alpha is not normally included in the key test */
 497 +#define CKEY_MASK_565          0x00F8FCF8UL
 498 +
 499 +/* Fill colours must be translated into argb8888 format */
 500 +#define CFILL_4444(P)          (((P&0xF000UL)<<16) | ((P&0x0F00UL)<<12) | ((P&0x00F0UL)<<8) | ((P&0x000FUL)<<4))
 501 +#define CFILL_1555(P)          (((P&0x8000UL)<<16) | ((P&0x7C00UL)<<9)  | ((P&0x3E0UL)<<6)  | ((P&0x1FUL)<<3))
 502 +#define CFILL_565(P)           (((P&0xF800UL)<<8)  | ((P&0x7E0UL)<<5)   | ((P&0x1FUL)<<3))
 503 +
 504 +/* PVR2DCreateDeviceContext flags */
 505 +#define PVR2D_XSERVER_PROC                     0x00000001UL            /*!< Set for the Xserver connection */
 506 +
 507 +/* PVR2DMemAlloc flags */
 508 +#define PVR2D_MEM_UNCACHED                     0x00000000UL    /* Default */
 509 +#define PVR2D_MEM_CACHED                       0x00000001UL    /* Caller must flush and sync when necessary */
 510 +#define PVR2D_MEM_WRITECOMBINE         0x00000002UL
 511 +
 512 +/* Functions that the library exports */
 513 +
 514 +PVR2D_IMPORT
 515 +int PVR2DEnumerateDevices(PVR2DDEVICEINFO *pDevInfo);
 516 +
 517 +PVR2D_IMPORT
 518 +PVR2DERROR PVR2DCreateDeviceContext(PVR2D_ULONG ulDevID,
 519 +                                                                       PVR2DCONTEXTHANDLE* phContext,
 520 +                                                                       PVR2D_ULONG ulFlags);
 521 +
 522 +PVR2D_IMPORT
 523 +PVR2DERROR PVR2DDestroyDeviceContext(PVR2DCONTEXTHANDLE hContext);
 524 +
 525 +PVR2D_IMPORT
 526 +PVR2DERROR PVR2DGetDeviceInfo(PVR2DCONTEXTHANDLE hContext,
 527 +                                                         PVR2DDISPLAYINFO *pDisplayInfo);
 528 +
 529 +PVR2D_IMPORT
 530 +PVR2DERROR PVR2DGetMiscDisplayInfo(PVR2DCONTEXTHANDLE hContext,
 531 +                                                         PVR2DMISCDISPLAYINFO *pMiscDisplayInfo);
 532 +
 533 +PVR2D_IMPORT
 534 +PVR2DERROR PVR2DGetScreenMode(PVR2DCONTEXTHANDLE hContext,
 535 +                                                         PVR2DFORMAT *pFormat,
 536 +                                                         PVR2D_LONG *plWidth,
 537 +                                                         PVR2D_LONG *plHeight,
 538 +                                                         PVR2D_LONG *plStride,
 539 +                                                         PVR2D_INT *piRefreshRate);
 540 +
 541 +PVR2D_IMPORT
 542 +PVR2DERROR PVR2DGetFrameBuffer(PVR2DCONTEXTHANDLE hContext,
 543 +                                                          PVR2D_INT nHeap,
 544 +                                                          PVR2DMEMINFO **ppsMemInfo);
 545 +
 546 +PVR2D_IMPORT
 547 +PVR2DERROR PVR2DMemAlloc(PVR2DCONTEXTHANDLE hContext,
 548 +                                                PVR2D_ULONG ulBytes,
 549 +                                                PVR2D_ULONG ulAlign,
 550 +                                                PVR2D_ULONG ulFlags,
 551 +                                                PVR2DMEMINFO **ppsMemInfo);
 552 +
 553 +PVR2D_IMPORT
 554 +PVR2DERROR PVR2DMemExport(PVR2DCONTEXTHANDLE hContext,
 555 +                                                PVR2D_ULONG ulFlags,
 556 +                                                PVR2DMEMINFO *psMemInfo,
 557 +                                                PVR2D_HANDLE *phMemHandle);
 558 +
 559 +PVR2D_IMPORT
 560 +PVR2DERROR PVR2DMemWrap(PVR2DCONTEXTHANDLE hContext,
 561 +                                               PVR2D_VOID *pMem,
 562 +                                               PVR2D_ULONG ulFlags,
 563 +                                               PVR2D_ULONG ulBytes,
 564 +                                               PVR2D_ULONG alPageAddress[],
 565 +                                               PVR2DMEMINFO **ppsMemInfo);
 566 +
 567 +PVR2D_IMPORT
 568 +PVR2DERROR PVR2DMemMap(PVR2DCONTEXTHANDLE hContext,
 569 +                                               PVR2D_ULONG ulFlags,
 570 +                                               PVR2D_HANDLE hMemHandle,
 571 +                                               PVR2DMEMINFO **ppsDstMem);
 572 +
 573 +PVR2D_IMPORT
 574 +PVR2DERROR PVR2DMemFree(PVR2DCONTEXTHANDLE hContext,
 575 +                                               PVR2DMEMINFO *psMemInfo);
 576 +
 577 +PVR2D_IMPORT
 578 +PVR2DERROR PVR2DBlt(PVR2DCONTEXTHANDLE hContext,
 579 +                                       PVR2DBLTINFO *pBltInfo);
 580 +
 581 +PVR2D_IMPORT
 582 +PVR2DERROR PVR2DBltClipped(PVR2DCONTEXTHANDLE hContext,
 583 +                                                  PVR2DBLTINFO *pBltInfo,
 584 +                                                  PVR2D_ULONG ulNumClipRects,
 585 +                                                  PVR2DRECT *pClipRects);
 586 +
 587 +PVR2D_EXPORT
 588 +PVR2DERROR PVR2DSet1555Alpha (PVR2DCONTEXTHANDLE hContext,
 589 +                                                         PVR2D_UCHAR Alpha0, PVR2D_UCHAR Alpha1);
 590 +
 591 +PVR2D_IMPORT
 592 +PVR2DERROR PVR2DQueryBlitsComplete(PVR2DCONTEXTHANDLE hContext,
 593 +                                                                  const PVR2DMEMINFO *pMemInfo,
 594 +                                                                  PVR2D_UINT uiWaitForComplete);
 595 +
 596 +PVR2D_IMPORT
 597 +PVR2DERROR PVR2DSetPresentBltProperties(PVR2DCONTEXTHANDLE hContext,
 598 +                                                                               PVR2D_ULONG ulPropertyMask,
 599 +                                                                               PVR2D_LONG lSrcStride,
 600 +                                                                               PVR2D_ULONG ulDstWidth,
 601 +                                                                               PVR2D_ULONG ulDstHeight,
 602 +                                                                               PVR2D_LONG lDstXPos,
 603 +                                                                               PVR2D_LONG lDstYPos,
 604 +                                                                               PVR2D_ULONG ulNumClipRects,
 605 +                                                                               PVR2DRECT *pClipRects,
 606 +                                                                               PVR2D_ULONG ulSwapInterval);
 607 +
 608 +PVR2D_IMPORT
 609 +PVR2DERROR PVR2DPresentBlt(PVR2DCONTEXTHANDLE hContext,
 610 +                                                  PVR2DMEMINFO *pMemInfo,
 611 +                                                  PVR2D_LONG lRenderID);
 612 +
 613 +PVR2D_IMPORT
 614 +PVR2DERROR PVR2DCreateFlipChain(PVR2DCONTEXTHANDLE hContext,
 615 +                                                               PVR2D_ULONG ulFlags,
 616 +                                                               PVR2D_ULONG ulNumBuffers,
 617 +                                                               PVR2D_ULONG ulWidth,
 618 +                                                               PVR2D_ULONG ulHeight,
 619 +                                                               PVR2DFORMAT eFormat,
 620 +                                                               PVR2D_LONG *plStride,
 621 +                                                               PVR2D_ULONG *pulFlipChainID,
 622 +                                                               PVR2DFLIPCHAINHANDLE *phFlipChain);
 623 +
 624 +PVR2D_IMPORT
 625 +PVR2DERROR PVR2DDestroyFlipChain(PVR2DCONTEXTHANDLE hContext,
 626 +                                                                PVR2DFLIPCHAINHANDLE hFlipChain);
 627 +
 628 +PVR2D_IMPORT
 629 +PVR2DERROR PVR2DGetFlipChainBuffers(PVR2DCONTEXTHANDLE hContext,
 630 +                                                                       PVR2DFLIPCHAINHANDLE hFlipChain,
 631 +                                                                       PVR2D_ULONG *pulNumBuffers,
 632 +                                                                       PVR2DMEMINFO *psMemInfo[]);
 633 +
 634 +PVR2D_IMPORT
 635 +PVR2DERROR PVR2DSetPresentFlipProperties(PVR2DCONTEXTHANDLE hContext,
 636 +                                                                                PVR2DFLIPCHAINHANDLE hFlipChain,
 637 +                                                                                PVR2D_ULONG ulPropertyMask,
 638 +                                                                                PVR2D_LONG lDstXPos,
 639 +                                                                                PVR2D_LONG lDstYPos,
 640 +                                                                                PVR2D_ULONG ulNumClipRects,
 641 +                                                                                PVR2DRECT *pClipRects,
 642 +                                                                                PVR2D_ULONG ulSwapInterval);
 643 +
 644 +PVR2D_IMPORT
 645 +PVR2DERROR PVR2DPresentFlip(PVR2DCONTEXTHANDLE hContext,
 646 +                                                       PVR2DFLIPCHAINHANDLE hFlipChain,
 647 +                                                       PVR2DMEMINFO *psMemInfo,
 648 +                                                       PVR2D_LONG lRenderID);
 649 +
 650 +PVR2D_IMPORT
 651 +PVR2DERROR PVR2DGetAPIRev(PVR2D_LONG *lRevMajor, PVR2D_LONG *lRevMinor);
 652 +
 653 +PVR2D_IMPORT
 654 +PVR2DERROR PVR2DLoadUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_UCHAR      *pUseCode,
 655 +                                                                       const PVR2D_ULONG UseCodeSize, PVR2D_HANDLE *pUseCodeHandle);
 656 +PVR2D_IMPORT
 657 +PVR2DERROR PVR2DFreeUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_HANDLE hUseCodeHandle);
 658 +
 659 +PVR2D_IMPORT
 660 +PVR2DERROR PVR2DBlt3D (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT pBlt3D);
 661 +
 662 +PVR2D_IMPORT
 663 +PVR2DERROR PVR2DBlt3DExt (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT_EXT pBlt3D);
 664 +
 665 +#ifdef __cplusplus
 666 +}
 667 +#endif
 668 +
 669 +#endif /* _PVR2D_H_ */
 670 +
 671 +/******************************************************************************
 672 + End of file (pvr2d.h)
 673 +******************************************************************************/
 674 diff -Nurp qt-everywhere-opensource-src-4.6.3-orig//src/3rdparty/powervr/wsegl2/wsegl.h qt-everywhere-opensource-src-4.6.3/src/3rdparty/powervr/wsegl2/wsegl.h
 675 --- qt-everywhere-opensource-src-4.6.3-orig//src/3rdparty/powervr/wsegl2/wsegl.h        1970-01-01 00:00:00.000000000 +0000
 676 +++ qt-everywhere-opensource-src-4.6.3/src/3rdparty/powervr/wsegl2/wsegl.h      2011-05-16 22:51:52.702601769 +0000
 677 @@ -0,0 +1,285 @@
 678 +/**********************************************************************
 679 +*
 680 +* Copyright(c) Imagination Technologies Ltd.
 681 +*
 682 +* The contents of this file are subject to the MIT license as set out below.
 683 +*
 684 +* Permission is hereby granted, free of charge, to any person obtaining a copy
 685 +* of this software and associated documentation files (the "Software"),
 686 +* to deal in the Software without restriction, including without limitation
 687 +* the rights to use, copy, modify, merge, publish, distribute, sublicense,
 688 +* and/or sell copies of the Software, and to permit persons to whom the
 689 +* Software is furnished to do so, subject to the following conditions:
 690 +*
 691 +* The above copyright notice and this permission notice shall be included
 692 +* in all copies or substantial portions of the Software.
 693 +*
 694 +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 695 +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 696 +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 697 +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 698 +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
 699 +* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
 700 +* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 701 +*
 702 +* This License is also included in this distribution in the file called
 703 +* "COPYING".
 704 +*
 705 +******************************************************************************/
 706 +
 707 +
 708 +
 709 +#if !defined(__WSEGL_H__)
 710 +#define __WSEGL_H__
 711 +
 712 +#ifdef __cplusplus
 713 +extern "C" {
 714 +#endif
 715 +
 716 +/*
 717 +// WSEGL Platform-specific definitions
 718 +*/
 719 +#if defined(__linux__)
 720 +#define WSEGL_EXPORT __attribute__((visibility("default")))
 721 +#define WSEGL_IMPORT
 722 +#else
 723 +#define WSEGL_EXPORT
 724 +#define WSEGL_IMPORT
 725 +#endif
 726 +
 727 +/*
 728 +// WSEGL API Version Number
 729 +*/
 730 +
 731 +#define WSEGL_VERSION 2
 732 +#define WSEGL_DEFAULT_DISPLAY 0
 733 +#define WSEGL_DEFAULT_NATIVE_ENGINE 0
 734 +
 735 +#define WSEGL_FALSE            0
 736 +#define WSEGL_TRUE             1
 737 +#define WSEGL_NULL             0
 738 +
 739 +#define        WSEGL_UNREFERENCED_PARAMETER(param) (param) = (param)
 740 +
 741 +/*
 742 +// WSEGL handles
 743 +*/
 744 +typedef void *WSEGLDisplayHandle;
 745 +typedef void *WSEGLDrawableHandle;
 746 +
 747 +/*
 748 +// Display capability type
 749 +*/
 750 +typedef enum WSEGLCapsType_TAG
 751 +{
 752 +       WSEGL_NO_CAPS = 0,
 753 +       WSEGL_CAP_MIN_SWAP_INTERVAL = 1, /* System default value = 1 */
 754 +       WSEGL_CAP_MAX_SWAP_INTERVAL = 2, /* System default value = 1 */
 755 +       WSEGL_CAP_WINDOWS_USE_HW_SYNC = 3, /* System default value = 0 (FALSE) */
 756 +       WSEGL_CAP_PIXMAPS_USE_HW_SYNC = 4, /* System default value = 0 (FALSE) */
 757 +
 758 +} WSEGLCapsType;
 759 +
 760 +/*
 761 +// Display capability
 762 +*/
 763 +typedef struct WSEGLCaps_TAG
 764 +{
 765 +       WSEGLCapsType eCapsType;
 766 +       unsigned long ui32CapsValue;
 767 +
 768 +} WSEGLCaps;
 769 +
 770 +/*
 771 +// Drawable type
 772 +*/
 773 +#define WSEGL_NO_DRAWABLE                      0x0
 774 +#define WSEGL_DRAWABLE_WINDOW          0x1
 775 +#define WSEGL_DRAWABLE_PIXMAP          0x2
 776 +
 777 +
 778 +/*
 779 +// Pixel format of display/drawable
 780 +*/
 781 +typedef enum WSEGLPixelFormat_TAG
 782 +{
 783 +       /* These must not be re-ordered */
 784 +       WSEGL_PIXELFORMAT_RGB565        = 0,
 785 +       WSEGL_PIXELFORMAT_ARGB4444      = 1,
 786 +       WSEGL_PIXELFORMAT_ARGB8888      = 2,
 787 +       WSEGL_PIXELFORMAT_ARGB1555      = 3,
 788 +       WSEGL_PIXELFORMAT_ABGR8888      = 4,
 789 +       WSEGL_PIXELFORMAT_XBGR8888      = 5,
 790 +
 791 +       /* These are compatibility names only; new WSEGL
 792 +        * modules should not use them.
 793 +        */
 794 +       WSEGL_PIXELFORMAT_565           = WSEGL_PIXELFORMAT_RGB565,
 795 +       WSEGL_PIXELFORMAT_4444          = WSEGL_PIXELFORMAT_ARGB4444,
 796 +       WSEGL_PIXELFORMAT_8888          = WSEGL_PIXELFORMAT_ARGB8888,
 797 +       WSEGL_PIXELFORMAT_1555          = WSEGL_PIXELFORMAT_ARGB1555,
 798 +
 799 +} WSEGLPixelFormat;
 800 +
 801 +/*
 802 +// Transparent of display/drawable
 803 +*/
 804 +typedef enum WSEGLTransparentType_TAG
 805 +{
 806 +       WSEGL_OPAQUE = 0,
 807 +       WSEGL_COLOR_KEY = 1,
 808 +
 809 +} WSEGLTransparentType;
 810 +
 811 +/*
 812 +// Display/drawable configuration
 813 +*/
 814 +typedef struct WSEGLConfig_TAG
 815 +{
 816 +       /*
 817 +       // Type of drawables this configuration applies to -
 818 +       // OR'd values of drawable types.
 819 +       */
 820 +       unsigned long ui32DrawableType;
 821 +
 822 +       /* Pixel format */
 823 +       WSEGLPixelFormat ePixelFormat;
 824 +
 825 +       /* Native Renderable  - set to WSEGL_TRUE if native renderable */
 826 +       unsigned long ulNativeRenderable;
 827 +
 828 +       /* FrameBuffer Level Parameter */
 829 +       unsigned long ulFrameBufferLevel;
 830 +
 831 +       /* Native Visual ID */
 832 +       unsigned long ulNativeVisualID;
 833 +
 834 +       /* Native Visual */
 835 +       void *hNativeVisual;
 836 +
 837 +       /* Transparent Type */
 838 +       WSEGLTransparentType eTransparentType;
 839 +
 840 +       /* Transparent Color - only used if transparent type is COLOR_KEY */
 841 +       unsigned long ulTransparentColor; /* packed as 0x00RRGGBB */
 842 +
 843 +
 844 +} WSEGLConfig;
 845 +
 846 +/*
 847 +// WSEGL errors
 848 +*/
 849 +typedef enum WSEGLError_TAG
 850 +{
 851 +       WSEGL_SUCCESS = 0,
 852 +       WSEGL_CANNOT_INITIALISE = 1,
 853 +       WSEGL_BAD_NATIVE_DISPLAY = 2,
 854 +       WSEGL_BAD_NATIVE_WINDOW = 3,
 855 +       WSEGL_BAD_NATIVE_PIXMAP = 4,
 856 +       WSEGL_BAD_NATIVE_ENGINE = 5,
 857 +       WSEGL_BAD_DRAWABLE = 6,
 858 +       WSEGL_BAD_MATCH = 7,
 859 +       WSEGL_OUT_OF_MEMORY = 8,
 860 +
 861 +       /* These are compatibility names only; new WSEGL
 862 +        * modules should not use them.
 863 +        */
 864 +       WSEGL_BAD_CONFIG = WSEGL_BAD_MATCH,
 865 +
 866 +} WSEGLError;
 867 +
 868 +/*
 869 +// Drawable orientation (in degrees anti-clockwise)
 870 +*/
 871 +typedef enum WSEGLRotationAngle_TAG
 872 +{
 873 +       WSEGL_ROTATE_0 = 0,
 874 +       WSEGL_ROTATE_90 = 1,
 875 +       WSEGL_ROTATE_180 = 2,
 876 +       WSEGL_ROTATE_270 = 3
 877 +
 878 +} WSEGLRotationAngle;
 879 +
 880 +/*
 881 +// Drawable information required by OpenGL-ES driver
 882 +*/
 883 +typedef struct WSEGLDrawableParams_TAG
 884 +{
 885 +       /* Width in pixels of the drawable */
 886 +       unsigned long   ui32Width;
 887 +
 888 +       /* Height in pixels of the drawable */
 889 +       unsigned long   ui32Height;
 890 +
 891 +       /* Stride in pixels of the drawable */
 892 +       unsigned long   ui32Stride;
 893 +
 894 +       /* Pixel format of the drawable */
 895 +       WSEGLPixelFormat        ePixelFormat;
 896 +
 897 +       /* User space cpu virtual address of the drawable */
 898 +       void                    *pvLinearAddress;
 899 +
 900 +       /* HW address of the drawable */
 901 +       unsigned long   ui32HWAddress;
 902 +
 903 +       /* Private data for the drawable */
 904 +       void                    *hPrivateData;
 905 +
 906 +
 907 +} WSEGLDrawableParams;
 908 +
 909 +
 910 +/*
 911 +// Table of function pointers that is returned by WSEGL_GetFunctionTablePointer()
 912 +//
 913 +// The first entry in the table is the version number of the wsegl.h header file that
 914 +// the module has been written against, and should therefore be set to WSEGL_VERSION
 915 +*/
 916 +typedef struct WSEGL_FunctionTable_TAG
 917 +{
 918 +       unsigned long ui32WSEGLVersion;
 919 +
 920 +       WSEGLError (*pfnWSEGL_IsDisplayValid)(NativeDisplayType);
 921 +
 922 +       WSEGLError (*pfnWSEGL_InitialiseDisplay)(NativeDisplayType, WSEGLDisplayHandle *, const WSEGLCaps **, WSEGLConfig **);
 923 +
 924 +       WSEGLError (*pfnWSEGL_CloseDisplay)(WSEGLDisplayHandle);
 925 +
 926 +       WSEGLError (*pfnWSEGL_CreateWindowDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativeWindowType, WSEGLRotationAngle *);
 927 +
 928 +       WSEGLError (*pfnWSEGL_CreatePixmapDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativePixmapType, WSEGLRotationAngle *);
 929 +
 930 +       WSEGLError (*pfnWSEGL_DeleteDrawable)(WSEGLDrawableHandle);
 931 +
 932 +       WSEGLError (*pfnWSEGL_SwapDrawable)(WSEGLDrawableHandle, unsigned long);
 933 +
 934 +       WSEGLError (*pfnWSEGL_SwapControlInterval)(WSEGLDrawableHandle, unsigned long);
 935 +
 936 +       WSEGLError (*pfnWSEGL_WaitNative)(WSEGLDrawableHandle, unsigned long);
 937 +
 938 +       WSEGLError (*pfnWSEGL_CopyFromDrawable)(WSEGLDrawableHandle, NativePixmapType);
 939 +
 940 +       WSEGLError (*pfnWSEGL_CopyFromPBuffer)(void *, unsigned long, unsigned long, unsigned long, WSEGLPixelFormat, NativePixmapType);
 941 +
 942 +       WSEGLError (*pfnWSEGL_GetDrawableParameters)(WSEGLDrawableHandle, WSEGLDrawableParams *, WSEGLDrawableParams *);
 943 +
 944 +       WSEGLError (*pfnWSEGL_ConnectDrawable)(WSEGLDrawableHandle);
 945 +
 946 +       WSEGLError (*pfnWSEGL_DisconnectDrawable)(WSEGLDrawableHandle);
 947 +
 948 +
 949 +} WSEGL_FunctionTable;
 950 +
 951 +
 952 +WSEGL_IMPORT const WSEGL_FunctionTable *WSEGL_GetFunctionTablePointer(void);
 953 +
 954 +#ifdef __cplusplus
 955 +}
 956 +#endif
 957 +
 958 +#endif /* __WSEGL_H__ */
 959 +
 960 +/******************************************************************************
 961 + End of file (wsegl.h)
 962 +******************************************************************************/
 963 diff -Nurp qt-everywhere-opensource-src-4.6.3-orig//src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c qt-everywhere-opensource-src-4.6.3/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c
 964 --- qt-everywhere-opensource-src-4.6.3-orig//src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c      2010-06-02 02:03:17.000000000 +0000
 965 +++ qt-everywhere-opensource-src-4.6.3/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c    2011-05-16 23:08:51.618597097 +0000
 966 @@ -378,6 +378,20 @@ static WSEGLError wseglGetDrawableParame
 967      return WSEGL_SUCCESS;
 968  }
 969
 970 +/* Function stub for ConnectDrawable() */
 971 +static WSEGLError wseglConnectDrawable(WSEGLDrawableHandle hDrawable)
 972 +{
 973 +    WSEGL_UNREFERENCED_PARAMETER(hDrawable);
 974 +    return WSEGL_SUCCESS;
 975 +}
 976 +
 977 +/* Function stub for DisconnectDrawable() */
 978 +static WSEGLError wseglDisconnectDrawable(WSEGLDrawableHandle hDrawable)
 979 +{
 980 +    WSEGL_UNREFERENCED_PARAMETER(hDrawable);
 981 +    return WSEGL_SUCCESS;
 982 +}
 983 +
 984  static WSEGL_FunctionTable const wseglFunctions = {
 985      WSEGL_VERSION,
 986      wseglIsDisplayValid,
 987 @@ -391,7 +405,9 @@ static WSEGL_FunctionTable const wseglFu
 988      wseglWaitNative,
 989      wseglCopyFromDrawable,
 990      wseglCopyFromPBuffer,
 991 -    wseglGetDrawableParameters
 992 +    wseglGetDrawableParameters,
 993 +    wseglConnectDrawable,
 994 +    wseglDisconnectDrawable
 995  };
 996
 997  /* Return the table of WSEGL functions to the EGL implementation */