--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/libsdl-trunk/src/video/fbcon/SDL_fbmatrox.c Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,280 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2006 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#include "SDL_video.h"
+#include "../SDL_blit.h"
+#include "SDL_fbmatrox.h"
+#include "matrox_mmio.h"
+
+
+/* Wait for vertical retrace - taken from the XFree86 Matrox driver */
+static void WaitVBL(_THIS)
+{
+ int count;
+
+ /* find start of retrace */
+ mga_waitidle();
+ while ( (mga_in8(0x1FDA) & 0x08) )
+ ;
+ while ( !(mga_in8(0x1FDA) & 0x08) )
+ ;
+ /* wait until we're past the start */
+ count = mga_in32(0x1E20) + 2;
+ while ( mga_in32(0x1E20) < count )
+ ;
+}
+static void WaitIdle(_THIS)
+{
+ mga_waitidle();
+}
+
+/* Sets video mem colorkey and accelerated blit function */
+static int SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key)
+{
+ return(0);
+}
+
+/* Sets per surface hardware alpha value */
+#if 0
+static int SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 value)
+{
+ return(0);
+}
+#endif
+
+static int FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color)
+{
+ int dstX, dstY;
+ Uint32 fxbndry;
+ Uint32 ydstlen;
+ Uint32 fillop;
+
+ /* Don't blit to the display surface when switched away */
+ if ( switched_away ) {
+ return -2; /* no hardware access */
+ }
+ if ( dst == this->screen ) {
+ SDL_mutexP(hw_lock);
+ }
+
+ switch (dst->format->BytesPerPixel) {
+ case 1:
+ color |= (color<<8);
+ case 2:
+ color |= (color<<16);
+ break;
+ }
+
+ /* Set up the X/Y base coordinates */
+ FB_dst_to_xy(this, dst, &dstX, &dstY);
+
+ /* Adjust for the current rectangle */
+ dstX += rect->x;
+ dstY += rect->y;
+
+ /* Set up the X boundaries */
+ fxbndry = (dstX | ((dstX+rect->w) << 16));
+
+ /* Set up the Y boundaries */
+ ydstlen = (rect->h | (dstY << 16));
+
+ /* Set up for color fill operation */
+ fillop = MGADWG_TRAP | MGADWG_SOLID |
+ MGADWG_ARZERO | MGADWG_SGNZERO | MGADWG_SHIFTZERO;
+
+ /* Execute the operations! */
+ mga_wait(5);
+ mga_out32(MGAREG_DWGCTL, fillop | MGADWG_REPLACE);
+ mga_out32(MGAREG_FCOL, color);
+ mga_out32(MGAREG_FXBNDRY, fxbndry);
+ mga_out32(MGAREG_YDSTLEN + MGAREG_EXEC, ydstlen);
+
+ FB_AddBusySurface(dst);
+
+ if ( dst == this->screen ) {
+ SDL_mutexV(hw_lock);
+ }
+ return(0);
+}
+
+static int HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
+ SDL_Surface *dst, SDL_Rect *dstrect)
+{
+ SDL_VideoDevice *this = current_video;
+ int pitch, w, h;
+ int srcX, srcY;
+ int dstX, dstY;
+ Uint32 sign;
+ Uint32 start, stop;
+ int skip;
+ Uint32 blitop;
+
+ /* FIXME: For now, only blit to display surface */
+ if ( dst->pitch != SDL_VideoSurface->pitch ) {
+ return(src->map->sw_blit(src, srcrect, dst, dstrect));
+ }
+
+ /* Don't blit to the display surface when switched away */
+ if ( switched_away ) {
+ return -2; /* no hardware access */
+ }
+ if ( dst == this->screen ) {
+ SDL_mutexP(hw_lock);
+ }
+
+ /* Calculate source and destination base coordinates (in pixels) */
+ w = dstrect->w;
+ h = dstrect->h;
+ FB_dst_to_xy(this, src, &srcX, &srcY);
+ FB_dst_to_xy(this, dst, &dstX, &dstY);
+
+ /* Adjust for the current blit rectangles */
+ srcX += srcrect->x;
+ srcY += srcrect->y;
+ dstX += dstrect->x;
+ dstY += dstrect->y;
+ pitch = dst->pitch/dst->format->BytesPerPixel;
+
+ /* Set up the blit direction (sign) flags */
+ sign = 0;
+ if ( srcX < dstX ) {
+ sign |= 1;
+ }
+ if ( srcY < dstY ) {
+ sign |= 4;
+ srcY += (h - 1);
+ dstY += (h - 1);
+ }
+
+ /* Set up the blit source row start, end, and skip (in pixels) */
+ stop = start = (srcY * pitch) + srcX;
+ if ( srcX < dstX ) {
+ start += (w - 1);
+ } else {
+ stop += (w - 1);
+ }
+ if ( srcY < dstY ) {
+ skip = -pitch;
+ } else {
+ skip = pitch;
+ }
+
+ /* Set up the blit operation */
+ if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
+ Uint32 colorkey;
+
+ blitop = MGADWG_BFCOL | MGADWG_BITBLT |
+ MGADWG_SHIFTZERO | MGADWG_RSTR | (0x0C << 16) |
+ MGADWG_TRANSC;
+
+ colorkey = src->format->colorkey;
+ switch (dst->format->BytesPerPixel) {
+ case 1:
+ colorkey |= (colorkey<<8);
+ case 2:
+ colorkey |= (colorkey<<16);
+ break;
+ }
+ mga_wait(2);
+ mga_out32(MGAREG_FCOL, colorkey);
+ mga_out32(MGAREG_BCOL, 0xFFFFFFFF);
+ } else {
+ blitop = MGADWG_BFCOL | MGADWG_BITBLT |
+ MGADWG_SHIFTZERO | MGADWG_RSTR | (0x0C << 16);
+ }
+ mga_wait(7);
+ mga_out32(MGAREG_SGN, sign);
+ mga_out32(MGAREG_AR3, start);
+ mga_out32(MGAREG_AR0, stop);
+ mga_out32(MGAREG_AR5, skip);
+ mga_out32(MGAREG_FXBNDRY, (dstX | ((dstX + w-1) << 16)));
+ mga_out32(MGAREG_YDSTLEN, (dstY << 16) | h);
+ mga_out32(MGAREG_DWGCTL + MGAREG_EXEC, blitop);
+
+ FB_AddBusySurface(src);
+ FB_AddBusySurface(dst);
+
+ if ( dst == this->screen ) {
+ SDL_mutexV(hw_lock);
+ }
+ return(0);
+}
+
+static int CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
+{
+ int accelerated;
+
+ /* Set initial acceleration on */
+ src->flags |= SDL_HWACCEL;
+
+ /* Set the surface attributes */
+ if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
+ if ( ! this->info.blit_hw_A ) {
+ src->flags &= ~SDL_HWACCEL;
+ }
+ }
+ if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
+ if ( ! this->info.blit_hw_CC ) {
+ src->flags &= ~SDL_HWACCEL;
+ }
+ }
+
+ /* Check to see if final surface blit is accelerated */
+ accelerated = !!(src->flags & SDL_HWACCEL);
+ if ( accelerated ) {
+ src->map->hw_blit = HWAccelBlit;
+ }
+ return(accelerated);
+}
+
+void FB_MatroxAccel(_THIS, __u32 card)
+{
+ /* We have hardware accelerated surface functions */
+ this->CheckHWBlit = CheckHWBlit;
+ wait_vbl = WaitVBL;
+ wait_idle = WaitIdle;
+
+ /* The Matrox has an accelerated color fill */
+ this->info.blit_fill = 1;
+ this->FillHWRect = FillHWRect;
+
+ /* The Matrox has accelerated normal and colorkey blits. */
+ this->info.blit_hw = 1;
+ /* The Millenium I appears to do the colorkey test a word
+ at a time, and the transparency is intverted. (?)
+ */
+ if ( card != FB_ACCEL_MATROX_MGA2064W ) {
+ this->info.blit_hw_CC = 1;
+ this->SetHWColorKey = SetHWColorKey;
+ }
+
+#if 0 /* Not yet implemented? */
+ /* The Matrox G200/G400 has an accelerated alpha blit */
+ if ( (card == FB_ACCEL_MATROX_MGAG200)
+ || (card == FB_ACCEL_MATROX_MGAG400)
+ ) {
+ this->info.blit_hw_A = 1;
+ this->SetHWAlpha = SetHWAlpha;
+ }
+#endif
+}