IABSD.fr/xenocara/driver/xf86-video-mga/src/mga_shadow.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : matthieu
  Date : 2012-09-08 16:35:55
  Hash : bcbd7920
  Message : Update to xf86-video-mga 1.6.1

• driver/xf86-video-mga/src/mga_shadow.c

• /*
     Copyright (c) 1999,  The XFree86 Project Inc. 
     Written by Mark Vojkovich <markv@valinux.com>
  */
  
  #ifdef HAVE_CONFIG_H
  #include "config.h"
  #endif
  
  #include "xf86.h"
  #include "xf86_OSproc.h"
  #include "xf86Pci.h"
  #include "mga_reg.h"
  #include "mga.h"
  #include "shadowfb.h"
  #include "servermd.h"
  
  
  
  void
  MGARefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
  {
      MGAPtr pMga = MGAPTR(pScrn);
      int width, height, Bpp, FBPitch;
      unsigned char *src, *dst;
     
      Bpp = pScrn->bitsPerPixel >> 3;
      FBPitch = BitmapBytePad(pScrn->displayWidth * pScrn->bitsPerPixel);
  
      while(num--) {
  	width = (pbox->x2 - pbox->x1) * Bpp;
  	height = pbox->y2 - pbox->y1;
  	src = pMga->ShadowPtr + (pbox->y1 * pMga->ShadowPitch) + 
  						(pbox->x1 * Bpp);
  	dst = pMga->FbStart + (pbox->y1 * FBPitch) + (pbox->x1 * Bpp);
  
  	while(height--) {
  	    memcpy(dst, src, width);
  	    dst += FBPitch;
  	    src += pMga->ShadowPitch;
  	}
  	
  	pbox++;
      }
  } 
  
  void
  MGAPointerMoved(SCRN_ARG_TYPE arg, int x, int y)
  {
      SCRN_INFO_PTR(arg);
      MGAPtr pMga = MGAPTR(pScrn);
      int newX, newY;
  
      if(pMga->Rotate == 1) {
  	newX = pScrn->pScreen->height - y - 1;
  	newY = x;
      } else {
  	newX = y;
  	newY = pScrn->pScreen->width - x - 1;
      }
  
      (*pMga->PointerMoved)(arg, newX, newY);
  }
  
  void
  MGARefreshArea8(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
  {
      MGAPtr pMga = MGAPTR(pScrn);
      int count, width, height, y1, y2, dstPitch, srcPitch;
      CARD8 *dstPtr, *srcPtr, *src;
      CARD32 *dst;
  
      dstPitch = pScrn->displayWidth;
      srcPitch = -pMga->Rotate * pMga->ShadowPitch;
  
      while(num--) {
  	width = pbox->x2 - pbox->x1;
  	y1 = pbox->y1 & ~3;
  	y2 = (pbox->y2 + 3) & ~3;
  	height = (y2 - y1) >> 2;  /* in dwords */
  
  	if(pMga->Rotate == 1) {
  	    dstPtr = pMga->FbStart + 
  			(pbox->x1 * dstPitch) + pScrn->virtualX - y2;
  	    srcPtr = pMga->ShadowPtr + ((1 - y2) * srcPitch) + pbox->x1;
  	} else {
  	    dstPtr = pMga->FbStart + 
  			((pScrn->virtualY - pbox->x2) * dstPitch) + y1;
  	    srcPtr = pMga->ShadowPtr + (y1 * srcPitch) + pbox->x2 - 1;
  	}
  
  	while(width--) {
  	    src = srcPtr;
  	    dst = (CARD32*)dstPtr;
  	    count = height;
  	    while(count--) {
  		*(dst++) = src[0] | (src[srcPitch] << 8) | 
  					(src[srcPitch * 2] << 16) | 
  					(src[srcPitch * 3] << 24);
  		src += srcPitch * 4;
  	    }
  	    srcPtr += pMga->Rotate;
  	    dstPtr += dstPitch;
  	}
  
  	pbox++;
      }
  } 
  
  
  void
  MGARefreshArea16(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
  {
      MGAPtr pMga = MGAPTR(pScrn);
      int count, width, height, y1, y2, dstPitch, srcPitch;
      CARD16 *dstPtr, *srcPtr, *src;
      CARD32 *dst;
  
      dstPitch = pScrn->displayWidth;
      srcPitch = -pMga->Rotate * pMga->ShadowPitch >> 1;
  
      while(num--) {
  	width = pbox->x2 - pbox->x1;
  	y1 = pbox->y1 & ~1;
  	y2 = (pbox->y2 + 1) & ~1;
  	height = (y2 - y1) >> 1;  /* in dwords */
  
  	if(pMga->Rotate == 1) {
  	    dstPtr = (CARD16*)pMga->FbStart + 
  			(pbox->x1 * dstPitch) + pScrn->virtualX - y2;
  	    srcPtr = (CARD16*)pMga->ShadowPtr + 
  			((1 - y2) * srcPitch) + pbox->x1;
  	} else {
  	    dstPtr = (CARD16*)pMga->FbStart + 
  			((pScrn->virtualY - pbox->x2) * dstPitch) + y1;
  	    srcPtr = (CARD16*)pMga->ShadowPtr + 
  			(y1 * srcPitch) + pbox->x2 - 1;
  	}
  
  	while(width--) {
  	    src = srcPtr;
  	    dst = (CARD32*)dstPtr;
  	    count = height;
  	    while(count--) {
  		*(dst++) = src[0] | (src[srcPitch] << 16);
  		src += srcPitch * 2;
  	    }
  	    srcPtr += pMga->Rotate;
  	    dstPtr += dstPitch;
  	}
  
  	pbox++;
      }
  }
  
  
  /* this one could be faster */
  void
  MGARefreshArea24(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
  {
      MGAPtr pMga = MGAPTR(pScrn);
      int count, width, height, y1, y2, dstPitch, srcPitch;
      CARD8 *dstPtr, *srcPtr, *src;
      CARD32 *dst;
  
      dstPitch = BitmapBytePad(pScrn->displayWidth * 24);
      srcPitch = -pMga->Rotate * pMga->ShadowPitch;
  
      while(num--) {
          width = pbox->x2 - pbox->x1;
          y1 = pbox->y1 & ~3;
          y2 = (pbox->y2 + 3) & ~3;
          height = (y2 - y1) >> 2;  /* blocks of 3 dwords */
  
  	if(pMga->Rotate == 1) {
  	    dstPtr = pMga->FbStart + 
  			(pbox->x1 * dstPitch) + ((pScrn->virtualX - y2) * 3);
  	    srcPtr = pMga->ShadowPtr + ((1 - y2) * srcPitch) + (pbox->x1 * 3);
  	} else {
  	    dstPtr = pMga->FbStart + 
  			((pScrn->virtualY - pbox->x2) * dstPitch) + (y1 * 3);
  	    srcPtr = pMga->ShadowPtr + (y1 * srcPitch) + (pbox->x2 * 3) - 3;
  	}
  
  	while(width--) {
  	    src = srcPtr;
  	    dst = (CARD32*)dstPtr;
  	    count = height;
  	    while(count--) {
  		dst[0] = src[0] | (src[1] << 8) | (src[2] << 16) |
  				(src[srcPitch] << 24);		
  		dst[1] = src[srcPitch + 1] | (src[srcPitch + 2] << 8) |
  				(src[srcPitch * 2] << 16) |
  				(src[(srcPitch * 2) + 1] << 24);		
  		dst[2] = src[(srcPitch * 2) + 2] | (src[srcPitch * 3] << 8) |
  				(src[(srcPitch * 3) + 1] << 16) |
  				(src[(srcPitch * 3) + 2] << 24);	
  		dst += 3;
  		src += srcPitch * 4;
  	    }
  	    srcPtr += pMga->Rotate * 3;
  	    dstPtr += dstPitch; 
  	}
  
  	pbox++;
      }
  }
  
  void
  MGARefreshArea32(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
  {
      MGAPtr pMga = MGAPTR(pScrn);
      int count, width, height, dstPitch, srcPitch;
      CARD32 *dstPtr, *srcPtr, *src, *dst;
  
      dstPitch = pScrn->displayWidth;
      srcPitch = -pMga->Rotate * pMga->ShadowPitch >> 2;
  
      while(num--) {
  	width = pbox->x2 - pbox->x1;
  	height = pbox->y2 - pbox->y1;
  
  	if(pMga->Rotate == 1) {
  	    dstPtr = (CARD32*)pMga->FbStart + 
  			(pbox->x1 * dstPitch) + pScrn->virtualX - pbox->y2;
  	    srcPtr = (CARD32*)pMga->ShadowPtr + 
  			((1 - pbox->y2) * srcPitch) + pbox->x1;
  	} else {
  	    dstPtr = (CARD32*)pMga->FbStart + 
  			((pScrn->virtualY - pbox->x2) * dstPitch) + pbox->y1;
  	    srcPtr = (CARD32*)pMga->ShadowPtr + 
  			(pbox->y1 * srcPitch) + pbox->x2 - 1;
  	}
  
  	while(width--) {
  	    src = srcPtr;
  	    dst = dstPtr;
  	    count = height;
  	    while(count--) {
  		*(dst++) = *src;
  		src += srcPitch;
  	    }
  	    srcPtr += pMga->Rotate;
  	    dstPtr += dstPitch;
  	}
  
  	pbox++;
      }
  }