diff options
Diffstat (limited to 'packages')
| -rw-r--r-- | packages/qte/qte-2.3.10/c7x0-w100-accel.patch | 2108 | ||||
| -rw-r--r-- | packages/qte/qte_2.3.10.bb | 2 | ||||
| -rw-r--r-- | packages/soundtracker/soundtracker-gtk2_0.6.7.bb | 0 |
3 files changed, 2109 insertions, 1 deletions
diff --git a/packages/qte/qte-2.3.10/c7x0-w100-accel.patch b/packages/qte/qte-2.3.10/c7x0-w100-accel.patch index e69de29bb2..5cff74623a 100644 --- a/packages/qte/qte-2.3.10/c7x0-w100-accel.patch +++ b/packages/qte/qte-2.3.10/c7x0-w100-accel.patch @@ -0,0 +1,2108 @@ +ATI IMAGEON (W100) Accelerated support +Manuel Teira <manuel.teira@telefonica.net> + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10/configure~w100 ++++ qt-2.3.10/configure +@@ -325,6 +325,9 @@ + -accel-matrox) + QWS_ACCEL_MATROX=y + ;; ++ -accel-w100) ++ QWS_ACCEL_W100=y ++ ;; + -qvfb) + QWS_QVFB=y + ;; +@@ -726,6 +729,10 @@ + then + QT_CXX="$QT_CXX -DQT_NO_QWS_MATROX" + fi ++if [ -z "$QWS_ACCEL_W100" -a -n "$EMB" ] ++then ++ QT_CXX="$QT_CXX -DQT_NO_QWS_W100" ++fi + if [ -z "$QWS_VNC" -a -n "$EMB" ] + then + QT_CXX="$QT_CXX -DQT_NO_QWS_VNC" +@@ -1338,6 +1345,7 @@ + -accel-voodoo3 ..... Enable Voodoo3 acceleration. + -accel-mach64 ...... Enable Mach64 acceleration. + -accel-matrox ...... Enable Matrox MGA acceleration. ++ -accel-w100 ........ Enable ATI Imageon w100 acceleration (experimental). + -qvfb .............. Enable X11-based Qt Virtual Frame Buffer. + -vnc ............... Enable VNC server (requires network module). + +@@ -1462,6 +1470,7 @@ + [ "x$JPEG" = "xyes" ] && QT_LIBS="${QT_LIBS} -ljpeg" + [ "x$MNG" = "xyes" ] && QT_LIBS="${QT_LIBS} -lmng -ljpeg" # assume JNG support + [ "x$NAS_SOUND" = "xyes" ] && QT_LIBS="${QT_LIBS} -laudio -lXt" # Xt junk in audio library ++[ "x$QWS_ACCEL_W100" = "xy" ] && QT_LIBS="${QT_LIBS} -laticore" # Aticore W100 support + QT_LIBS="$L_FLAGS $R_FLAGS $QT_LIBS $l_FLAGS" + + +--- qt-2.3.10/src/kernel/qgfxraster_qws.cpp~w100 ++++ qt-2.3.10/src/kernel/qgfxraster_qws.cpp +@@ -5945,6 +5945,10 @@ + # include "qgfxmatrox_qws.cpp" + #endif + ++#if !defined(QT_NO_QWS_W100) ++# include "qgfxw100_qws.cpp" ++#endif ++ + #if !defined(QT_NO_QWS_VFB) + # include "qgfxvfb_qws.cpp" + #endif +@@ -5999,6 +6003,9 @@ + #if !defined(QT_NO_QWS_MATROX) + { "Matrox", qt_get_screen_matrox, 1 }, + #endif ++#if !defined(QT_NO_QWS_W100) ++ { "W100", qt_get_screen_w100, 1 }, ++#endif + #if !defined(QT_NO_QWS_TRANSFORMED) + { "Transformed", qt_get_screen_transformed, 0 }, + #endif +--- /dev/null ++++ qt-2.3.10/src/3rdparty/kernel/aticore/aticore.h +@@ -0,0 +1,567 @@ ++/* ++ * AtiCore 2D acceleration API ++ * ++ */ ++ ++#include <inttypes.h> ++#include <sys/types.h> ++ ++#ifndef __W100API_H__ ++#define __W100API_H__ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define SolidRop_GXclear 0x00 /* 0 */ ++#define SolidRop_GXand 0xa0 /* src AND dst */ ++#define SolidRop_GXandReverse 0x50 /* src AND NOT dst */ ++#define SolidRop_GXcopy 0xf0 /* src */ ++#define SolidRop_GXandInverted 0x0a /* NOT src AND dst */ ++#define SolidRop_GXnoop 0xaa /* dst */ ++#define SolidRop_GXxor 0x5a /* src XOR dst */ ++#define SolidRop_GXor 0xfa /* src OR dst */ ++#define SolidRop_GXnor 0x05 /* NOT src AND NOT dst */ ++#define SolidRop_GXequiv 0xa5 /* NOT src XOR dst */ ++#define SolidRop_GXinvert 0x55 /* NOT dst */ ++#define SolidRop_GXorReverse 0xf5 /* src OR NOT dst */ ++#define SolidRop_GXcopyInverted 0x0f /* NOT src */ ++#define SolidRop_GXorInverted 0xaf /* NOT src OR dst */ ++#define SolidRop_GXnand 0x5f /* NOT src OR NOT dst */ ++#define SolidRop_GXset 0xff /* 1 */ ++ ++#define BltRop_GXclear 0x00 /* 0 */ ++#define BltRop_GXand 0x88 /* src AND dst */ ++#define BltRop_GXandReverse 0x44 /* src AND NOT dst */ ++#define BltRop_GXcopy 0xcc /* src */ ++#define BltRop_GXandInverted 0x22 /* NOT src AND dst */ ++#define BltRop_GXnoop 0xaa /* dst */ ++#define BltRop_GXxor 0x66 /* src XOR dst */ ++#define BltRop_GXor 0xee /* src OR dst */ ++#define BltRop_GXnor 0x11 /* NOT src AND NOT dst */ ++#define BltRop_GXequiv 0x99 /* NOT src XOR dst */ ++#define BltRop_GXinvert 0x55 /* NOT dst */ ++#define BltRop_GXorReverse 0xdd /* src OR NOT dst */ ++#define BltRop_GXcopyInverted 0x33 /* NOT src */ ++#define BltRop_GXorInverted 0xbb /* NOT src OR dst */ ++#define BltRop_GXnand 0x77 /* NOT src OR NOT dst */ ++#define BltRop_GXset 0xff /* 1 */ ++ ++#define DSTTYPE_8BPP 2 //8bpp ++#define DSTTYPE_16BPP_1555 3 //16 bpp aRGB 1555 ++#define DSTTYPE_16BPP_444 5 //16 bpp aRGB 4444 ++ ++#define SRCTYPE_1BPP_OPA 0 //mono (expanded to frgd, bkgd) ++#define SRCTYPE_1BPP_TRA 1 //mono (expanded to frgd, leave_alone) ++#define SRCTYPE_EQU_DST 3 //color (same as DST) ++#define SRCTYPE_SOLID_COLOR_BLT 4 //solid color for Blt (use frgd) ++#define SRCTYPE_4BPP 5 //4 bpp ++#define SRCTYPE_12BPP_PACKED 6 //12 bpp packed ++ ++#define ROP3_SRCCOPY 0xcc ++#define ROP3_PATCOPY 0xf0 ++ ++#define OVLTYPE_YUV420 7 ++#define OVLTYPE_RGB565 8 ++ ++#define DP_BRUSH_8x8MONOOPA 0 //8x8 mono pattern (expanded to frgd, bkgd ) ++#define DP_BRUSH_8x8MONOTRA 1 //8x8 mono pattern (expanded to frgd, leave alone ) ++#define DP_PEN_32x1MONOOPA 6 //32x1 mono pattern (expanded to frgd, bkgd) ++#define DP_PEN_32x1MONOTRA 7 //32x1 mono pattern (expanded to frgd, leave alone) ++#define DP_BRUSH_8x8COLOR 10 //8x8 color pattern ++#define DP_BRUSH_SOLIDCOLOR 13 //solid color pattern (frgd) ++#define DB_BRUSH_NONE 15 //No brush used ++ ++ typedef struct { ++ int16_t XCoord; ++ int16_t YCoord; ++ } ATI_POINT; ++ ++ typedef struct { ++ int16_t XCoord; ++ int16_t YCoord; ++ int16_t Width; ++ int16_t Height; ++ } ATI_RECT; ++ ++ typedef struct { ++ int16_t X_Top_Left; // x coordinate of top left corner ++ int16_t Y_Top_Left; // y coordinate of top left corner ++ int16_t X_Bottom_Right; // x coordinate of bottom right corner ++ int16_t Y_Bottom_Right; // y coordinate of bottom right corner ++ } ATI_CLIPRECT; ++ ++ typedef struct { ++ uint32_t Count; ++ uint8_t ScaleXFactor; ++ uint8_t ScaleYFactor; ++ uint8_t BlendOn; ++ uint8_t dummy1; ++ } ATI_STRETCH; ++ ++ typedef struct { ++ uint32_t *lpSrcBitmap; /* サーフェスのオフセット */ ++ uint16_t XCoord; /* +4 確定:サーフェス内のx座標 */ ++ uint16_t YCoord; /* +6 確定:サーフェス内のy座標 */ ++ uint16_t SrcPitch; /* +8 確定: */ ++ uint16_t SrcHeight; /* +10 確定: */ ++ uint16_t OverlayWidth; /* オーバレイの幅(Srcと違う値にしても、動的に拡大縮小されたりはしない、意味あんの？) */ ++ uint16_t OverlayHeight; ++ uint32_t lpOverlayKey; /* +16 確定:謎(カラーキー？) */ ++ uint8_t OverlayFormat; /* +20 確定 */ ++ uint8_t dummy1; ++ uint16_t dummy2; ++ } ATI_OVERLAYPROP; /* 24bytes? */ ++ ++ typedef struct { ++ int HInvert; ++ int VInvert; ++ } ATI_EXTVIDEOPROP; ++ ++ typedef struct { ++ ATI_EXTVIDEOPROP ExtVideoProp; ++ } ATI_UNKNOWN1; ++ ++ typedef struct { ++ unsigned long clr_cmp_fcn_src :3; ++ unsigned long :5; ++ unsigned long clr_cmp_fcn_dst :3; ++ unsigned long :13; ++ unsigned long clr_cmp_src :2; ++ unsigned long :6; ++ } clr_cmp_cntl_t; ++ ++ typedef struct { ++ uint16_t x; ++ uint16_t y; ++ uint16_t w; ++ uint16_t h; ++ clr_cmp_cntl_t cmp_cntl; ++ unsigned long tcolour; ++ } transbitblt_t; ++ ++ typedef struct { ++ uint32_t dummy1; ++ uint32_t dummy2; ++ uint8_t HExpansion; /* +8 確定 */ ++ uint8_t VExpansion; /* +9 確定 */ ++ uint8_t dummy3; ++ uint8_t dummy4; ++ uint8_t RConversion; /* +12 確定 */ ++ uint8_t dummy5; ++ uint8_t dummy6; ++ uint8_t dummy7; ++ ATI_UNKNOWN1 x; ++ } ATI_EXTENDEDOVERLAYPROP; /* 16byte? */ ++ ++ /** ++ * AtiCore initialization. ++ * Sets up the shared memory area ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_ProcessAttach( void ); ++ ++ /** ++ * AtiCore finish. ++ * ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_ProcessDetach( void ); ++ ++ /** ++ * Allocates a surface on the internal RAM. ++ * Perhaps there's a way to indicate to allocate on the ++ * internal RAM? ++ * @arg handle Reference to the returned surface handle ++ * @arg offset Returned offset of this surface on the video memory ++ * @arg size Size (bytes) to be reserved (16 multiple) ++ * @arg direction ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_AllocateSurface( uint16_t *handle, uint32_t *offset, ++ uint32_t size, uint32_t direction ); ++ ++ /** ++ * Deallocates a given surface. ++ * @arg handle Handle to the allocated surface ++ * (As returned by AllocateSurface) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_DestroySurface( uint16_t handle ); ++ ++ /** ++ * Sets the kind of Raster Operation. ++ * @param rop Raster operation to be performed ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetRopOperation( uint32_t rop ); ++ ++ /** ++ * Sets the destination type for raster operation. ++ * @param dsttype ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDstType( uint32_t dsttype ); ++ ++ /** ++ * Sets the source type for raster operation. ++ * @param srctype ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetSrcType( uint32_t srctype ); ++ ++ /** ++ * Sets Source clipping rectangle. ++ * @param cliprect Rectangle to perform clipping. ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetSrcClippingRect( ATI_CLIPRECT *cliprect ); ++ ++ /** ++ * Sets Destination clipping rectangle. ++ * @param cliprect Rectangle to perform clipping. ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDstClippingRect(ATI_CLIPRECT *cliprect); ++ ++ /** ++ * Sets pitch and offset for source in a raster operation. ++ * @param pitch Pitch (line width) of source ++ * @param offset Offset of source ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetSrcPitchOffset( int pitch, int offset ); ++ ++ /** ++ * Sets pitch and offset destination source in a raster operation. ++ * @param pitch Pitch (line width) of destination ++ * @param offset Offset of destination (memory offset) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDstPitchOffset( int pitch, int offset ); ++ ++ /** ++ * Performs a BitBlt with source rotation. ++ * @param flags Rotation degree ++ * @param dstRect Rectangle for destination Bitblitting ++ * @param srcRect Rectangle for origin bitblitting ++ * @test Tested with specified flags parameter ++ */ ++ int AtiCore_BitBltFilpRotate( int flags, ++ ATI_RECT *dstRect, ++ ATI_RECT *srcRect); ++ ++ /** ++ * Performs a BitBlt with source stretching. ++ * @param option Unknown ++ * @param point Unknown ++ * @param srcRect Source blitting surface ++ * @test Untested ++ */ ++ int AtiCore_StretchBlt( ATI_STRETCH *option, ++ ATI_POINT *point, ++ ATI_RECT *srcRect); ++ ++ /** ++ * Waits for the FIFO to be idle at least msecs. ++ * @param msecs Maximum time to wait for FIFO to idle ++ * @return 1:success, 0:fail ++ * @test Untested ++ */ ++ int AtiCore_WaitComplete( int msec ); ++ ++ /** ++ * Allocates a new overlay handle. ++ * @param handle overlay ++ * @return 1:success, 0:fail ++ * @test Yes ++ */ ++ int AtiCore_AllocOverlay( uint16_t *handle ); ++ ++ /** ++ * Deallocates a overlay handle. ++ * @param handle overlay ++ * @return 1:success, 0:fail ++ * @test Yes ++ */ ++ int AtiCore_ReleaseOverlay( uint16_t handle ); ++ ++ /** ++ * Sets up an overlay given a handle an a set of properties. ++ * @param handle Allocated handle to setup the overlay. ++ * @param props Overlay properties struct ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetupOverlay( uint16_t handle, ATI_OVERLAYPROP *props ); ++ ++ /** ++ * Sets up extended overlay features. ++ * @param handle Allocated handle to an overlay ++ * @param props Extended overlay properties ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetupOverlayExtended( uint16_t handle, ++ ATI_EXTENDEDOVERLAYPROP *props ); ++ ++ /** ++ * Enable/Disable an overlayed surface. ++ * @param handle Overlay to be enabled/disabled ++ * @param enable 1: Enable, 0: Disable ++ * @return 1:success, 0:fail ++ * @test Tested ++ */ ++ int AtiCore_SetOverlayOnOff( uint16_t handle, int enable ); ++ ++ /** ++ * Sets up the overlay position for a given handle. ++ * @param handle Overlay Handle ++ * @param x X Coordinate (Seems to be a bug with x < 4 ) ++ * @param y Y Coordinate ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetOverlayPos( uint16_t handle, ++ uint16_t x, ++ uint16_t y ); ++ ++ /** ++ * Translates between physical/virtual addresses. ++ * @param offset VRAM offset to be translated ++ * @param viraddr Virtual address for VRAM ++ * @return 1:success,0:fail ++ */ ++ int AtiCore_SetupMemoryTransfer( uint32_t offset, ++ uint32_t *viraddr ); ++ ++ /** ++ * Related with the previous one. It seems to be necesary to be called ++ * but I'm not sure of its function. ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_TerminateMemoryTransfer( void ); ++ ++ /** ++ * Returns the frontbuffer pitch and offset. ++ * @param pitch Return value for the frontbuffer pitch (width) ++ * @param offset Return value for the frontbuffer offset ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_GetFrontBufferPitchOffset( uint32_t *pitch, ++ uint32_t *offset ); ++ ++ /** ++ * Changes display brighness ? ++ * @param brightness -64...63 ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDisplayBrightness( int brightness ); ++ ++ /** ++ * Returns the amount of available internal/external memory. ++ * @param internal Pointer to return internal memory size ++ * @param external Pointer to return external memory size ++ * @return 1:success, 0:fail ++ */ ++ int GetAvailableVideoMem( uint32_t *internal, ++ uint32_t *external ); ++ ++/** ++ * ++ * ++ * ++ ++ { ++ (uint32_t) 0 ++ (uint32_t) 0 ++ (uint16_t) 480 ++ (uint16_t) 640 ++ (uint16_t) 480 ++ (uint16_t) 640 ++ (uint32_t) 5 ++ */ ++ ++ typedef struct { ++ uint32_t dummy1; ++ ATI_RECT Size; ++ uint16_t Width; ++ uint16_t Height; ++ uint32_t Flag; ++ } ATI_GRAPHICWINDOW; ++ ++ int AtiCore_SetupGraphicWindow(void* ); ++ ++ /** ++ * It seems to be necessary after AtiCore_ProcessAttach ++ * @param mode: 0xaaab for portrait, 0xaaaa for landscape ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_ProcessAttachSpecialMode( int mode ); ++ ++ /** ++ * Sets up the position of the Graphic viewport ? ++ * @param x X coordinate ++ * @param y Y coordinate ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetGraphicWindowPos( int x, int y ); ++ ++ /** ++ * Get the graphic viewport position. ++ * @param x Pointer to xcoord placeholder ++ * @param y Pointer to ycoord placeholder ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_GetGraphicWindowPos( int *x, int *y ); ++ ++ /** ++ * Sets up the frontbuffer position. ++ * @param offset VRAM offset to be used. ++ * @param x X Coordinate? ++ * @param y Y Coordinate? ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetFrontBuffer( int offset, int x, int y ); ++ ++ /** ++ * Enable/Disable the frontbuffer? ++ * @param enable 1 enables/ 0 disables ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetGraphicWindowOnOff( int enable ); ++ ++ /* ++ * Sets the foreground color. ++ * @param colour Color in 565 format (perhaps depends on the source format) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetFrgColour( int colour ); ++ ++ /* ++ * Sets the background colour. ++ * @param colour Colour in 565 format (perhaps depends on the source format) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetBkgColour( int colour ); ++ ++ /** ++ * Changes the painting brush ++ * @param btype Type of brush to use ++ * 4: Uses the pattern ++ * 6: SolidLine ++ * @param pattern Pointer to a 32 bit pattern ++ * @return 1:success, 0:fail ++ * @test Some values for btype produces a kind of antialiasing line ++ */ ++ int AtiCore_BrushType( int btype, unsigned int *pattern ); ++ ++ /** ++ * Performs a rectangle paint. ++ * @param nrects Number of rectangles to be painted ++ * @param rects Array of rectangles to be painted ++ * @return 1:success, 0:fail ++ * @test Tested with nrects==1 ++ */ ++ int AtiCore_PaintRect( int nrects , ++ ATI_RECT rects[] ); ++ ++ /** ++ * Draws a set of lines. ++ * @param npoints Number of points in the polyline set ++ * @param points Pointer to an array of ATI_POINT ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_Polyline( int npoints, ATI_POINT points[] ); ++ ++ int AtiCore_GetPitchOffsetProperty( void *, void *); ++ ++ int AtiCore_CursorOnOff( int, int ); ++ ++ /** ++ * Performs a BitBlt ROP operation. ++ * @param unk Unknown (Always set to 1) ++ * @param dstrect Bounding destination rect ++ * @param srcrect Bounding source rect ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_BitBlt( int unk, ++ ATI_RECT *dstrect, ++ ATI_RECT *srcrect ); ++ ++ /** ++ * Performs a Transparent BitBlt ROP operation. ++ * @param dstrect Transparent DstRect bitblt argument ++ * @param srcrect Transparent SrcRect bitblt argument ++ * @return 1:success, 0:fail ++ * @test Doesn't work. It sets to zero CLR_CMP_CNTL and CLR_CMP_MSK ++ */ ++ int AtiCore_TransBitBlt( transbitblt_t *dstrect, ++ transbitblt_t *srcrect ); ++ ++ int AtiCore_WakeUpCall( void ); ++ ++ /** ++ * Draws a set of pixels ++ * @param npoints Number of points to draw ++ * @param points Pointer to an array of ATI_POINT ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_DrawPixel( int npoints, ATI_POINT *points ); ++ ++ int AtiCore_SetSysClk( unsigned short in0 ); ++ int AtiCore_SetFastSysClk( unsigned short in0 ); ++ int AtiCore_SetSlowSysClk( unsigned short in0 ); ++ ++ int AtiCore_GetCursorPos( unsigned long in0, ++ unsigned short *x, ++ unsigned short *y ); ++ ++ ++ ++/* ================================================================ */ ++/* from libqte.so.2.3.2 */ ++/* ++AtiCore_AlphaBlend ++ ++AtiCore_Flush ++AtiCore_GammaCorrection ++AtiCore_GetCRC ++AtiCore_GetCursorPos ++AtiCore_GetDeviceInfo ++AtiCore_GetGPIO_Data ++AtiCore_GetGraphicExtended ++AtiCore_GetGraphicWindowPos ++AtiCore_GetLargestVideoMemBlock ++AtiCore_GetLastError ++AtiCore_GetMultiCRC ++AtiCore_GetOverlayPos ++AtiCore_Host ++AtiCore_LoadCursorBitMap ++AtiCore_PolyScanline ++AtiCore_ProcessAttachMinimal(void)? ++AtiCore_ProcessDetachMinimal(void)? ++AtiCore_ProcessDetachSpecialMode ++AtiCore_ReadCfgReg ++AtiCore_ReadMem(int, int)? ++AtiCore_ReadReg(int, int)? ++AtiCore_ScanlineShading ++AtiCore_SetApertures ++AtiCore_SetBytePixelOrder ++AtiCore_SetCursorPos ++AtiCore_SetDisplayParameters ++AtiCore_SetDriverBehaviour ++AtiCore_SetGPIO_Data ++AtiCore_SetOverlayPosUsingGraphicWindowXY ++AtiCore_SetPartialCursor ++AtiCore_SetupGraphicExtended ++AtiCore_SetupPM4 ++AtiCore_SmallText ++AtiCore_SubmitPM4Packet ++AtiCore_WriteCfgReg ++AtiCore_WriteMem ++AtiCore_WriteReg ++ */ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +--- /dev/null ++++ qt-2.3.10/src/kernel/qgfxw100_qws.cpp +@@ -0,0 +1,1466 @@ ++/*************************************************************************** ++ ++** Imageon driver for qte using libAticore ++** Manuel Teira( 2005 ) ++** BUGS ++* - Enable again internal memory surfaces. ++****************************************************************************/ ++#include <unistd.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <errno.h> ++#include <string.h> ++#include <dirent.h> ++#include <fcntl.h> ++#include <sys/types.h> ++#include <sys/mman.h> ++#include <time.h> ++ ++#include <qapplication.h> ++ ++#ifndef __sparc__ ++#include <sys/io.h> ++#endif ++ ++#include "qgfxraster_qws.h" ++#include "qgfxlinuxfb_qws.h" ++#include <aticore/aticore.h> ++ ++#include <stdarg.h> ++ ++class W100Control { ++public: ++ ++ typedef enum Loglevel { ++ ERROR = 0, ++ WARNING, ++ INFO ++ }; ++ ++ typedef enum Opcodes { ++ DRAWLINE = 1, ++ DRAWPOINT, ++ DRAWPOINTS, ++ FILLRECT, ++ SCROLL, ++ BITBLT, ++ POLYLINE, ++ EOO ++ }; ++ ++ typedef struct Opcode { ++ QString str; ++ int index; ++ bool accelerated; ++ int hits; ++ int misses; ++ }; ++ ++ static Opcode lOpcodes[]; ++ ++ static QString level2str( int level ) ++ { ++ switch( level ) { ++ case ERROR: ++ return QString( "ERROR" ); ++ break; ++ case WARNING: ++ return QString( "WARNING" ); ++ break; ++ case INFO: ++ return QString( "INFO" ); ++ break; ++ default: ++ return QString( "UNKNOWN" ); ++ break; ++ } ++ } ++ ++ W100Control(): ++ m_loglevel( 0 ), ++ m_enabled( 0 ) ++ { ++ m_loglevel = 0; ++ char *var; ++ if ( var = getenv( "W100_DEBUG" ) ) { ++ if ( strtol( var, 0, 0 ) == 1 ) { ++ m_enabled = 1; ++ } ++ } ++ ++ if ( m_enabled ) { ++ if ( var = getenv( "W100_DEBUGLEVEL" ) ) { ++ if ( ( m_loglevel = strtol( var, 0, 0 ) ) < 0 ) { ++ m_loglevel = 0; ++ } ++ } ++ ++ QString path( "/mnt/card/w100/w100debug.log" ); ++ if ( var = getenv( "W100_DEBUGPATH" ) ) { ++ path = QString( var ) + "/w100debug.log"; ++ } ++ m_logfile = fopen( path.latin1(), "w" ); ++ if ( m_logfile == NULL ) m_enabled = 0; ++ } ++ ++ Opcode *opcodePtr = lOpcodes; ++ int i = 1; ++ while ( opcodePtr->index != EOO ) { ++ if ( opcodePtr->index != i ) { ++ fprintf( stderr, "Opcode list is not ordered!!\n" ); ++ abort(); ++ } ++ ++ QString varName = "W100_ACCEL_" + opcodePtr->str; ++ char *varPtr; ++ if ( ( varPtr = getenv( varName.latin1() ) ) ) { ++ if ( ( strtol( varPtr, NULL, 0 ) == 0 ) || ++ ( strcmp( varPtr, "false" ) == 0 ) ) { ++ opcodePtr->accelerated = false; ++ } ++ } ++ opcodePtr++; ++ i++; ++ } ++ } ++ ++ ~W100Control() ++ { ++ //Dump statistics about any opcode ++ Opcode *opcodePtr = lOpcodes; ++ while ( opcodePtr->index != EOO ) { ++ log( WARNING, "Opcode %s. Accelerated=%s. Hits=%d. Misses=%d", ++ opcodePtr->str.latin1(), ++ opcodePtr->accelerated ? "true" : "false", ++ opcodePtr->hits, ++ opcodePtr->misses ); ++ opcodePtr++; ++ } ++ if ( m_enabled && m_logfile ) { ++ fclose( m_logfile ); ++ } ++ } ++ ++ bool accelerated( int opcode ) ++ { ++ if ( opcode < EOO ) { ++ return lOpcodes[opcode].accelerated; ++ } ++ return false; ++ } ++ ++ void addHit( int opcode ) ++ { ++ lOpcodes[opcode].hits++; ++ ( *lastop ) = opcode; ++ } ++ ++ int lastOp( void ) const ++ { ++ return ( *lastop ); ++ } ++ ++ void addMiss( int opcode ) ++ { ++ lOpcodes[opcode].misses++; ++ } ++ ++ void log( int level, const char *fmt, ... ) ++ { ++ if ( m_enabled && ( level <= m_loglevel ) ) { ++ char buffer[1024]; ++ va_list ap; ++ va_start( ap, fmt ); ++ vsnprintf( buffer, 1023, fmt, ap ); ++ va_end( ap ); ++ fprintf( m_logfile, "%d:%s:%s\n", getpid(), ++ level2str( level ).latin1(), ++ buffer ); ++ } ++ } ++ ++private: ++ FILE *m_logfile; ++ int m_loglevel; ++ bool m_enabled; ++}; ++ ++W100Control::Opcode W100Control::lOpcodes[] = { ++ { "DRAWLINE", W100Control::DRAWLINE, true, 0, 0 }, ++ { "DRAWPOINT", W100Control::DRAWPOINT, true, 0, 0 }, ++ { "DRAWPOINTS", W100Control::DRAWPOINTS, true, 0, 0 }, ++ { "FILLRECT", W100Control::FILLRECT, true, 0, 0 }, ++ { "SCROLL", W100Control::SCROLL, true, 0, 0 }, ++ { "BITBLT", W100Control::BITBLT, true, 0, 0 }, ++ { "POLYLINE", W100Control::POLYLINE, true, 0, 0 }, ++ { "" , W100Control::EOO, false, 0, 0 } ++}; ++ ++W100Control control; ++ ++static int W100_ProcessAttach( void ) ++{ ++ return( AtiCore_ProcessAttach() ); ++} ++ ++static int W100_ProcessDetach( void ) ++{ ++ return( AtiCore_ProcessDetach() ); ++} ++ ++static int W100_AllocateSurface( uint16_t *handle, uint32_t *offset, ++ uint32_t size, uint32_t direction ) ++{ ++ int retcode = AtiCore_AllocateSurface( handle, offset, size, direction ); ++ return( retcode ); ++} ++ ++static int W100_DestroySurface( uint16_t handle ) ++{ ++ int retcode = AtiCore_DestroySurface( handle ); ++ return( retcode ); ++} ++ ++static int W100_DrawPixel( int npoints, ATI_POINT *points ) ++{ ++ return( AtiCore_DrawPixel( npoints, points ) ); ++} ++ ++static int W100_SetRopOperation( uint32_t rop ) ++{ ++ return( AtiCore_SetRopOperation( rop ) ); ++} ++ ++static int W100_SetDstType( uint32_t dtype ) ++{ ++ return( AtiCore_SetDstType( dtype ) ); ++} ++ ++static int W100_SetSrcType( uint32_t stype ) ++{ ++ return( AtiCore_SetSrcType( stype ) ); ++} ++ ++static int W100_SetSrcClippingRect( ATI_CLIPRECT *cliprect ) ++{ ++ return( AtiCore_SetSrcClippingRect( cliprect ) ); ++} ++ ++ ++static int W100_SetDstClippingRect( ATI_CLIPRECT *cliprect ) ++{ ++ return( AtiCore_SetDstClippingRect( cliprect ) ); ++} ++ ++static int W100_SetSrcPitchOffset( int pitch, int offset ) ++{ ++ return( AtiCore_SetSrcPitchOffset( pitch, offset ) ); ++} ++ ++static int W100_SetDstPitchOffset( int pitch, int offset ) ++{ ++ return( AtiCore_SetDstPitchOffset( pitch, offset ) ); ++} ++ ++static int W100_BitBltFilpRotate( int flags, ++ ATI_RECT *dstRect, ++ ATI_RECT *srcRect ) ++{ ++ return( AtiCore_BitBltFilpRotate( flags, dstRect, srcRect ) ); ++} ++ ++static int W100_StretchBlt( ATI_STRETCH *option, ++ ATI_POINT *point, ++ ATI_RECT *srcRect ) ++{ ++ return( AtiCore_StretchBlt( option, point, srcRect ) ); ++} ++ ++static int W100_WaitComplete( int msec ) ++{ ++ return( AtiCore_WaitComplete( msec ) ); ++} ++ ++static int W100_AllocOverlay( uint16_t *handle ) ++{ ++ return( AtiCore_AllocOverlay( handle ) ); ++} ++ ++static int W100_ReleaseOverlay( uint16_t handle ) ++{ ++ return( AtiCore_ReleaseOverlay( handle ) ); ++} ++ ++static int W100_SetupOverlay( uint16_t handle, ATI_OVERLAYPROP *prop ) ++{ ++ return( AtiCore_SetupOverlay( handle, prop ) ); ++} ++ ++static int W100_SetupOverlayExtended( uint16_t handle, ATI_EXTENDEDOVERLAYPROP *prop ) ++{ ++ return( AtiCore_SetupOverlayExtended( handle, prop ) ); ++} ++ ++static int W100_SetOverlayOnOff( uint16_t handle, int isShow ) ++{ ++ return( AtiCore_SetOverlayOnOff( handle, isShow ) ); ++} ++ ++static int W100_SetOverlayPos( uint16_t handle, uint16_t x, uint16_t y ) ++{ ++ return( AtiCore_SetOverlayPos( handle, x, y ) ); ++} ++ ++static int W100_SetupMemoryTransfer( uint32_t offset, uint32_t *regdata ) ++{ ++ return( AtiCore_SetupMemoryTransfer( offset, regdata ) ); ++} ++ ++static int W100_TerminateMemoryTransfer( void ) ++{ ++ return( AtiCore_TerminateMemoryTransfer() ); ++} ++ ++static int W100_GetFrontBufferPitchOffset( uint32_t *pitch, uint32_t *offset ) ++{ ++ return( AtiCore_GetFrontBufferPitchOffset( pitch, offset ) ); ++} ++ ++static int W100_SetDisplayBrightness( int bri ) ++{ ++ return( AtiCore_SetDisplayBrightness( bri ) ); ++} ++ ++static int W100_GetAvailableVideoMem( uint32_t *internal, uint32_t *external ) ++{ ++ return( GetAvailableVideoMem( internal, external ) ); ++} ++ ++static int W100_SetupGraphicWindow( ATI_GRAPHICWINDOW *win ) ++{ ++ return( AtiCore_SetupGraphicWindow( ( void * ) win ) ); ++} ++ ++static int W100_ProcessAttachSpecialMode( int mode ) ++{ ++ return( AtiCore_ProcessAttachSpecialMode( mode ) ); ++} ++ ++static int W100_SetGraphicWindowPos( int x, int y ) ++{ ++ return( AtiCore_SetGraphicWindowPos( x, y ) ); ++} ++ ++static int W100_SetFrontBuffer( int offset, int a, int b ) ++{ ++ return( AtiCore_SetFrontBuffer( offset, a, b ) ); ++} ++ ++static int W100_SetGraphicWindowOnOff( int val ) ++{ ++ return( AtiCore_SetGraphicWindowOnOff( val ) ); ++} ++ ++static unsigned long ccolor( unsigned int rgb ) ++{ ++ unsigned char r = ( rgb & 0xff0000 ) >> 19; ++ unsigned char g = ( rgb & 0xff00 ) >> 10; ++ unsigned char b = ( rgb & 0xff ) >> 3; ++ return ( ( ( ( unsigned short )0x1f & r ) << 11 ) | ++ ( ( ( unsigned short )0x3f & g ) << 5 ) | ++ ( ( ( unsigned short )0x1f & b ) ) ); ++} ++ ++static int W100_SetFrgColour( int val ) ++{ ++ return( AtiCore_SetFrgColour( ccolor( val ) ) ); ++} ++ ++static int W100_BrushType( int type, unsigned int pattern ) ++{ ++ return( AtiCore_BrushType( type, &pattern ) ); ++} ++ ++static int W100_PaintRect( int flags, ATI_RECT *rect ) ++{ ++ return( AtiCore_PaintRect( flags, rect ) ); ++} ++ ++static int W100_Polyline( int npoints, ATI_POINT *points ) ++{ ++ return( AtiCore_Polyline( npoints, points ) ); ++} ++ ++static int W100_GetPitchOffsetProperty( void *pitch, void *offset ) ++{ ++ return( AtiCore_GetPitchOffsetProperty( pitch, offset ) ); ++} ++ ++static int W100_CursorOnOff( int a, int b ) ++{ ++ return( AtiCore_CursorOnOff( a, b ) ); ++} ++ ++static int W100_BitBlt( int flags, ATI_RECT *dst, ATI_RECT *src ) ++{ ++ return( AtiCore_BitBlt( flags, dst, src ) ); ++} ++ ++static int W100_WakeUpCall( void ) ++{ ++ return( AtiCore_WakeUpCall() ); ++} ++ ++ ++template <const int depth, const int type> ++class QGfxW100 : public QGfxRaster<depth,type> { ++ ++public: ++ QGfxW100( unsigned char *b, int w, int h ); ++ virtual void drawLine( int, int, int, int); ++ virtual void fillRect( int, int, int, int); ++ virtual void blt( int, int, int, int, int, int ); ++ virtual void sync(); ++ virtual void setOffset( int x, int y ); ++ virtual void setPen( const QPen & p ); ++ ++ virtual void drawPolyline( const QPointArray &, int, int ); ++ virtual void drawPolygon( const QPointArray &, bool, int, int ); ++ virtual void drawPoint( int, int ); ++ virtual void drawPoints( const QPointArray &, int, int ); ++ virtual void scroll( int, int, int, int, int, int ); ++ ++ ++private: ++ bool checkDest( bool setsrc = false ); ++ bool checkSourceDest(); ++}; ++ ++template<const int depth,const int type> ++QGfxW100<depth,type>::QGfxW100( unsigned char * b, int w, int h ) ++ : QGfxRaster<depth,type>(b, w, h) ++{ ++} ++ ++ ++template<const int depth,const int type> ++inline void QGfxW100<depth,type>::setOffset( int x, int y ) ++{ ++ QGfxRaster<depth,type>::setOffset( x, y ); ++} ++ ++static QString penStyleStr( const QPen &pen ) ++{ ++ QString res; ++ switch( pen.style() ) { ++ case Qt::NoPen: ++ res = "NoPen"; ++ break; ++ case Qt::SolidLine: ++ res = "SolidLine"; ++ break; ++ case Qt::DashLine: ++ res = "DashLine"; ++ break; ++ case Qt::DotLine: ++ res = "DotLine"; ++ break; ++ case Qt::DashDotLine: ++ res = "DashDotLine"; ++ break; ++ case Qt::DashDotDotLine: ++ res = "DashDotDotLine"; ++ break; ++ default: ++ res = "Unknown"; ++ } ++ return res; ++} ++ ++template<const int depth, const int type> ++inline void QGfxW100<depth,type>::setPen( const QPen &p ) ++{ ++ QGfxRaster<depth,type>::setPen( p ); ++} ++ ++template<const int depth,const int type> ++inline bool QGfxW100<depth,type>::checkSourceDest() ++{ ++ if ( !checkDest() ) { ++ return FALSE; ++ } ++ ++ int sourcepixelpitch; ++ ulong src_buffer_offset; ++ if ( this->srctype == this->SourcePen ) { ++ src_buffer_offset = -1; ++ return FALSE; ++ } else { ++ if ( !qt_screen->onCard( this->srcbits, src_buffer_offset ) ) { ++ return FALSE; ++ } ++ sourcepixelpitch = ( this->srclinestep * 8 ) / this->srcdepth; ++ W100_SetSrcPitchOffset( sourcepixelpitch, ++ src_buffer_offset ); ++ } ++ return TRUE; ++} ++ ++template< const int depth, const int type> ++inline bool QGfxW100<depth, type>::checkDest( bool setsrc ) ++{ ++ //Main framebuffer should be registered as a hardware surface ++ ulong buffer_offset; ++ if ( !qt_screen->onCard( this->buffer, buffer_offset ) ) { ++ return FALSE; ++ } ++ int pixelstep = ( this->linestep() * 8 ) / depth; ++ W100_SetDstPitchOffset( pixelstep, buffer_offset ); ++ if ( setsrc ) { ++ W100_SetSrcPitchOffset( pixelstep, buffer_offset ); ++ } ++ return TRUE; ++} ++ ++template<const int depth,const int type> ++void QGfxW100<depth,type>::drawLine( int x1, int y1, int x2, int y2 ) ++{ ++ // No point going any further if the window isn't visible ++ if( this->ncliprect < 1 ) { ++ return; ++ } ++ ++ if ( !control.accelerated( W100Control::DRAWLINE ) ) { ++ control.addMiss( W100Control::DRAWLINE ); ++ QGfxRaster<depth,type>::drawLine( x1, y1, x2, y2 ); ++ return; ++ } ++ ++ // Only handle 'normal' lines ++ if ( ( this->cpen.style() != this->SolidLine ) || ++ ( this->myrop != this->CopyROP ) || ++ ( this->cpen.width() > 1 ) || ++ ( this->dashedLines ) ) { ++ control.addMiss( W100Control::DRAWLINE ); ++ QGfxRaster<depth,type>::drawLine(x1,y1,x2,y2); ++ return; ++ } ++ ++ // Stop anyone else trying to access optype/lastop/the graphics engine ++ // to avoid synchronization problems with other processes ++ QWSDisplay::grab( TRUE ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ control.addMiss( W100Control::DRAWLINE ); ++ QGfxRaster<depth,type>::drawLine( x1, y1, x2, y2); ++ return; ++ } ++ ++ // Note that the last operation used the 2d engine ++ ( *optype ) = 1; ++ ++ ++ ++ // Add the offset of the gfx - used to make the origin the right ++ // place for windows ++ x1 = x1 + this->xoffs; ++ y1 = y1 + this->yoffs; ++ x2 = x2 + this->xoffs; ++ y2 = y2 + this->yoffs; ++ ++ // Only cope with lines going from left to right ++ // - swap them round if this isn't TRUE ++ if ( x1 > x2 ) { ++ int x3 = x2; ++ int y3 = y2; ++ x2 = x1; ++ y2 = y1; ++ x1 = x3; ++ y1 = y3; ++ } ++ ++ GFX_START( QRect( x1, ++ y1 < y2 ? y1 : y2, ++ ( x2 - x1 + 1 ), ++ QABS( y2 - y1 ) + 1 ) ); ++ ++ // The clip region is defined as a series of rectangles ++ // We repeatedly set up the hardware clip rectangle to one of ++ // these rectangles and re-draw the line - an alternative approach ++ // would be to clip to the rectangle in software ++ ++ ++ ++ /* ++ * Just a dirty hack. Comment it out for now ++ if ( this->dashedLines ) { ++ W100_BrushType( 4, 0xaaaaaaaa ); ++ } else { ++ W100_BrushType( 6, 0 ); ++ } ++ switch( this->cpen.style() ) { ++ case Qt::NoPen: ++ //W100DEBUG( "Using pen style NoPen" ); ++ break; ++ case Qt::SolidLine: ++ //W100DEBUG( "Using pen style SolidLine" ); ++ break; ++ case Qt::DashLine: ++ //W100DEBUG( "Using pen style DashLine" ); ++ break; ++ case Qt::DotLine: ++ //W100DEBUG( "Using pen style DotLine" ); ++ break; ++ case Qt::DashDotLine: ++ //W100DEBUG( "Using pen style DashDotLine" ); ++ break; ++ case Qt::DashDotDotLine: ++ //W100DEBUG( "Using pen style DashDotDotLine" ); ++ break; ++ default: ++ //W100DEBUG( "Using unknown type of pen" ); ++ } ++ */ ++ ++ //if ( control.lastOp() != W100Control::DRAWLINE && ++ //control.lastOp() != W100Control::POLYLINE ) { ++ W100_SetDstType( DSTTYPE_16BPP_1555 ); ++ W100_SetSrcType( SRCTYPE_EQU_DST ); ++ W100_SetRopOperation( ROP3_PATCOPY ); ++ W100_BrushType( 6, 0 ); ++ //} ++ W100_SetFrgColour( this->cpen.color().rgb() ); ++ control.addHit( W100Control::DRAWLINE ); ++ ++ //The imageon seems not to write on the edge of the clip ++ //for the polyline op. ++ //We are using a three points array repeating the last point ++ //to get the last single point painted. ++ ATI_POINT points[3]; ++ points[0].XCoord = x1; ++ points[0].YCoord = y1; ++ points[1].XCoord = x2; ++ points[1].YCoord = y2; ++ points[2].XCoord = x2; ++ points[2].YCoord = y2; ++ for ( int loopc = 0 ; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ W100_SetDstClippingRect( &clip ); ++ ++ W100_Polyline( 3, points ); ++ } ++ ++ // Software mouse cursor stuff ++ GFX_END; ++ ++ // Release display again - not doing so will cause Qt/Embedded applications ++ // to deadlock ++ QWSDisplay::ungrab(); ++ ++} ++ ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPolyline( const QPointArray &a, ++ int index, ++ int npoints ) ++{ ++ ++ if ( ( this->ncliprect < 1 ) || ( npoints < 1 ) ) { ++ return; ++ } ++ ++ if ( !control.accelerated( W100Control::POLYLINE ) ) { ++ control.addMiss( W100Control::POLYLINE ); ++ QGfxRaster<depth,type>::drawPolyline( a, index, npoints ); ++ return; ++ } ++ ++ if ( this->cpen.style() != this->SolidLine || ++ this->myrop != this->CopyROP ) { ++ control.addMiss( W100Control::POLYLINE ); ++ QGfxRaster<depth,type>::drawPolyline( a, index, npoints ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ control.addMiss( W100Control::POLYLINE ); ++ QGfxRaster<depth,type>::drawPolyline( a, index, npoints ); ++ return; ++ } ++ ++ ( *optype ) = 1; ++ ++ //if ( control.lastOp() != W100Control::POLYLINE && ++ //control.lastOp() != W100Control::DRAWLINE ) { ++ ++ W100_SetDstType( DSTTYPE_16BPP_1555 ); ++ W100_SetSrcType( SRCTYPE_EQU_DST ); ++ W100_SetRopOperation( ROP3_PATCOPY ); ++ W100_BrushType( 6, 0 ); ++ ++ //} ++ ++ W100_SetFrgColour( this->cpen.color().rgb() ); ++ ++ control.addHit( W100Control::POLYLINE ); ++ ++ ATI_POINT *points = new ATI_POINT[ npoints + 1 ]; ++ ++ for ( int i = 0; i < npoints; i++ ) { ++ points[i].XCoord = a[ i + index ].x() + this->xoffs; ++ points[i].YCoord = a[ i + index ].y() + this->yoffs; ++ } ++ //Hack to get the last point of the last line painted ++ points[ npoints ] = points[ npoints - 1 ]; ++ ++ ++ GFX_START( clipbounds ); ++ W100_SetFrgColour( this->cpen.color().rgb() ); ++ W100_SetRopOperation( ROP3_PATCOPY ); ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ W100_SetDstClippingRect( &clip ); ++ W100_Polyline( npoints + 1, points ); ++ } ++ GFX_END; ++ ++ delete [] points; ++ ++ QWSDisplay::ungrab(); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPolygon( const QPointArray &a, bool b, int c, int d ) ++{ ++ QGfxRaster<depth,type>::drawPolygon( a, b, c, d ); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPoint( int a, int b ) ++{ ++ ++ if ( this->ncliprect < 1 ) { ++ //W100DEBUG( "ncliprect=%d", this->ncliprect ); ++ return; ++ } ++ ++ if ( !control.accelerated( W100Control::DRAWPOINT) ) { ++ control.addMiss( W100Control::DRAWPOINT ); ++ QGfxRaster<depth,type>::drawPoint( a, b ); ++ return; ++ } ++ ++ if ( this->cpen.style() != this->SolidLine || ++ this->myrop != this->CopyROP ) { ++ control.addMiss( W100Control::DRAWPOINT ); ++ QGfxRaster<depth,type>::drawPoint( a, b ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ control.addMiss( W100Control::DRAWPOINT ); ++ QGfxRaster<depth,type>::drawPoint( a, b ); ++ return; ++ } ++ ++ control.addHit( W100Control::DRAWPOINT ); ++ ( *optype ) = 1; ++ ++ ATI_POINT point; ++ point.XCoord = a + this->xoffs; ++ point.YCoord = b + this->yoffs; ++ ++ GFX_START( clipbounds ); ++ W100_SetFrgColour( this->cpen.color().rgb() ); ++ W100_SetRopOperation( ROP3_PATCOPY ); ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ W100_SetDstClippingRect( &clip ); ++ W100_DrawPixel( 1, &point ); ++ } ++ GFX_END; ++ QWSDisplay::ungrab(); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPoints( const QPointArray &a, ++ int index, ++ int npoints ) ++{ ++ if ( ( this->ncliprect < 1 ) || ( npoints < 1 ) ) { ++ return; ++ } ++ ++ if ( !control.accelerated( W100Control::DRAWPOINTS ) ) { ++ control.addMiss( W100Control::DRAWPOINTS ); ++ QGfxRaster<depth,type>::drawPoints( a, index, npoints ); ++ return; ++ } ++ ++ if ( this->cpen.style() != this->SolidLine || ++ this->myrop != this->CopyROP ) { ++ control.addMiss( W100Control::DRAWPOINTS ); ++ QGfxRaster<depth,type>::drawPoints( a, index, npoints ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ control.addMiss( W100Control::DRAWPOINTS ); ++ QGfxRaster<depth,type>::drawPoints( a, index, npoints ); ++ return; ++ } ++ ++ control.addHit( W100Control::DRAWPOINTS ); ++ ( *optype ) = 1; ++ ++ ATI_POINT *points = new ATI_POINT[ npoints ]; ++ for ( int i = 0; i < npoints; i++ ) { ++ points[i].XCoord = a[ i + index ].x() + this->xoffs; ++ points[i].YCoord = a[ i + index ].y() + this->yoffs; ++ } ++ ++ GFX_START( clipbounds ); ++ W100_SetFrgColour( this->cpen.color().rgb() ); ++ W100_SetRopOperation( ROP3_PATCOPY ); ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ W100_SetDstClippingRect( &clip ); ++ W100_DrawPixel( npoints, points ); ++ } ++ GFX_END; ++ ++ delete [] points; ++ QWSDisplay::ungrab(); ++} ++ ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::scroll( int rx, int ry, ++ int w, int h, ++ int sx, int sy ) ++{ ++ if ( !control.accelerated( W100Control::SCROLL ) ) { ++ control.addMiss( W100Control::SCROLL ); ++ QGfxRaster<depth,type>::scroll( rx, ry, w, h, sx, sy ); ++ return; ++ } ++ ++ if ( this->ncliprect < 1 ) return; ++ ++ if ( ( w < 1 ) || ( h < 1 ) ) return; ++ ++ int dy = sy - ry; ++ int dx = sx - rx; ++ ++ if ( dx == 0 && dy == 0 ) return; ++ ++ ++ QWSDisplay::grab( TRUE ); ++ ++ if ( checkDest( true ) ) { ++ ++ ++ rx += this->xoffs; ++ sx += this->xoffs; ++ ry += this->yoffs; ++ sy += this->yoffs; ++ ++ GFX_START( QRect( QMIN( rx , sx ), ++ QMIN( ry , sy ), ++ w + QABS( dx ) + 1, ++ h + QABS( dy ) + 1 ) ); ++ ( *optype ) = 1; ++ ++ ++ //if ( control.lastOp() != W100Control::SCROLL ) { ++ W100_SetRopOperation( ROP3_SRCCOPY ); ++ W100_SetDstType( DSTTYPE_16BPP_1555 ); ++ W100_SetSrcType( SRCTYPE_EQU_DST ); ++ //} ++ ++ control.addHit( W100Control::SCROLL ); ++ ++ ATI_RECT srcrect, dstrect; ++ ++ srcrect.XCoord = sx; ++ srcrect.YCoord = sy; ++ srcrect.Width = w; ++ srcrect.Height = h; ++ dstrect.XCoord = rx; ++ dstrect.YCoord = ry; ++ dstrect.Width = w; ++ dstrect.Height = h; ++ ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[ loopc ].x(); ++ clip.Y_Top_Left = this->cliprect[ loopc ].y(); ++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1; ++ W100_SetDstClippingRect( &clip ); ++ W100_BitBlt( 1, &dstrect, &srcrect ); ++ } ++ GFX_END; ++ QWSDisplay::ungrab(); ++ ++ } else { ++ QWSDisplay::ungrab(); ++ // software fallback ++ control.addMiss( W100Control::SCROLL ); ++ QGfxRaster<depth,type>::scroll( rx, ry, w, h, sx, sy ); ++ } ++} ++ ++ ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::fillRect( int rx, int ry, int w, int h ) ++{ ++ ++ if ( w <= 0 || h <= 0 || this->ncliprect < 1 ) return; ++ ++ if ( !control.accelerated( W100Control::FILLRECT ) ) { ++ control.addMiss( W100Control::FILLRECT ); ++ QGfxRaster<depth,type>::fillRect( rx, ry, w, h ); ++ return; ++ } ++ ++ if ( ( this->cbrush.style() != this->NoBrush ) && ++ ( this->cbrush.style() != this->SolidPattern ) ) { ++ control.addMiss( W100Control::FILLRECT ); ++ QGfxRaster<depth,type>::fillRect( rx, ry, w, h ); ++ return; ++ } ++ ++ if ( !checkDest() || ( this->myrop != this->CopyROP ) ) { ++ control.addMiss( W100Control::FILLRECT ); ++ QGfxRaster<depth,type>::fillRect(rx,ry,w,h); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ rx += this->xoffs; ++ ry += this->yoffs; ++ ++ GFX_START( QRect( rx, ry, w+1, h+1 ) ); ++ ++ ( *optype ) = 1; ++ control.log( W100Control::INFO, "QGfxW100::fillRect( +%d+%d %dx%d )", ++ rx, ry, w, h ); ++ ++ ++ //if ( control.lastOp() != W100Control::FILLRECT ) { ++ W100_SetDstType( DSTTYPE_16BPP_1555 ); ++ W100_SetSrcType( SRCTYPE_EQU_DST ); ++ W100_SetRopOperation( ROP3_PATCOPY ); ++ W100_BrushType( 6, 0 ); ++ //} ++ W100_SetFrgColour( this->cbrush.color().rgb() ); ++ ++ control.addHit( W100Control::FILLRECT ); ++ ++ if ( this->cbrush.style() != this->NoBrush ) { ++ //Using all the cliprects ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ ATI_RECT rect; ++ ++ clip.X_Top_Left = this->cliprect[ loopc ].x(); ++ clip.Y_Top_Left = this->cliprect[ loopc ].y(); ++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1; ++ ++ W100_SetDstClippingRect( &clip ); ++ rect.XCoord = rx; ++ rect.YCoord = ry; ++ rect.Width = w; ++ rect.Height = h; ++ W100_PaintRect( 1, &rect ); ++ } ++ } ++ GFX_END; ++ ++ QWSDisplay::ungrab(); ++} ++ ++template< const int depth, const int type > ++inline void QGfxW100< depth, type>::blt( int rx, int ry, ++ int w, int h, ++ int sx, int sy ) ++{ ++ control.log( W100Control::INFO, "QGfxW100::blt( +%d+%d %dx%d )", ++ rx, ry, w, h ); ++ if ( !w || !h || this->ncliprect < 1 ) { ++ return; ++ } ++ ++ if ( !control.accelerated( W100Control::BITBLT ) ) { ++ control.addMiss( W100Control::BITBLT ); ++ QGfxRaster<depth,type>::blt(rx,ry,w,h,sx,sy); ++ return; ++ } ++ ++ if ( this->alphatype == this->BigEndianMask || ++ this->alphatype == this->LittleEndianMask || ++ this->alphatype == this->SeparateAlpha || ++ this->srctype == this->SourcePen || ++ ( this->myrop != this->CopyROP ) ) { ++ control.addMiss( W100Control::BITBLT ); ++ QGfxRaster<depth,type>::blt(rx,ry,w,h,sx,sy); ++ return; ++ } ++ ++ if( ( this->srcdepth != 16 ) || this->alphatype != this->IgnoreAlpha ) { ++ control.addMiss( W100Control::BITBLT ); ++ QGfxRaster<depth,type>::blt(rx,ry,w,h,sx,sy); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ ++ if( checkSourceDest() ) { ++ GFX_START( QRect( rx + xoffs, ry + yoffs , w+1, h+1 ) ); ++ ( *optype ) = 1; ++ ++ //if ( control.lastOp() != W100Control::BITBLT ) { ++ W100_SetRopOperation( ROP3_SRCCOPY ); ++ W100_SetDstType( DSTTYPE_16BPP_1555 ); ++ W100_SetSrcType( SRCTYPE_EQU_DST ); ++ //} ++ ++ control.addHit( W100Control::BITBLT ); ++ ++ ATI_RECT rect1; ++ ATI_RECT rect2; ++ ++ rect1.XCoord = this->srcwidgetoffs.x() + sx; ++ rect1.YCoord = this->srcwidgetoffs.y() + sy; ++ rect1.Width = w; ++ rect1.Height = h; ++ rect2.XCoord = this->xoffs + rx; ++ rect2.YCoord = this->yoffs + ry; ++ rect2.Width = w; ++ rect2.Height = h; ++ for(int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[ loopc ].x(); ++ clip.Y_Top_Left = this->cliprect[ loopc ].y(); ++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1; ++ W100_SetDstClippingRect( &clip ); ++ W100_BitBlt( 1, &rect2, &rect1 ); ++ } ++ GFX_END; ++ ++ QWSDisplay::ungrab(); ++ return; ++ } else { ++ QWSDisplay::ungrab(); ++ // software fallback ++ control.addMiss( W100Control::BITBLT ); ++ QGfxRaster<depth,type>::blt( rx, ry, w, h, sx, sy ); ++ } ++} ++ ++ ++template<const int depth,const int type> ++void QGfxW100<depth,type>::sync() ++{ ++ W100_WaitComplete( -1 ); ++} ++ ++class QW100Screen : public QLinuxFbScreen { ++ ++public: ++ class HWSurface { ++ public: ++ HWSurface( void ): ++ m_handle( 0 ), ++ m_offset( 0 ), ++ m_addr( 0 ), ++ m_size( 0 ), ++ m_internal( false ), ++ m_clientid( -1 ) {}; ++ HWSurface( unsigned short handle, ++ uint32_t sOffset, ++ unsigned char *localAddr, ++ int amount, ++ bool internal, ++ int clientid ): ++ m_handle( handle ), ++ m_offset( sOffset ), ++ m_addr( localAddr ), ++ m_size( amount ), ++ m_internal( internal ), ++ m_clientid( clientid ) {}; ++ HWSurface( uint32_t sOffset, ++ unsigned char *localAddr, ++ bool internal, ++ int amount ): ++ m_handle( 0 ), ++ m_offset( sOffset ), ++ m_addr( localAddr ), ++ m_size( amount ), ++ m_internal( internal ), ++ m_clientid( -1 ) {}; ++ bool operator!=( HWSurface &other ) { ++ return( m_offset == other.getSOffset() ); ++ }; ++ HWSurface &operator=( const HWSurface &c ) { ++ m_handle = c.getHandle(); ++ m_offset = c.getSOffset(); ++ m_addr = c.getAddr(); ++ m_size = c.getSize(); ++ m_clientid= c.getCId(); ++ m_internal = c.internal(); ++ return( *this ); ++ }; ++ unsigned short getHandle( void ) const { return m_handle; }; ++ uint32_t getSOffset( void ) const { return m_offset; }; ++ unsigned char *getAddr( void ) const { return m_addr; }; ++ unsigned int getSize( void ) const { return m_size; }; ++ int getCId( void ) const { return m_clientid; }; ++ bool internal( void ) const { return m_internal; }; ++ ++ private: ++ unsigned short m_handle; ++ uint32_t m_offset; ++ unsigned char *m_addr; ++ int m_size; ++ bool m_internal; ++ int m_clientid; ++ }; ++ ++ QW100Screen( int display_id ); ++ virtual ~QW100Screen(); ++ virtual bool connect( const QString &spec ); ++ virtual void disconnect( void ); ++ virtual bool initDevice(); ++ virtual void shutdownDevice(); ++ virtual bool useOffscreen() { return TRUE; } ++ virtual QGfx * createGfx( unsigned char *, int, int, int, int); ++ virtual uchar *cache( int amount, int optim ); ++ virtual void uncache( uchar *c ); ++ virtual bool onCard( unsigned char *p ) const; ++ virtual bool onCard( unsigned char *p, ulong& offset ) const; ++ QMap< uchar*, HWSurface > *getPSurfaceMap( void ) const; ++ void clearCache( int clientId ); ++protected: ++ static void clearCache( QScreen *instance, int clientId ); ++ QMap< uchar*, HWSurface > surfaceMap; ++ int vramoffset; ++ virtual int pixmapLinestepAlignment() { return 128; } ++}; ++ ++QW100Screen::QW100Screen( int display_id ) ++ :QLinuxFbScreen( display_id ) ++{ ++ vramoffset = ( w == 320 ) ? 0: 0x0f000000; ++ clearCacheFunc = &clearCache; ++} ++ ++bool QW100Screen::connect( const QString &displaySpec ) ++{ ++ ++ if ( QLinuxFbScreen::connect( displaySpec ) ) { ++ if ( W100_ProcessAttach() ) { ++ W100_ProcessAttachSpecialMode( ( w == 480 ) ? 0xaaab:0xaaaa ); ++ surfaceMap.insert( 0, HWSurface( vramoffset, ++ data , false, ++ w*h*d/8 ) ); ++ canaccel = TRUE; ++ return TRUE; ++ } ++ } ++ return FALSE; ++} ++ ++void QW100Screen::disconnect( void ) ++{ ++ QLinuxFbScreen::disconnect(); ++ W100_ProcessDetach(); ++} ++ ++QW100Screen::~QW100Screen() ++{ ++} ++ ++bool QW100Screen::initDevice() ++{ ++ ATI_GRAPHICWINDOW win; ++ ATI_CLIPRECT clip; ++ uint16_t overlay; ++ int ret; ++ uint32_t extm, intm; ++ W100_GetAvailableVideoMem( &intm, &extm ); ++ ret = W100_CursorOnOff( 1, 0 ); ++ ret = W100_CursorOnOff( 2, 0 ); ++ ret = W100_CursorOnOff( 3, 0 ); ++ win.dummy1 = 0; ++ win.Size.XCoord = 0; ++ win.Size.YCoord = 0; ++ win.Size.Width = w; ++ win.Size.Height = h; ++ win.Width = w > h ? h : w; ++ win.Height = w > h ? w : h; ++ win.Flag = DSTTYPE_16BPP_444; //(5) ++ ++ ret = W100_SetupGraphicWindow( &win ); ++ if ( !ret ) { ++ return FALSE; ++ } ++ ret = W100_SetGraphicWindowPos( 0, 0 ); ++ ++ ret = W100_SetFrontBuffer( vramoffset, 0, 0 ); ++ ret = W100_SetDstPitchOffset( w, vramoffset ); ++ ret = W100_SetDstType( DSTTYPE_16BPP_444 ); ++ ret = W100_SetSrcPitchOffset( w, vramoffset ); ++ ret = W100_SetSrcType( SRCTYPE_SOLID_COLOR_BLT ); ++ clip.X_Top_Left = 0; ++ clip.Y_Top_Left = 0; ++ clip.X_Bottom_Right = w; ++ clip.Y_Bottom_Right = h; ++ ret = W100_SetDstClippingRect( &clip ); ++ ++ clip.X_Top_Left = 0xE000; ++ clip.Y_Top_Left = 0xE000; ++ clip.X_Bottom_Right = 0x1FFF; ++ clip.Y_Bottom_Right = 0x1FFF; ++ ++ ret = W100_SetSrcClippingRect( &clip ); ++ ret = W100_SetRopOperation( ROP3_SRCCOPY ); ++ ret = W100_SetGraphicWindowOnOff( 1 ); ++ ++ ret = W100_AllocOverlay( &overlay ); ++ ret = W100_SetOverlayOnOff( overlay, 0 ); ++ ret = W100_ReleaseOverlay( overlay ); ++ ret = W100_SetDstPitchOffset( w, vramoffset ); ++ ret = W100_SetDstClippingRect( NULL ); ++ ++ if ( QLinuxFbScreen::initDevice() ) { ++ //HACK ++ //Some sprite corruption seems to be avoided ++ //reserving some upper memory on the offscreen framebuffer memory ++ QLinuxFbScreen::cache( 65535 * 2, 0 ); ++ return true; ++ } ++ return false; ++} ++ ++void QW100Screen::shutdownDevice() ++{ ++ QLinuxFbScreen::shutdownDevice(); ++ W100_ProcessDetach(); ++} ++ ++QGfx *QW100Screen::createGfx( unsigned char *b, ++ int w, int h, int d, int linestep ) ++{ ++ //We need ALL the gfx created to be QGfxW100 to allow software ++ //drawing syncing after hardware operations ++ QGfx * ret=0; ++ if ( false ) { ++#ifndef QT_NO_QWS_DEPTH_1 ++ } else if ( d == 1 ) { ++ ret = new QGfxW100<1,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_4 ++ } else if ( d == 4 ) { ++ ret = new QGfxW100<4,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_8 ++ } else if ( d == 8 ) { ++ ret = new QGfxW100<8,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_16 ++ } else if ( d == 16 ) { ++ ret = new QGfxW100<16,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_24 ++ } else if ( d == 24 ) { ++ ret = new QGfxW100<24,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_32 ++ } else if ( d == 32 ) { ++ ret = new QGfxW100<32,0>( b, w, h ); ++#endif ++ } else { ++ qFatal( "Unsupported depth %d\n", d ); ++ ret = 0; ++ } ++ ++ ret->setLineStep( linestep ); ++ return ret; ++} ++ ++static int sinternal = 0; ++static int sexternal = 0; ++ ++uchar *QW100Screen::cache( int amount, int optim ) ++{ ++ unsigned short hSurface = 0; ++ uint32_t surfaceOffset = 0; ++ uchar* localAddr = 0; ++ bool internal = false; ++ ++ /* The size must have 0xF bit zeroed (16 multiple)*/ ++ /* Perhaps this is not needed anymore, after setting ++ * QW100Screen::pixmapLinestepAlignment to 128 ++ */ ++ amount = ( amount & 0x0F ) ? ( amount | 0x10 ) & ~0x0F : amount; ++ ++ /* Experimenting memory corruption with the ++ * internal AtiCore memory allocation routines ++ * disabled for now ++ */ ++#if 1 ++ if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) { ++ return( 0 ); ++ } ++ surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t )data; ++ ++#else ++ int retcode = 0; ++ qt_fbdpy->grab(); ++ retcode = W100_AllocateSurface( &hSurface, ++ &surfaceOffset, ++ amount, 1 ); ++ qt_fbdpy->ungrab(); ++ if ( retcode ) { ++ internal = true; ++ W100_SetupMemoryTransfer( surfaceOffset, (uint32_t*) &localAddr ); ++ W100_TerminateMemoryTransfer(); ++ } else { ++ // Try to use the offscreen framebuffer memory ++ // to allocate the surface. Use the qgfxlinuxfb routines ++ if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) { ++ return( 0 ); ++ } ++ //Distance between physical vram start and surface should be ++ //the same than distance between logical addresses ++ surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t ) data; ++ } ++#endif ++ ++ HWSurface surface( hSurface, surfaceOffset, ++ localAddr, amount, ++ internal, ++ qws_client_id ); ++#if 0 ++ if ( internal ) { ++ sinternal++; ++ } else { ++ sexternal++; ++ } ++#endif ++ surfaceMap.insert( surface.getAddr(), surface ); ++ return( ( uchar* ) localAddr ); ++} ++ ++void QW100Screen::uncache( uchar *c ) ++{ ++ QMap< uchar*, HWSurface >::Iterator itr; ++ if ( ( itr = surfaceMap.find( c ) ) != surfaceMap.end() ) { ++ if ( itr.data().internal() ) { ++ qt_fbdpy->grab(); ++ W100_DestroySurface( itr.data().getHandle() ); ++ qt_fbdpy->ungrab(); ++ --sinternal; ++ } else { ++ --sexternal; ++ QLinuxFbScreen::uncache( c ); ++ } ++ surfaceMap.remove( itr ); ++ } ++} ++ ++bool QW100Screen::onCard( uchar *p ) const ++{ ++ QMap< uchar*, HWSurface >::ConstIterator itr = surfaceMap.begin(); ++ for ( ; itr != surfaceMap.end(); itr++ ) { ++ uchar *begin; ++ if ( ( begin = itr.data().getAddr() ) <= p ) { ++ if ( ( itr.data().getSize() + begin ) >= p ) { ++ return TRUE; ++ } ++ } ++ } ++ return FALSE; ++} ++ ++bool QW100Screen::onCard( unsigned char *p, ulong& offset ) const ++{ ++ QMap< uchar*, HWSurface >::ConstIterator itr; ++ for ( itr = surfaceMap.begin(); itr != surfaceMap.end(); itr++ ) { ++ uchar *begin; ++ if ( ( begin = itr.data().getAddr() ) <= p ) { ++ if ( ( itr.data().getSize() + begin ) >= p ) { ++ offset = itr.data().getSOffset() + ( p - begin ); ++ return TRUE; ++ } ++ } ++ } ++ return FALSE; ++} ++ ++QMap< uchar*, QW100Screen::HWSurface > ++*QW100Screen::getPSurfaceMap( void ) const ++{ ++ return ( QMap<uchar*,HWSurface> *) &surfaceMap; ++} ++ ++void QW100Screen::clearCache( int clientId ) ++{ ++ QMap< uchar*, HWSurface >::Iterator itr = surfaceMap.begin(); ++ while ( itr != surfaceMap.end() ) { ++ if ( itr.data().getCId() == clientId ) { ++ if ( itr.data().internal() ) { ++ qt_fbdpy->grab(); ++ W100_DestroySurface( itr.data().getHandle() ); ++ qt_fbdpy->ungrab(); ++ --sinternal; ++ } else { ++ QLinuxFbScreen::uncache( itr.data().getAddr() ); ++ --sexternal; ++ } ++ surfaceMap.remove( itr ); ++ } ++ itr++; ++ } ++} ++ ++void QW100Screen::clearCache( QScreen *instance, int clientId ) ++{ ++ QW100Screen *screen = ( QW100Screen * )instance; ++ screen->clearCache( clientId ); ++} ++ ++extern bool qws_accel; ++ ++extern "C" QScreen * qt_get_screen_w100( int display_id ) ++{ ++ return( new QW100Screen( display_id ) ); ++} diff --git a/packages/qte/qte_2.3.10.bb b/packages/qte/qte_2.3.10.bb index fb0df5c28d..f21662f55f 100644 --- a/packages/qte/qte_2.3.10.bb +++ b/packages/qte/qte_2.3.10.bb @@ -7,7 +7,7 @@ DEPENDS = "zlib libpng jpeg tslib uicmoc-native" DEPENDS_mnci = "zlib libpng jpeg uicmoc-native" DEPENDS_append_c7x0 = " sharp-aticore-oss" PROVIDES = "virtual/qte virtual/libqte2" -PR = "r17" +PR = "r18" SRC_URI = "ftp://ftp.trolltech.com/pub/qt/source/qt-embedded-${PV}-free.tar.gz;md5=1f7ad30113afc500cab7f5b2f4dec0d7 \ file://qpe.patch;patch=1 \ diff --git a/packages/soundtracker/soundtracker-gtk2_0.6.7.bb b/packages/soundtracker/soundtracker-gtk2_0.6.7.bb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/packages/soundtracker/soundtracker-gtk2_0.6.7.bb |