From patchwork Sun Jul 7 17:12:45 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Spenser Gilliland X-Patchwork-Id: 257351 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from fraxinus.osuosl.org (fraxinus.osuosl.org [140.211.166.137]) by ozlabs.org (Postfix) with ESMTP id 2AE7D2C0087 for ; Mon, 8 Jul 2013 03:13:14 +1000 (EST) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 61E938BD89; Sun, 7 Jul 2013 17:13:13 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id ZmL66mjYRAeR; Sun, 7 Jul 2013 17:13:06 +0000 (UTC) Received: from ash.osuosl.org (ash.osuosl.org [140.211.166.34]) by fraxinus.osuosl.org (Postfix) with ESMTP id 7F7108BDA9; Sun, 7 Jul 2013 17:13:06 +0000 (UTC) X-Original-To: buildroot@lists.busybox.net Delivered-To: buildroot@osuosl.org Received: from whitealder.osuosl.org (whitealder.osuosl.org [140.211.166.138]) by ash.osuosl.org (Postfix) with ESMTP id 968A98F753 for ; Sun, 7 Jul 2013 17:13:11 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 96D8E8AB10 for ; Sun, 7 Jul 2013 17:13:04 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 8Hwx+KE+W9+4 for ; Sun, 7 Jul 2013 17:13:01 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.7.6 Received: from mail-ob0-f182.google.com (mail-ob0-f182.google.com [209.85.214.182]) by whitealder.osuosl.org (Postfix) with ESMTPS id E6F488A5EB for ; Sun, 7 Jul 2013 17:13:00 +0000 (UTC) Received: by mail-ob0-f182.google.com with SMTP id va7so4719501obc.27 for ; Sun, 07 Jul 2013 10:13:00 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=from:to:cc:subject:date:message-id:x-mailer:in-reply-to:references :x-gm-message-state; bh=lXte62q4BoX38I7YErX7Cj+WI6S6/f/F313dARUV1HY=; b=XVpw9iu9zASTsn0yxo7aBRlHLxaepiRY0LiRtlvZ23GZc264CrIc67U3kvj+LDHXqM YKKjDzpGQlsKNQxA7mD2uIiheCIcOCIwImyG6EAphNj90v3b4DCrQAQJSixuiCwEdvbZ kWajLUntUxu9tXq7xl5AGdQrBIVaXFvB++u8ju6dCPHcuJxTZ5EKlf5NbxWnnfeBo4yK V+emPrQXlQYnbqWIxnywHeuIOeR/Ol8yaHt5bsajOMlITfq3HpzyT5zn3zoVHFtOU7aN i8F19E8scnuy/BnND8umLVtNxpb6+/R2tNrHCqmLqKqctkEkcb/qY2H15rJYDxlENBAC pLEg== X-Received: by 10.60.43.226 with SMTP id z2mr18074519oel.76.1373217179935; Sun, 07 Jul 2013 10:12:59 -0700 (PDT) Received: from bourban.gateway.2wire.net (108-90-245-135.lightspeed.cicril.sbcglobal.net. [108.90.245.135]) by mx.google.com with ESMTPSA id df11sm28849729oec.0.2013.07.07.10.12.58 for (version=TLSv1.1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Sun, 07 Jul 2013 10:12:59 -0700 (PDT) From: Spenser Gilliland To: buildroot@busybox.net Date: Sun, 7 Jul 2013 12:12:45 -0500 Message-Id: <1373217165-14521-2-git-send-email-spenser@gillilanding.com> X-Mailer: git-send-email 1.8.1.2 In-Reply-To: <1373217165-14521-1-git-send-email-spenser@gillilanding.com> References: <1373217165-14521-1-git-send-email-spenser@gillilanding.com> X-Gm-Message-State: ALoCoQljGIha3bSBz9UCqN4/7utGieFWurCu6cqxpWeHAXrKw8m4HiIibD5RA8p78Wffu+Iqoswj Subject: [Buildroot] [PATCH v3 2/2] qt: add powervr and opengl X-BeenThere: buildroot@busybox.net X-Mailman-Version: 2.1.14 Precedence: list List-Id: Discussion and development of buildroot List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: buildroot-bounces@busybox.net Sender: buildroot-bounces@busybox.net Signed-off-by: Spenser Gilliland --- This patch adds powervr output to qt4. The patch can be tested by installing the qt demos using BR2_PACKAGE_QT_DEMOS and running the folloiwng. /usr/share/qt/examples/opengl/hellogl_es2/hellogl_es2 -qws -display powervr --- package/qt/Config.gfx.in | 5 + package/qt/Config.in | 8 + package/qt/powervr.ini | 2 + package/qt/qt-pvrqwswseql.patch | 11 + package/qt/qt-wsegl2.patch | 998 ++++++++++++++++++++++++++++++++++++++++ package/qt/qt.mk | 28 +- 6 files changed, 1051 insertions(+), 1 deletion(-) create mode 100644 package/qt/powervr.ini create mode 100644 package/qt/qt-pvrqwswseql.patch create mode 100644 package/qt/qt-wsegl2.patch diff --git a/package/qt/Config.gfx.in b/package/qt/Config.gfx.in index dc70665..c983f29 100644 --- a/package/qt/Config.gfx.in +++ b/package/qt/Config.gfx.in @@ -23,4 +23,9 @@ config BR2_PACKAGE_QT_GFX_DIRECTFB depends on BR2_PACKAGE_DIRECTFB bool "directFB" +config BR2_PACKAGE_QT_GFX_POWERVR + depends on BR2_PACKAGE_QT_OPENGL_ES + depends on BR2_PACKAGE_TI_GFX + bool "powervr" + endmenu diff --git a/package/qt/Config.in b/package/qt/Config.in index 9f6e54d..35e8208 100644 --- a/package/qt/Config.in +++ b/package/qt/Config.in @@ -281,6 +281,14 @@ config BR2_PACKAGE_QT_PHONON_BACKEND help Build the platform Phonon plugin. If unsure, say n. + +config BR2_PACKAGE_QT_OPENGL_ES + bool "OpenGL ES v2.x support" + depends on BR2_PACKAGE_HAS_OPENGL_ES + depends on BR2_PACKAGE_HAS_OPENGL_EGL + help + Enable the OpenGL ES v2.x support. + endif config BR2_PACKAGE_QT_DBUS diff --git a/package/qt/powervr.ini b/package/qt/powervr.ini new file mode 100644 index 0000000..57863eb --- /dev/null +++ b/package/qt/powervr.ini @@ -0,0 +1,2 @@ +[default] +WindowSystem=libpvrQWSWSEGL.so.1 diff --git a/package/qt/qt-pvrqwswseql.patch b/package/qt/qt-pvrqwswseql.patch new file mode 100644 index 0000000..41e8475 --- /dev/null +++ b/package/qt/qt-pvrqwswseql.patch @@ -0,0 +1,11 @@ +--- ./src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl_orig.c 2012-02-27 18:53:22.919285167 +0530 ++++ ./src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c 2012-02-25 11:26:47.131221091 +0530 +@@ -39,7 +39,7 @@ + ** + ****************************************************************************/ + +-#include ++#include + #include + #include + #include diff --git a/package/qt/qt-wsegl2.patch b/package/qt/qt-wsegl2.patch new file mode 100644 index 0000000..ac261e1 --- /dev/null +++ b/package/qt/qt-wsegl2.patch @@ -0,0 +1,998 @@ +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 +--- qt-everywhere-opensource-src-4.6.3-orig//src/3rdparty/powervr/wsegl2/pvr2d.h 1970-01-01 00:00:00.000000000 +0000 ++++ qt-everywhere-opensource-src-4.6.3/src/3rdparty/powervr/wsegl2/pvr2d.h 2011-05-16 22:51:43.158564336 +0000 +@@ -0,0 +1,669 @@ ++/********************************************************************** ++* ++* Copyright(c) Imagination Technologies Ltd. ++* ++* The contents of this file are subject to the MIT license as set out below. ++* ++* Permission is hereby granted, free of charge, to any person obtaining a copy ++* of this software and associated documentation files (the "Software"), ++* to deal in the Software without restriction, including without limitation ++* the rights to use, copy, modify, merge, publish, distribute, sublicense, ++* and/or sell copies of the Software, and to permit persons to whom the ++* Software is furnished to do so, subject to the following conditions: ++* ++* The above copyright notice and this permission notice shall be included ++* in all copies or substantial portions of the Software. ++* ++* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ++* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, ++* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT ++* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE ++* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++* ++* This License is also included in this distribution in the file called ++* "COPYING". ++* ++******************************************************************************/ ++ ++ ++ ++/****************************************************************************** ++Modifications :- ++$Log: pvr2d.h $ ++ ++ --- Revision Logs Removed --- ++******************************************************************************/ ++ ++#ifndef _PVR2D_H_ ++#define _PVR2D_H_ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* PVR2D Platform-specific definitions */ ++#if defined (__linux__) ++#define PVR2D_EXPORT __attribute__((visibility("default"))) ++#define PVR2D_IMPORT ++#else ++#define PVR2D_EXPORT ++#define PVR2D_IMPORT ++#endif ++ ++/* PVR2D header revision */ ++#define PVR2D_REV_MAJOR 3 ++#define PVR2D_REV_MINOR 5 ++ ++/* Basic types */ ++typedef enum ++{ ++ PVR2D_FALSE = 0, ++ PVR2D_TRUE ++} PVR2D_BOOL; ++ ++typedef void* PVR2D_HANDLE; ++ ++typedef char PVR2D_CHAR, *PVR2D_PCHAR; ++typedef unsigned char PVR2D_UCHAR, *PVR2D_PUCHAR; ++typedef int PVR2D_INT, *PVR2D_PINT; ++typedef unsigned int PVR2D_UINT, *PVR2D_PUINT; ++typedef long PVR2D_LONG, *PVR2D_PLONG; ++typedef unsigned long PVR2D_ULONG, *PVR2D_PULONG; ++ ++typedef void PVR2D_VOID, *PVR2D_PVOID; ++ ++ ++/* error codes */ ++typedef enum ++{ ++ PVR2D_OK = 0, ++ PVR2DERROR_INVALID_PARAMETER = -1, ++ PVR2DERROR_DEVICE_UNAVAILABLE = -2, ++ PVR2DERROR_INVALID_CONTEXT = -3, ++ PVR2DERROR_MEMORY_UNAVAILABLE = -4, ++ PVR2DERROR_DEVICE_NOT_PRESENT = -5, ++ PVR2DERROR_IOCTL_ERROR = -6, ++ PVR2DERROR_GENERIC_ERROR = -7, ++ PVR2DERROR_BLT_NOTCOMPLETE = -8, ++ PVR2DERROR_HW_FEATURE_NOT_SUPPORTED = -9, ++ PVR2DERROR_NOT_YET_IMPLEMENTED = -10, ++ PVR2DERROR_MAPPING_FAILED = -11 ++}PVR2DERROR; ++ ++/* 32 bit PVR2D pixel format specifier */ ++typedef unsigned long PVR2DFORMAT; ++ ++/* Standard PVR2D pixel formats */ ++#define PVR2D_1BPP 0x00UL // 1bpp mask surface or palletized 1 bit source with 2x32 bit CLUT ++#define PVR2D_RGB565 0x01UL // Common rgb 565 format ++#define PVR2D_ARGB4444 0x02UL // Common argb 4444 format ++#define PVR2D_RGB888 0x03UL // Common rgb 888 format (not supported) ++#define PVR2D_ARGB8888 0x04UL // Common argb 8888 format ++#define PVR2D_ARGB1555 0x05UL // Common argb 1555 format ++#define PVR2D_ALPHA8 0x06UL // Alpha-only 8 bit per pixel (used with a constant fill colour) ++#define PVR2D_ALPHA4 0x07UL // Alpha-only 4 bits per pixel (used with a constant fill colour) ++#define PVR2D_PAL2 0x08UL // Palletized 2 bit format (requires 4x32 bit CLUT) ++#define PVR2D_PAL4 0x09UL // Palletized 4 bit format (requires 16x32 bit CLUT) ++#define PVR2D_PAL8 0x0AUL // Palletized 8 bit format (requires 256x32 bit CLUT) ++#define PVR2D_U8 0x10UL // monochrome unsigned 8 bit ++#define PVR2D_U88 0x11UL // monochrome unsigned 16 bit ++#define PVR2D_S8 0x12UL // signed 8 bit ++#define PVR2D_YUV422_YUYV 0x13UL // YUV 422 low-high byte order Y0UY1V ++#define PVR2D_YUV422_UYVY 0x14UL // YUV 422 low-high byte order UY0VY1 ++#define PVR2D_YUV422_YVYU 0x15UL // YUV 422 low-high byte order Y0VY1U ++#define PVR2D_YUV422_VYUY 0x16UL // YUV 422 low-high byte order VY0UY1 ++#define PVR2D_YUV420_2PLANE 0x17UL // YUV420 2 Plane ++#define PVR2D_YUV420_3PLANE 0x18UL // YUV420 3 Plane ++#define PVR2D_2101010ARGB 0x19UL // 32 bit 2 10 10 10 ++#define PVR2D_888RSGSBS 0x1AUL ++#define PVR2D_16BPP_RAW 0x1BUL // 16 bit raw (no format conversion) ++#define PVR2D_32BPP_RAW 0x1CUL // 32 bit raw ++#define PVR2D_64BPP_RAW 0x1DUL // 64 bit raw ++#define PVR2D_128BPP_RAW 0x1EUL // 128 bit raw ++ ++#define PVR2D_NO_OF_FORMATS 0x1FUL ++ ++/* Format modifier bit field (DstFormat and SrcFormat bits 16..23) */ ++#define PVR2D_FORMAT_MASK 0x0000FFFFUL // PVR2D Format bits ++#define PVR2D_FORMAT_LAYOUT_MASK 0x000F0000UL // Format layout (strided / twiddled / tiled) ++#define PVR2D_FORMAT_FLAGS_MASK 0x0FF00000UL // Surface Flags mask ++ ++/* Layout */ ++#define PVR2D_FORMAT_LAYOUT_SHIFT 16 ++#define PVR2D_FORMAT_LAYOUT_STRIDED 0x00000000UL ++#define PVR2D_FORMAT_LAYOUT_TILED 0x00010000UL ++#define PVR2D_FORMAT_LAYOUT_TWIDDLED 0x00020000UL ++ ++/* ++ PVR2D_SURFACE_PDUMP ++ This flag requests a surface pdump, to capture the pixel state after host writes. ++ Not needed if the surface state has resulted from previous SGX 2D/3D core writes. ++*/ ++#define PVR2D_SURFACE_PDUMP 0x00100000UL // calls PVRSRVPDumpMem to capture the surface (pdump builds only) ++ ++/* ++ Low level 3D format extension - for blts via the 3D core only. ++ If the top bit of the format field is set then PVR2D reads it as a PVRSRV_PIXEL_FORMAT. ++ The outcome is hardware dependant. ++ There is no guarantee that any specific PVRSRV format will be supported. ++*/ ++#define PVR2D_FORMAT_PVRSRV 0x80000000 ++ ++/* wrap surface type */ ++typedef enum ++{ ++ PVR2D_WRAPFLAG_NONCONTIGUOUS = 0, ++ PVR2D_WRAPFLAG_CONTIGUOUS = 1, ++ ++}PVR2DWRAPFLAGS; ++ ++#define PVR2D_CONTEXT_FLAGS_PRIORITY_MASK 0x00000003 ++ ++#define PVR2D_CONTEXT_FLAGS_LOW_PRIORITY_CONTEXT 1 ++#define PVR2D_CONTEXT_FLAGS_NORMAL_PRIORITY_CONTEXT 0 ++#define PVR2D_CONTEXT_FLAGS_HIGH_PRIORITY_CONTEXT 2 ++ ++/* flags for control information of additional blits */ ++typedef enum ++{ ++ PVR2D_BLIT_DISABLE_ALL = 0x00000000, /* disable all additional controls */ ++ PVR2D_BLIT_CK_ENABLE = 0x00000001, /* enable colour key */ ++ PVR2D_BLIT_GLOBAL_ALPHA_ENABLE = 0x00000002, /* enable standard global alpha */ ++ PVR2D_BLIT_PERPIXEL_ALPHABLEND_ENABLE = 0x00000004, /* enable per-pixel alpha bleding */ ++ PVR2D_BLIT_PAT_SURFACE_ENABLE = 0x00000008, /* enable pattern surf (disable fill) */ ++ PVR2D_BLIT_FULLY_SPECIFIED_ALPHA_ENABLE = 0x00000010, /* enable fully specified alpha */ ++ PVR2D_BLIT_ROT_90 = 0x00000020, /* apply 90 degree rotation to the blt */ ++ PVR2D_BLIT_ROT_180 = 0x00000040, /* apply 180 degree rotation to the blt */ ++ PVR2D_BLIT_ROT_270 = 0x00000080, /* apply 270 degree rotation to the blt */ ++ PVR2D_BLIT_COPYORDER_TL2BR = 0x00000100, /* copy order overrides */ ++ PVR2D_BLIT_COPYORDER_BR2TL = 0x00000200, ++ PVR2D_BLIT_COPYORDER_TR2BL = 0x00000400, ++ PVR2D_BLIT_COPYORDER_BL2TR = 0x00000800, ++ PVR2D_BLIT_COLKEY_SOURCE = 0x00001000, /* Key colour is on the source surface */ ++ PVR2D_BLIT_COLKEY_DEST = 0x00002000, /* Key colour is on the destination surface */ ++ PVR2D_BLIT_COLKEY_MASKED = 0x00004000, /* Mask enabled for colour key */ ++ PVR2D_BLIT_COLKEY_OP_PASS = 0x00008000, /* Colour key op = pass */ ++ PVR2D_BLIT_COLKEY_OP_REJECT = 0x00010000, /* Colour key op = reject */ ++ PVR2D_BLIT_PATH_2DCORE = 0x00100000, /* Blt via dedicated 2D Core or PTLA */ ++ PVR2D_BLIT_PATH_3DCORE = 0x00200000, /* Blt via 3D Core */ ++ PVR2D_BLIT_PATH_SWBLT = 0x00400000, /* Blt via host software */ ++ PVR2D_BLIT_NO_SRC_SYNC_INFO = 0x00800000, /* Dont send a source sync info*/ ++ PVR2D_BLIT_ISSUE_STATUS_UPDATES = 0x01000000, /* Issue status updates */ ++ ++} PVR2DBLITFLAGS; ++ ++/* standard alpha-blending functions, AlphaBlendingFunc field of PVR2DBLTINFO */ ++typedef enum ++{ ++ PVR2D_ALPHA_OP_SRC_DSTINV = 1, /* source alpha : Cdst = Csrc*Asrc + Cdst*(1-Asrc) */ ++ PVR2D_ALPHA_OP_SRCP_DSTINV = 2 /* premultiplied source alpha : Cdst = Csrc + Cdst*(1-Asrc) */ ++} PVR2D_ALPHABLENDFUNC; ++ ++/* blend ops for fully specified alpha (SGX 2D Core only) */ ++typedef enum ++{ ++ PVR2D_BLEND_OP_ZERO = 0, ++ PVR2D_BLEND_OP_ONE = 1, ++ PVR2D_BLEND_OP_SRC = 2, ++ PVR2D_BLEND_OP_DST = 3, ++ PVR2D_BLEND_OP_GLOBAL = 4, ++ PVR2D_BLEND_OP_SRC_PLUS_GLOBAL = 5, ++ PVR2D_BLEND_OP_DST_PLUS_GLOBAL = 6 ++}PVR2D_BLEND_OP; ++ ++/* SGX 2D Core Fully specified alpha blend : pAlpha field of PVR2DBLTINFO structure */ ++/* a fully specified Alpha Blend operation is defined as */ ++/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (ALPHA_3 * DST (ALPHA)) */ ++/* DST (RGB) = (ALPHA_2 * SRC (RGB)) + (ALPHA_4 * DST (RGB)) */ ++/* if the pre-multiplication stage is enabled then the equations become the following: */ ++/* PRE_MUL = ((SRC(A)) * (Global Alpha Value)) */ ++/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (PRE_MUL * DST (ALPHA)) */ ++/* DST (RGB) = (ALPHA_2 * SRC (RGB)) + (PRE_MUL * DST (RGB)) */ ++/* if the transparent source alpha stage is enabled then a source alpha of zero forces the */ ++/* source to be transparent for that pixel regardless of the blend equation being used. */ ++typedef struct _PVR2D_ALPHABLT ++{ ++ PVR2D_BLEND_OP eAlpha1; ++ PVR2D_BOOL bAlpha1Invert; ++ PVR2D_BLEND_OP eAlpha2; ++ PVR2D_BOOL bAlpha2Invert; ++ PVR2D_BLEND_OP eAlpha3; ++ PVR2D_BOOL bAlpha3Invert; ++ PVR2D_BLEND_OP eAlpha4; ++ PVR2D_BOOL bAlpha4Invert; ++ PVR2D_BOOL bPremulAlpha; /* enable pre-multiplication stage */ ++ PVR2D_BOOL bTransAlpha; /* enable transparent source alpha stage */ ++ PVR2D_BOOL bUpdateAlphaLookup; /* enable and update the 1555-Lookup alpha table */ ++ PVR2D_UCHAR uAlphaLookup0; /* 8 bit alpha when A=0 in a 1555-Lookup surface */ ++ PVR2D_UCHAR uAlphaLookup1; /* 8 bit alpha when A=1 in a 1555-Lookup surface */ ++ PVR2D_UCHAR uGlobalRGB; /* Global Alpha Value for RGB, 0=transparent 255=opaque */ ++ PVR2D_UCHAR uGlobalA; /* Global Alpha Value for Alpha */ ++ ++} PVR2D_ALPHABLT, *PPVR2D_ALPHABLT; ++ ++ ++/* surface memory info structure */ ++typedef struct _PVR2DMEMINFO ++{ ++ PVR2D_VOID *pBase; ++ PVR2D_ULONG ui32MemSize; ++ PVR2D_ULONG ui32DevAddr; ++ PVR2D_ULONG ulFlags; ++ PVR2D_VOID *hPrivateData; ++ PVR2D_VOID *hPrivateMapData; ++ ++}PVR2DMEMINFO, *PPVR2DMEMINFO; ++ ++ ++#define PVR2D_MAX_DEVICE_NAME 20 ++ ++typedef struct _PVR2DDEVICEINFO ++{ ++ PVR2D_ULONG ulDevID; ++ PVR2D_CHAR szDeviceName[PVR2D_MAX_DEVICE_NAME]; ++}PVR2DDEVICEINFO; ++ ++ ++typedef struct _PVR2DISPLAYINFO ++{ ++ PVR2D_ULONG ulMaxFlipChains; ++ PVR2D_ULONG ulMaxBuffersInChain; ++ PVR2DFORMAT eFormat; ++ PVR2D_ULONG ulWidth; ++ PVR2D_ULONG ulHeight; ++ PVR2D_LONG lStride; ++ PVR2D_ULONG ulMinFlipInterval; ++ PVR2D_ULONG ulMaxFlipInterval; ++ ++}PVR2DDISPLAYINFO; ++ ++ ++typedef struct _PVR2MISCDISPLAYINFO ++{ ++ PVR2D_ULONG ulPhysicalWidthmm; ++ PVR2D_ULONG ulPhysicalHeightmm; ++ PVR2D_ULONG ulUnused[10]; ++ ++}PVR2DMISCDISPLAYINFO; ++ ++ ++typedef struct _PVR2DBLTINFO ++{ ++ PVR2D_ULONG CopyCode; /* rop code */ ++ PVR2D_ULONG Colour; /* fill colour */ ++ PVR2D_ULONG ColourKey; /* colour key argb8888 (see CKEY_ defs below) */ ++ PVR2D_UCHAR GlobalAlphaValue; /* global alpha blending */ ++ PVR2D_UCHAR AlphaBlendingFunc; /* per-pixel alpha-blending function */ ++ ++ PVR2DBLITFLAGS BlitFlags; /* additional blit control information */ ++ ++ PVR2DMEMINFO *pDstMemInfo; /* destination memory */ ++ PVR2D_ULONG DstOffset; /* byte offset from start of allocation to destination surface pixel 0,0 */ ++ PVR2D_LONG DstStride; /* signed stride, the number of bytes from pixel 0,0 to 0,1 */ ++ PVR2D_LONG DstX, DstY; /* pixel offset from start of dest surface to start of blt rectangle */ ++ PVR2D_LONG DSizeX,DSizeY; /* blt size */ ++ PVR2DFORMAT DstFormat; /* dest format */ ++ PVR2D_ULONG DstSurfWidth; /* size of dest surface in pixels */ ++ PVR2D_ULONG DstSurfHeight; /* size of dest surface in pixels */ ++ ++ PVR2DMEMINFO *pSrcMemInfo; /* source mem, (source fields are also used for patterns) */ ++ PVR2D_ULONG SrcOffset; /* byte offset from start of allocation to src/pat surface pixel 0,0 */ ++ PVR2D_LONG SrcStride; /* signed stride, the number of bytes from pixel 0,0 to 0,1 */ ++ PVR2D_LONG SrcX, SrcY; /* pixel offset from start of surface to start of source rectangle */ ++ /* for patterns this is the start offset within the pattern */ ++ PVR2D_LONG SizeX,SizeY; /* source rectangle size or pattern size in pixels */ ++ PVR2DFORMAT SrcFormat; /* source/pattern format */ ++ PVR2DMEMINFO *pPalMemInfo; /* source/pattern palette memory containing argb8888 colour table */ ++ PVR2D_ULONG PalOffset; /* byte offset from start of allocation to start of palette */ ++ PVR2D_ULONG SrcSurfWidth; /* size of source surface in pixels */ ++ PVR2D_ULONG SrcSurfHeight; /* size of source surface in pixels */ ++ ++ PVR2DMEMINFO *pMaskMemInfo; /* mask memory, 1bpp format implied */ ++ PVR2D_ULONG MaskOffset; /* byte offset from start of allocation to mask surface pixel 0,0 */ ++ PVR2D_LONG MaskStride; /* signed stride, the number of bytes from pixel 0,0 to 0,1 */ ++ PVR2D_LONG MaskX, MaskY; /* mask rect top left (mask size = blt size) */ ++ PVR2D_ULONG MaskSurfWidth; /* size of mask surface in pixels */ ++ PVR2D_ULONG MaskSurfHeight; /* size of mask surface in pixels */ ++ ++ PPVR2D_ALPHABLT pAlpha; /* fully specified alpha blend (2DCore only) */ ++ ++ PVR2D_ULONG uSrcChromaPlane1; /* mem offset from start of source alloc to chroma plane 1 */ ++ PVR2D_ULONG uSrcChromaPlane2; /* mem offset from start of source alloc to chroma plane 2 */ ++ PVR2D_ULONG uDstChromaPlane1; /* mem offset from start of dest alloc to chroma plane 1 */ ++ PVR2D_ULONG uDstChromaPlane2; /* mem offset from start of dest alloc to chroma plane 2 */ ++ ++ PVR2D_ULONG ColourKeyMask; /* 32 bit colour key mask, only valid when PVR2D_BLIT_COLKEY_MASKED is set */ ++ ++}PVR2DBLTINFO, *PPVR2DBLTINFO; ++ ++typedef struct _PVR2DRECT ++{ ++ PVR2D_LONG left, top; ++ PVR2D_LONG right, bottom; ++} PVR2DRECT; ++ ++typedef struct ++{ ++ PVR2DMEMINFO *pSurfMemInfo; /* surface memory */ ++ PVR2D_ULONG SurfOffset; /* byte offset from start of allocation to destination surface pixel 0,0 */ ++ PVR2D_LONG Stride; /* signed stride */ ++ PVR2DFORMAT Format; /* format */ ++ PVR2D_ULONG SurfWidth; /* surface width in pixels */ ++ PVR2D_ULONG SurfHeight; /* surface height in pixels */ ++ ++} PVR2D_SURFACE, *PPVR2D_SURFACE; ++ ++typedef struct ++{ ++ PVR2D_ULONG uChromaPlane1; /* YUV multiplane - byte offset from start of alloc to chroma plane 1 */ ++ PVR2D_ULONG uChromaPlane2; /* YUV multiplane - byte offset from start of alloc to chroma plane 2 */ ++ PVR2D_LONG Reserved[2]; /* Reserved, must be zero */ ++ ++} PVR2D_SURFACE_EXT, *PPVR2D_SURFACE_EXT; ++ ++typedef struct ++{ ++ PVR2D_ULONG *pUseCode; /* USSE code */ ++ PVR2D_ULONG UseCodeSize; /* usse code size in bytes */ ++ ++} PVR2D_USECODE, *PPVR2D_USECODE; ++ ++typedef struct ++{ ++ PVR2D_SURFACE sDst; /* destination surface */ ++ PVR2D_SURFACE sSrc; /* source surface */ ++ PVR2DRECT rcDest; /* destination rectangle */ ++ PVR2DRECT rcSource; /* source rectangle */ ++ PVR2D_HANDLE hUseCode; /* custom USE code (NULL implies source copy) */ ++ PVR2D_ULONG UseParams[2]; /* per-blt params for use code */ ++ ++} PVR2D_3DBLT, *PPVR2D_3DBLT; ++ ++typedef struct ++{ ++ PVR2D_SURFACE sDst; /* destination surface */ ++ PVR2DRECT rcDest; /* destination rectangle; scaling is supported */ ++ PVR2D_SURFACE sSrc; /* source surface */ ++ PVR2DRECT rcSource; /* source rectangle; scaling is supported */ ++ PPVR2D_SURFACE pSrc2; /* optional second source surface (NULL if not required) */ ++ PVR2DRECT* prcSource2; /* optional pSrc2 rectangle */ ++ PVR2D_HANDLE hUseCode; /* custom USSE shader code (NULL implies default source copy) */ ++ PVR2D_ULONG UseParams[2]; /* per-blt params for usse code */ ++ PVR2D_ULONG uiNumTemporaryRegisters; /* no. of temporary registers used in custom shader code */ ++ PVR2D_BOOL bDisableDestInput; /* set true if the destination is output only */ ++ PPVR2D_SURFACE_EXT pDstExt; /* Extended format params for dest */ ++ PPVR2D_SURFACE_EXT pSrcExt[2]; /* Extended format params for source 1 and 2 */ ++ PVR2D_LONG Reserved[4]; /* Reserved, must be zero */ ++ ++} PVR2D_3DBLT_EXT, *PPVR2D_3DBLT_EXT; ++ ++ ++#define MAKE_COPY_BLIT(src,soff,dest,doff,sx,sy,dx,dy,sz) ++ ++typedef void* PVR2DCONTEXTHANDLE; ++typedef void* PVR2DFLIPCHAINHANDLE; ++ ++ ++// CopyCode field of PVR2DBLTINFO structure: ++// the CopyCode field of the PVR2DBLTINFO structure should contain a rop3 or rop4 code. ++// a rop3 is an 8 bit code that describes a blt with three inputs : source dest and pattern ++// rop4 is a 16 bit code that describes a blt with four inputs : source dest pattern and mask ++// common rop3 codes are defined below ++// a colour fill blt is processed in the pattern channel as a constant colour with a rop code of 0xF0 ++// PVR2D_BLIT_PAT_SURFACE_ENABLE defines whether the pattern channel is a surface or a fill colour. ++// a rop4 is defined by two rop3 codes, and the 1 bit-per-pixel mask surface defines which is used. ++// a common rop4 is 0xAAF0 which is the mask copy blt used for text glyphs. ++// CopyCode is taken to be a rop4 when pMaskMemInfo is non zero, otherwise it is assumed to be a rop3 ++// use the PVR2DMASKROP4 macro below to construct a rop4 from two rop3's ++// rop3a is the rop used when mask pixel = 1, and rop3b when mask = 0 ++#define PVR2DROP4(rop3b, rop3a) ((rop3b<<8)|rop3a) ++ ++/* common rop codes */ ++#define PVR2DROPclear 0x00 /* 0 (whiteness) */ ++#define PVR2DROPset 0xFF /* 1 (blackness) */ ++#define PVR2DROPnoop 0xAA /* dst (used for masked blts) */ ++ ++/* source and dest rop codes */ ++#define PVR2DROPand 0x88 /* src AND dst */ ++#define PVR2DROPandReverse 0x44 /* src AND NOT dst */ ++#define PVR2DROPcopy 0xCC /* src (used for source copy and alpha blts) */ ++#define PVR2DROPandInverted 0x22 /* NOT src AND dst */ ++#define PVR2DROPxor 0x66 /* src XOR dst */ ++#define PVR2DROPor 0xEE /* src OR dst */ ++#define PVR2DROPnor 0x11 /* NOT src AND NOT dst */ ++#define PVR2DROPequiv 0x99 /* NOT src XOR dst */ ++#define PVR2DROPinvert 0x55 /* NOT dst */ ++#define PVR2DROPorReverse 0xDD /* src OR NOT dst */ ++#define PVR2DROPcopyInverted 0x33 /* NOT src */ ++#define PVR2DROPorInverted 0xBB /* NOT src OR dst */ ++#define PVR2DROPnand 0x77 /* NOT src OR NOT dst */ ++ ++/* pattern rop codes */ ++#define PVR2DPATROPand 0xA0 /* pat AND dst */ ++#define PVR2DPATROPandReverse 0x50 /* pat AND NOT dst */ ++#define PVR2DPATROPcopy 0xF0 /* pat (used for solid color fills and pattern blts) */ ++#define PVR2DPATROPandInverted 0x0A /* NOT pat AND dst */ ++#define PVR2DPATROPxor 0x5A /* pat XOR dst */ ++#define PVR2DPATROPor 0xFA /* pat OR dst */ ++#define PVR2DPATROPnor 0x05 /* NOT pat AND NOT dst */ ++#define PVR2DPATROPequiv 0xA5 /* NOT pat XOR dst */ ++#define PVR2DPATROPinvert 0x55 /* NOT dst */ ++#define PVR2DPATROPorReverse 0xF5 /* pat OR NOT dst */ ++#define PVR2DPATROPcopyInverted 0x0F /* NOT pat */ ++#define PVR2DPATROPorInverted 0xAF /* NOT pat OR dst */ ++#define PVR2DPATROPnand 0x5F /* NOT pat OR NOT dst */ ++ ++/* common rop4 codes */ ++#define PVR2DROP4MaskedCopy PVR2DROP4(PVR2DROPnoop,PVR2DROPcopy) /* masked source copy blt (used for rounded window corners etc) */ ++#define PVR2DROP4MaskedFill PVR2DROP4(PVR2DROPnoop,PVR2DPATROPcopy) /* masked colour fill blt (used for text) */ ++ ++/* Legacy support */ ++#define PVR2DROP3_PATMASK PVR2DPATROPcopy ++#define PVR2DROP3_SRCMASK PVR2DROPcopy ++ ++/* pixmap memory alignment */ ++#define PVR2D_ALIGNMENT_4 4 /* DWORD alignment */ ++#define PVR2D_ALIGNMENT_ANY 0 /* no alignment */ ++#define PVR2D_ALIGNMENT_PALETTE 16 /* 16 byte alignment is required for palettes */ ++ ++/* Heap number for PVR2DGetFrameBuffer */ ++#define PVR2D_FB_PRIMARY_SURFACE 0 ++ ++#define PVR2D_PRESENT_PROPERTY_SRCSTRIDE (1UL << 0) ++#define PVR2D_PRESENT_PROPERTY_DSTSIZE (1UL << 1) ++#define PVR2D_PRESENT_PROPERTY_DSTPOS (1UL << 2) ++#define PVR2D_PRESENT_PROPERTY_CLIPRECTS (1UL << 3) ++#define PVR2D_PRESENT_PROPERTY_INTERVAL (1UL << 4) ++ ++#define PVR2D_CREATE_FLIPCHAIN_SHARED (1UL << 0) ++#define PVR2D_CREATE_FLIPCHAIN_QUERY (1UL << 1) ++#define PVR2D_CREATE_FLIPCHAIN_OEMOVERLAY (1UL << 2) ++#define PVR2D_CREATE_FLIPCHAIN_AS_BLITCHAIN (1UL << 3) ++ ++/* Colour-key colour must be translated into argb8888 format */ ++#define CKEY_8888(P) (P) ++#define CKEY_4444(P) (((P&0xF000UL)<<16) | ((P&0x0F00UL)<<12) | ((P&0x00F0UL)<<8) | ((P&0x000FUL)<<4)) ++#define CKEY_1555(P) (((P&0x8000UL)<<16) | ((P&0x7C00UL)<<9) | ((P&0x3E0UL)<<6) | ((P&0x1FUL)<<3)) ++#define CKEY_565(P) (((P&0xF800UL)<<8) | ((P&0x7E0UL)<<5) | ((P&0x1FUL)<<3)) ++#define CKEY_MASK_8888 0x00FFFFFFUL ++#define CKEY_MASK_4444 0x00F0F0F0UL ++#define CKEY_MASK_1555 0x00F8F8F8UL /* Alpha is not normally included in the key test */ ++#define CKEY_MASK_565 0x00F8FCF8UL ++ ++/* Fill colours must be translated into argb8888 format */ ++#define CFILL_4444(P) (((P&0xF000UL)<<16) | ((P&0x0F00UL)<<12) | ((P&0x00F0UL)<<8) | ((P&0x000FUL)<<4)) ++#define CFILL_1555(P) (((P&0x8000UL)<<16) | ((P&0x7C00UL)<<9) | ((P&0x3E0UL)<<6) | ((P&0x1FUL)<<3)) ++#define CFILL_565(P) (((P&0xF800UL)<<8) | ((P&0x7E0UL)<<5) | ((P&0x1FUL)<<3)) ++ ++/* PVR2DCreateDeviceContext flags */ ++#define PVR2D_XSERVER_PROC 0x00000001UL /*!< Set for the Xserver connection */ ++ ++/* PVR2DMemAlloc flags */ ++#define PVR2D_MEM_UNCACHED 0x00000000UL /* Default */ ++#define PVR2D_MEM_CACHED 0x00000001UL /* Caller must flush and sync when necessary */ ++#define PVR2D_MEM_WRITECOMBINE 0x00000002UL ++ ++/* Functions that the library exports */ ++ ++PVR2D_IMPORT ++int PVR2DEnumerateDevices(PVR2DDEVICEINFO *pDevInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DCreateDeviceContext(PVR2D_ULONG ulDevID, ++ PVR2DCONTEXTHANDLE* phContext, ++ PVR2D_ULONG ulFlags); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DDestroyDeviceContext(PVR2DCONTEXTHANDLE hContext); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DGetDeviceInfo(PVR2DCONTEXTHANDLE hContext, ++ PVR2DDISPLAYINFO *pDisplayInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DGetMiscDisplayInfo(PVR2DCONTEXTHANDLE hContext, ++ PVR2DMISCDISPLAYINFO *pMiscDisplayInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DGetScreenMode(PVR2DCONTEXTHANDLE hContext, ++ PVR2DFORMAT *pFormat, ++ PVR2D_LONG *plWidth, ++ PVR2D_LONG *plHeight, ++ PVR2D_LONG *plStride, ++ PVR2D_INT *piRefreshRate); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DGetFrameBuffer(PVR2DCONTEXTHANDLE hContext, ++ PVR2D_INT nHeap, ++ PVR2DMEMINFO **ppsMemInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DMemAlloc(PVR2DCONTEXTHANDLE hContext, ++ PVR2D_ULONG ulBytes, ++ PVR2D_ULONG ulAlign, ++ PVR2D_ULONG ulFlags, ++ PVR2DMEMINFO **ppsMemInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DMemExport(PVR2DCONTEXTHANDLE hContext, ++ PVR2D_ULONG ulFlags, ++ PVR2DMEMINFO *psMemInfo, ++ PVR2D_HANDLE *phMemHandle); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DMemWrap(PVR2DCONTEXTHANDLE hContext, ++ PVR2D_VOID *pMem, ++ PVR2D_ULONG ulFlags, ++ PVR2D_ULONG ulBytes, ++ PVR2D_ULONG alPageAddress[], ++ PVR2DMEMINFO **ppsMemInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DMemMap(PVR2DCONTEXTHANDLE hContext, ++ PVR2D_ULONG ulFlags, ++ PVR2D_HANDLE hMemHandle, ++ PVR2DMEMINFO **ppsDstMem); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DMemFree(PVR2DCONTEXTHANDLE hContext, ++ PVR2DMEMINFO *psMemInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DBlt(PVR2DCONTEXTHANDLE hContext, ++ PVR2DBLTINFO *pBltInfo); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DBltClipped(PVR2DCONTEXTHANDLE hContext, ++ PVR2DBLTINFO *pBltInfo, ++ PVR2D_ULONG ulNumClipRects, ++ PVR2DRECT *pClipRects); ++ ++PVR2D_EXPORT ++PVR2DERROR PVR2DSet1555Alpha (PVR2DCONTEXTHANDLE hContext, ++ PVR2D_UCHAR Alpha0, PVR2D_UCHAR Alpha1); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DQueryBlitsComplete(PVR2DCONTEXTHANDLE hContext, ++ const PVR2DMEMINFO *pMemInfo, ++ PVR2D_UINT uiWaitForComplete); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DSetPresentBltProperties(PVR2DCONTEXTHANDLE hContext, ++ PVR2D_ULONG ulPropertyMask, ++ PVR2D_LONG lSrcStride, ++ PVR2D_ULONG ulDstWidth, ++ PVR2D_ULONG ulDstHeight, ++ PVR2D_LONG lDstXPos, ++ PVR2D_LONG lDstYPos, ++ PVR2D_ULONG ulNumClipRects, ++ PVR2DRECT *pClipRects, ++ PVR2D_ULONG ulSwapInterval); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DPresentBlt(PVR2DCONTEXTHANDLE hContext, ++ PVR2DMEMINFO *pMemInfo, ++ PVR2D_LONG lRenderID); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DCreateFlipChain(PVR2DCONTEXTHANDLE hContext, ++ PVR2D_ULONG ulFlags, ++ PVR2D_ULONG ulNumBuffers, ++ PVR2D_ULONG ulWidth, ++ PVR2D_ULONG ulHeight, ++ PVR2DFORMAT eFormat, ++ PVR2D_LONG *plStride, ++ PVR2D_ULONG *pulFlipChainID, ++ PVR2DFLIPCHAINHANDLE *phFlipChain); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DDestroyFlipChain(PVR2DCONTEXTHANDLE hContext, ++ PVR2DFLIPCHAINHANDLE hFlipChain); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DGetFlipChainBuffers(PVR2DCONTEXTHANDLE hContext, ++ PVR2DFLIPCHAINHANDLE hFlipChain, ++ PVR2D_ULONG *pulNumBuffers, ++ PVR2DMEMINFO *psMemInfo[]); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DSetPresentFlipProperties(PVR2DCONTEXTHANDLE hContext, ++ PVR2DFLIPCHAINHANDLE hFlipChain, ++ PVR2D_ULONG ulPropertyMask, ++ PVR2D_LONG lDstXPos, ++ PVR2D_LONG lDstYPos, ++ PVR2D_ULONG ulNumClipRects, ++ PVR2DRECT *pClipRects, ++ PVR2D_ULONG ulSwapInterval); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DPresentFlip(PVR2DCONTEXTHANDLE hContext, ++ PVR2DFLIPCHAINHANDLE hFlipChain, ++ PVR2DMEMINFO *psMemInfo, ++ PVR2D_LONG lRenderID); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DGetAPIRev(PVR2D_LONG *lRevMajor, PVR2D_LONG *lRevMinor); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DLoadUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_UCHAR *pUseCode, ++ const PVR2D_ULONG UseCodeSize, PVR2D_HANDLE *pUseCodeHandle); ++PVR2D_IMPORT ++PVR2DERROR PVR2DFreeUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_HANDLE hUseCodeHandle); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DBlt3D (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT pBlt3D); ++ ++PVR2D_IMPORT ++PVR2DERROR PVR2DBlt3DExt (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT_EXT pBlt3D); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* _PVR2D_H_ */ ++ ++/****************************************************************************** ++ End of file (pvr2d.h) ++******************************************************************************/ +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 +--- qt-everywhere-opensource-src-4.6.3-orig//src/3rdparty/powervr/wsegl2/wsegl.h 1970-01-01 00:00:00.000000000 +0000 ++++ qt-everywhere-opensource-src-4.6.3/src/3rdparty/powervr/wsegl2/wsegl.h 2011-05-16 22:51:52.702601769 +0000 +@@ -0,0 +1,285 @@ ++/********************************************************************** ++* ++* Copyright(c) Imagination Technologies Ltd. ++* ++* The contents of this file are subject to the MIT license as set out below. ++* ++* Permission is hereby granted, free of charge, to any person obtaining a copy ++* of this software and associated documentation files (the "Software"), ++* to deal in the Software without restriction, including without limitation ++* the rights to use, copy, modify, merge, publish, distribute, sublicense, ++* and/or sell copies of the Software, and to permit persons to whom the ++* Software is furnished to do so, subject to the following conditions: ++* ++* The above copyright notice and this permission notice shall be included ++* in all copies or substantial portions of the Software. ++* ++* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ++* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, ++* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT ++* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE ++* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++* ++* This License is also included in this distribution in the file called ++* "COPYING". ++* ++******************************************************************************/ ++ ++ ++ ++#if !defined(__WSEGL_H__) ++#define __WSEGL_H__ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* ++// WSEGL Platform-specific definitions ++*/ ++#if defined(__linux__) ++#define WSEGL_EXPORT __attribute__((visibility("default"))) ++#define WSEGL_IMPORT ++#else ++#define WSEGL_EXPORT ++#define WSEGL_IMPORT ++#endif ++ ++/* ++// WSEGL API Version Number ++*/ ++ ++#define WSEGL_VERSION 2 ++#define WSEGL_DEFAULT_DISPLAY 0 ++#define WSEGL_DEFAULT_NATIVE_ENGINE 0 ++ ++#define WSEGL_FALSE 0 ++#define WSEGL_TRUE 1 ++#define WSEGL_NULL 0 ++ ++#define WSEGL_UNREFERENCED_PARAMETER(param) (param) = (param) ++ ++/* ++// WSEGL handles ++*/ ++typedef void *WSEGLDisplayHandle; ++typedef void *WSEGLDrawableHandle; ++ ++/* ++// Display capability type ++*/ ++typedef enum WSEGLCapsType_TAG ++{ ++ WSEGL_NO_CAPS = 0, ++ WSEGL_CAP_MIN_SWAP_INTERVAL = 1, /* System default value = 1 */ ++ WSEGL_CAP_MAX_SWAP_INTERVAL = 2, /* System default value = 1 */ ++ WSEGL_CAP_WINDOWS_USE_HW_SYNC = 3, /* System default value = 0 (FALSE) */ ++ WSEGL_CAP_PIXMAPS_USE_HW_SYNC = 4, /* System default value = 0 (FALSE) */ ++ ++} WSEGLCapsType; ++ ++/* ++// Display capability ++*/ ++typedef struct WSEGLCaps_TAG ++{ ++ WSEGLCapsType eCapsType; ++ unsigned long ui32CapsValue; ++ ++} WSEGLCaps; ++ ++/* ++// Drawable type ++*/ ++#define WSEGL_NO_DRAWABLE 0x0 ++#define WSEGL_DRAWABLE_WINDOW 0x1 ++#define WSEGL_DRAWABLE_PIXMAP 0x2 ++ ++ ++/* ++// Pixel format of display/drawable ++*/ ++typedef enum WSEGLPixelFormat_TAG ++{ ++ /* These must not be re-ordered */ ++ WSEGL_PIXELFORMAT_RGB565 = 0, ++ WSEGL_PIXELFORMAT_ARGB4444 = 1, ++ WSEGL_PIXELFORMAT_ARGB8888 = 2, ++ WSEGL_PIXELFORMAT_ARGB1555 = 3, ++ WSEGL_PIXELFORMAT_ABGR8888 = 4, ++ WSEGL_PIXELFORMAT_XBGR8888 = 5, ++ ++ /* These are compatibility names only; new WSEGL ++ * modules should not use them. ++ */ ++ WSEGL_PIXELFORMAT_565 = WSEGL_PIXELFORMAT_RGB565, ++ WSEGL_PIXELFORMAT_4444 = WSEGL_PIXELFORMAT_ARGB4444, ++ WSEGL_PIXELFORMAT_8888 = WSEGL_PIXELFORMAT_ARGB8888, ++ WSEGL_PIXELFORMAT_1555 = WSEGL_PIXELFORMAT_ARGB1555, ++ ++} WSEGLPixelFormat; ++ ++/* ++// Transparent of display/drawable ++*/ ++typedef enum WSEGLTransparentType_TAG ++{ ++ WSEGL_OPAQUE = 0, ++ WSEGL_COLOR_KEY = 1, ++ ++} WSEGLTransparentType; ++ ++/* ++// Display/drawable configuration ++*/ ++typedef struct WSEGLConfig_TAG ++{ ++ /* ++ // Type of drawables this configuration applies to - ++ // OR'd values of drawable types. ++ */ ++ unsigned long ui32DrawableType; ++ ++ /* Pixel format */ ++ WSEGLPixelFormat ePixelFormat; ++ ++ /* Native Renderable - set to WSEGL_TRUE if native renderable */ ++ unsigned long ulNativeRenderable; ++ ++ /* FrameBuffer Level Parameter */ ++ unsigned long ulFrameBufferLevel; ++ ++ /* Native Visual ID */ ++ unsigned long ulNativeVisualID; ++ ++ /* Native Visual */ ++ void *hNativeVisual; ++ ++ /* Transparent Type */ ++ WSEGLTransparentType eTransparentType; ++ ++ /* Transparent Color - only used if transparent type is COLOR_KEY */ ++ unsigned long ulTransparentColor; /* packed as 0x00RRGGBB */ ++ ++ ++} WSEGLConfig; ++ ++/* ++// WSEGL errors ++*/ ++typedef enum WSEGLError_TAG ++{ ++ WSEGL_SUCCESS = 0, ++ WSEGL_CANNOT_INITIALISE = 1, ++ WSEGL_BAD_NATIVE_DISPLAY = 2, ++ WSEGL_BAD_NATIVE_WINDOW = 3, ++ WSEGL_BAD_NATIVE_PIXMAP = 4, ++ WSEGL_BAD_NATIVE_ENGINE = 5, ++ WSEGL_BAD_DRAWABLE = 6, ++ WSEGL_BAD_MATCH = 7, ++ WSEGL_OUT_OF_MEMORY = 8, ++ ++ /* These are compatibility names only; new WSEGL ++ * modules should not use them. ++ */ ++ WSEGL_BAD_CONFIG = WSEGL_BAD_MATCH, ++ ++} WSEGLError; ++ ++/* ++// Drawable orientation (in degrees anti-clockwise) ++*/ ++typedef enum WSEGLRotationAngle_TAG ++{ ++ WSEGL_ROTATE_0 = 0, ++ WSEGL_ROTATE_90 = 1, ++ WSEGL_ROTATE_180 = 2, ++ WSEGL_ROTATE_270 = 3 ++ ++} WSEGLRotationAngle; ++ ++/* ++// Drawable information required by OpenGL-ES driver ++*/ ++typedef struct WSEGLDrawableParams_TAG ++{ ++ /* Width in pixels of the drawable */ ++ unsigned long ui32Width; ++ ++ /* Height in pixels of the drawable */ ++ unsigned long ui32Height; ++ ++ /* Stride in pixels of the drawable */ ++ unsigned long ui32Stride; ++ ++ /* Pixel format of the drawable */ ++ WSEGLPixelFormat ePixelFormat; ++ ++ /* User space cpu virtual address of the drawable */ ++ void *pvLinearAddress; ++ ++ /* HW address of the drawable */ ++ unsigned long ui32HWAddress; ++ ++ /* Private data for the drawable */ ++ void *hPrivateData; ++ ++ ++} WSEGLDrawableParams; ++ ++ ++/* ++// Table of function pointers that is returned by WSEGL_GetFunctionTablePointer() ++// ++// The first entry in the table is the version number of the wsegl.h header file that ++// the module has been written against, and should therefore be set to WSEGL_VERSION ++*/ ++typedef struct WSEGL_FunctionTable_TAG ++{ ++ unsigned long ui32WSEGLVersion; ++ ++ WSEGLError (*pfnWSEGL_IsDisplayValid)(NativeDisplayType); ++ ++ WSEGLError (*pfnWSEGL_InitialiseDisplay)(NativeDisplayType, WSEGLDisplayHandle *, const WSEGLCaps **, WSEGLConfig **); ++ ++ WSEGLError (*pfnWSEGL_CloseDisplay)(WSEGLDisplayHandle); ++ ++ WSEGLError (*pfnWSEGL_CreateWindowDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativeWindowType, WSEGLRotationAngle *); ++ ++ WSEGLError (*pfnWSEGL_CreatePixmapDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativePixmapType, WSEGLRotationAngle *); ++ ++ WSEGLError (*pfnWSEGL_DeleteDrawable)(WSEGLDrawableHandle); ++ ++ WSEGLError (*pfnWSEGL_SwapDrawable)(WSEGLDrawableHandle, unsigned long); ++ ++ WSEGLError (*pfnWSEGL_SwapControlInterval)(WSEGLDrawableHandle, unsigned long); ++ ++ WSEGLError (*pfnWSEGL_WaitNative)(WSEGLDrawableHandle, unsigned long); ++ ++ WSEGLError (*pfnWSEGL_CopyFromDrawable)(WSEGLDrawableHandle, NativePixmapType); ++ ++ WSEGLError (*pfnWSEGL_CopyFromPBuffer)(void *, unsigned long, unsigned long, unsigned long, WSEGLPixelFormat, NativePixmapType); ++ ++ WSEGLError (*pfnWSEGL_GetDrawableParameters)(WSEGLDrawableHandle, WSEGLDrawableParams *, WSEGLDrawableParams *); ++ ++ WSEGLError (*pfnWSEGL_ConnectDrawable)(WSEGLDrawableHandle); ++ ++ WSEGLError (*pfnWSEGL_DisconnectDrawable)(WSEGLDrawableHandle); ++ ++ ++} WSEGL_FunctionTable; ++ ++ ++WSEGL_IMPORT const WSEGL_FunctionTable *WSEGL_GetFunctionTablePointer(void); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* __WSEGL_H__ */ ++ ++/****************************************************************************** ++ End of file (wsegl.h) ++******************************************************************************/ +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 +--- qt-everywhere-opensource-src-4.6.3-orig//src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c 2010-06-02 02:03:17.000000000 +0000 ++++ qt-everywhere-opensource-src-4.6.3/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwswsegl.c 2011-05-16 23:08:51.618597097 +0000 +@@ -378,6 +378,20 @@ static WSEGLError wseglGetDrawableParame + return WSEGL_SUCCESS; + } + ++/* Function stub for ConnectDrawable() */ ++static WSEGLError wseglConnectDrawable(WSEGLDrawableHandle hDrawable) ++{ ++ WSEGL_UNREFERENCED_PARAMETER(hDrawable); ++ return WSEGL_SUCCESS; ++} ++ ++/* Function stub for DisconnectDrawable() */ ++static WSEGLError wseglDisconnectDrawable(WSEGLDrawableHandle hDrawable) ++{ ++ WSEGL_UNREFERENCED_PARAMETER(hDrawable); ++ return WSEGL_SUCCESS; ++} ++ + static WSEGL_FunctionTable const wseglFunctions = { + WSEGL_VERSION, + wseglIsDisplayValid, +@@ -391,7 +405,9 @@ static WSEGL_FunctionTable const wseglFu + wseglWaitNative, + wseglCopyFromDrawable, + wseglCopyFromPBuffer, +- wseglGetDrawableParameters ++ wseglGetDrawableParameters, ++ wseglConnectDrawable, ++ wseglDisconnectDrawable + }; + + /* Return the table of WSEGL functions to the EGL implementation */ + diff --git a/package/qt/qt.mk b/package/qt/qt.mk index 9325b56..7193150 100644 --- a/package/qt/qt.mk +++ b/package/qt/qt.mk @@ -136,7 +136,10 @@ QT_DEPENDENCIES += directfb else QT_CONFIGURE_OPTS += -no-gfx-directfb endif - +ifeq ($(BR2_PACKAGE_QT_GFX_POWERVR),y) +QT_CONFIGURE_OPTS += \ + -plugin-gfx-powervr -D QT_NO_QWS_CURSOR -D QT_QWS_CLIENTBLIT +endif ### Mouse drivers ifeq ($(BR2_PACKAGE_QT_MOUSE_PC),y) @@ -313,6 +316,13 @@ else QT_CONFIGURE_OPTS += -no-openssl endif +ifeq ($(BR2_PACKAGE_QT_OPENGL_ES),y) +QT_CONFIGURE_OPTS += -opengl es2 -egl +QT_DEPENDENCIES += libgles libegl +else +QT_CONFIGURE_OPTS += -no-opengl +endif + # Qt SQL Drivers ifeq ($(BR2_PACKAGE_QT_SQL_MODULE),y) ifeq ($(BR2_PACKAGE_QT_IBASE),y) @@ -564,6 +574,12 @@ endif ifeq ($(BR2_PACKAGE_QT_QT3SUPPORT),y) QT_INSTALL_LIBS += Qt3Support endif +ifeq ($(BR2_PACKAGE_QT_OPENGL_ES),y) +QT_INSTALL_LIBS += QtOpenGL +endif +ifeq ($(BR2_PACKAGE_QT_GFX_POWERVR),y) +QT_INSTALL_LIBS += pvrQWSWSEGL +endif QT_CONF_FILE=$(HOST_DIR)/usr/bin/qt.conf @@ -640,12 +656,22 @@ define QT_INSTALL_TARGET_FONTS_TTF endef endif +ifeq ($(BR2_PACKAGE_QT_GFX_POWERVR),y) +define QT_INSTALL_TARGET_POWERVR + # Note: this overwrites the default powervr.ini provided by the ti-gfx + # package. + $(INSTALL) -D -m 0644 package/qt/powervr.ini \ + $(TARGET_DIR)/etc/powervr.ini +endef +endif + define QT_INSTALL_TARGET_CMDS $(QT_INSTALL_TARGET_LIBS) $(QT_INSTALL_TARGET_PLUGINS) $(QT_INSTALL_TARGET_IMPORTS) $(QT_INSTALL_TARGET_FONTS) $(QT_INSTALL_TARGET_FONTS_TTF) + $(QT_INSTALL_TARGET_POWERVR) endef define QT_CLEAN_CMDS