blt.cpp

SM501基于ARMV4/ARMV4I平台

	reg_DimXY    = (dimX << 16) | dimY;
	if (pBltParms->bltFlags & BLT_TRANSPARENT)
		reg_ColorCmp   = color;
	reg_RowPitch    = (dstWidth << 16) | dstWidth;
	reg_WindowWidth = (dstWidth << 16) | dstWidth;
	reg_ROPCommand = (pBltParms->rop4 & 0xFF)
				   | CMD_HOSTBLT_WRITE
				   | dwTransp
				   | START_DRAWING_ENGINE;
#endif //CMDLISTHBLT
#if 1
	if (srcStride < 0)
	{
        // if the bitmap is from bottom to top, the first line need to special handling.
		if (nLong)
        {
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), ( nLong/4) );
#endif
            for (i=0;i<(nLong/4);i++)
            {
                memcpy(&m_ulSrc, (pSrcBuffer + i*4), 4);
#ifdef CMDLISTHBLT
                INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
#else  //CMDLISTHBLT
                *(PULONG) m_pMMIO = m_ulSrc;
#endif
			}
#ifdef CMDLISTHBLT
            INSERTCMD_PADQWORD(cmd_ptr, ( nLong/4) );
#endif
		}
		if (BytesRemain)
		{
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), 2 );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)abyRemain );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)(abyRemain+4) );
#else  //CMDLISTHBLT
			*(PULONG) m_pMMIO = *(PULONG)abyRemain;
			*(PULONG) m_pMMIO = *(PULONG)(abyRemain+4);
#endif //CMDLISTHBLT
		}
        pSrcBuffer += srcStride;
	}

#ifdef CMDLISTHBLT
    if (dimY>1) //aviod INSERTCMD_LOADREG_E() with counter 0 which cause hang
    {
        if (0) //Media player hang if transfer size is too big. dwhostsize< HOST_DATAPORT_SIZE/4) 
            //&& (dwhostsize < CMDLISTBUF_SIZE/4-4*CMD_STRIDE_DWORD))
        {
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), dwhostsize );
            for (i = 1; i < dimY; i++)
            {
                for (j=0;j<dwhostlinesize;j++)
                {
                    memcpy(&m_ulSrc, pSrcBuffer+j*4, 4);
                    INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
                }
                pSrcBuffer += srcStride;
            }
            INSERTCMD_PADQWORD(cmd_ptr, dwhostsize );
        }
        else
        {
            for (i = 1; i < dimY; i++)
            {
                INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), dwhostlinesize );
                for (j=0;j<dwhostlinesize;j++)
                {
                    memcpy(&m_ulSrc, pSrcBuffer+j*4, 4);
                    INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
                }
                INSERTCMD_PADQWORD(cmd_ptr, dwhostlinesize );
                pSrcBuffer += srcStride;
            }
        }
    }
#else  //CMDLISTHBLT
	for (i = 1; i < dimY; i++)
	{
		for (j=0;j<(Bytes8PerScan/4);j++)
		{
			memcpy(&m_ulSrc, pSrcBuffer+j*4, 4);
            *(PULONG) m_pMMIO = m_ulSrc;
		}
		pSrcBuffer += srcStride;
	}
#endif //CMDLISTHBLT

	if (srcStride > 0)
	{
        // if the bitmap is from top to bottom, the last line need to special handling.
		if (nLong)
		{
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), ( nLong/4) );
#endif
			for (i=0;i<(nLong/4);i++)
			{
				memcpy(&m_ulSrc, (pSrcBuffer + i*4), 4);
#ifdef CMDLISTHBLT
                INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
#else  //CMDLISTHBLT
				*(PULONG) m_pMMIO = m_ulSrc;
#endif //CMDLISTHBLT
			}
#ifdef CMDLISTHBLT
            INSERTCMD_PADQWORD(cmd_ptr, ( nLong/4) );
#endif
		}
		if (BytesRemain)
		{
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), 2 );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)abyRemain );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)(abyRemain+4) );
#else  //CMDLISTHBLT
			*(PULONG) m_pMMIO = *(PULONG)abyRemain;
			*(PULONG) m_pMMIO = *(PULONG)(abyRemain+4);
#endif //CMDLISTHBLT
		}
    }

#ifdef CMDLISTHBLT
    INSERTCMD_FINISH(cmd_ptr, 0);
    
    STOP_CI();
    WAIT_CI_STOP();
    
    INSERTCMD_NOP(last_finish_ptr);
    
    last_finish_ptr = cmd_ptr - CMD_STRIDE_DWORD;
    
    FLUSH_CMD();

    START_CI("CMDList HostBlt");

#endif //CMDLISTHBLT

#else 
	if (srcStride < 0)
	{
        // if the bitmap is from bottom to top, the first line need to special handling.
		memcpy(m_pMMIO, pSrcBuffer, nLong);
        if (BytesRemain) {
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
			memcpy(m_pMMIO, abyRemain, 8);
        }

        pSrcBuffer += srcStride;
    }
    for (i=1; i < dimY; i++) 
    {
		memcpy(m_pMMIO, pSrcBuffer, Bytes8PerScan);
		pSrcBuffer += srcStride;
    }

	if (srcStride > 0)
	{
        // if the bitmap is from top to bottom, the last line need to special handling.
		memcpy(m_pMMIO, pSrcBuffer, nLong);
        if (BytesRemain) {
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
			memcpy(m_pMMIO, abyRemain, 8);
        }
    }
#endif

//	RETAILMSG(1, (_T("SMI:: -SrcCopy\r\n")));
	return(S_OK);
}

SCODE SMI::CSCSrcCopy(GPEBltParms *pBltParms)
{
    DWORD origSrcDimX, origSrcDimY, origDestDimX, origDestDimY;
    DWORD ScaleXn, ScaleXd, ScaleYn, ScaleYd;
    DWORD SrcTn, SrcTd, SrcLn, SrcLd;
    DWORD SrcRn, SrcRd, SrcBn, SrcBd;
    DWORD SrcDimX, SrcDimY, DestDimX, DestDimY;
	DWORD SrcFormat, DstFormat, HFilter, VFilter, byOrder;
	DWORD SrcYBase, SrcUBase, SrcVBase, SrcYPitch, SrcUVPitch, SrcBpp;
	DWORD DestBase, DestPitch, DestHeight, DestWidth, DestBpp;

	BLTRECT bd;
	BLTRECT *pd = &bd;

	if (!(pBltParms->xPositive && pBltParms->yPositive))
		return EmulatedBlt(pBltParms);
	
	pd->rSrc = *pBltParms->prclSrc;
	pd->rOrigSrc = *pBltParms->prclSrc;
	pd->rDest = *pBltParms->prclDst;
	pd->rOrigDest = *pBltParms->prclDst;

	SrcBpp = EGPEFormatToBpp[((SMISurf*) (pBltParms->pSrc))->Format()] / 8;
	SrcYBase = ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory();
	SrcUBase = ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory();
	SrcVBase = ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory();
	DestBase = ((SMISurf*) (pBltParms->pDst))->OffsetInVideoMemory();
	SrcYPitch = ((SMISurf*) (pBltParms->pSrc))->AlignedWidth() * SrcBpp;
	SrcUVPitch = ((SMISurf*) (pBltParms->pSrc))->AlignedWidth() * SrcBpp;

	DestBpp = EGPEFormatToBpp[((SMISurf*) (pBltParms->pDst))->Format()] / 8;
	DestPitch = ((SMISurf*) (pBltParms->pDst))->AlignedWidth() * DestBpp;
	DestHeight = ((SMISurf*) (pBltParms->pDst))->Height();
	DestWidth = ((SMISurf*) (pBltParms->pDst))->Width();


	byOrder = 0;
	switch (SrcBpp)
	{
	case 2:
		SrcFormat = CSC_CONTROL_SOURCE_FORMAT_RGB565;			
		break;
	case 4:
		SrcFormat = CSC_CONTROL_SOURCE_FORMAT_RGB8888;
		break;
	default:
        DEBUGMSG(1, (TEXT("SMI::CSCSrcCopy - Unsupported screen bit-depth (%d)\r\n"), 
    	    	m_nScreenBpp));
       	return EmulatedBlt(pBltParms);
	}

	switch (DestBpp)
	{
	case 2:
		DstFormat = CSC_CONTROL_DESTINATION_FORMAT_RGB565;
		break;
	case 4:
		DstFormat = CSC_CONTROL_DESTINATION_FORMAT_RGB8888;
		break;
	default:
		DEBUGMSG(1, (TEXT("ERROR! SMI::CSCSrcCopy() - CSC Dst Format Unsupported - iDestBpp = %d\r\n"),DestBpp));
       	return EmulatedBlt(pBltParms);
		break;		
	}

	HFilter = CSC_CONTROL_HORIZONTAL_FILTER_ENABLE;
	VFilter = CSC_CONTROL_VERTICAL_FILTER_ENABLE;

	if ((pd->rOrigSrc.right == 0) &&
		(pd->rOrigSrc.left == 0) &&
		(pd->rOrigSrc.bottom == 0) &&
		(pd->rOrigSrc.top == 0))
	{
		pd->rOrigSrc = pd->rSrc;
	}

	if ((pd->rOrigDest.right == 0) &&
		(pd->rOrigDest.left == 0) &&
		(pd->rOrigDest.bottom == 0) &&
		(pd->rOrigDest.top == 0))
	{
		pd->rOrigDest = pd->rDest;
	}

    origSrcDimX = pd->rOrigSrc.right - pd->rOrigSrc.left;
    origSrcDimY = pd->rOrigSrc.bottom - pd->rOrigSrc.top;

    origDestDimX = pd->rOrigDest.right - pd->rOrigDest.left;
    origDestDimY = pd->rOrigDest.bottom - pd->rOrigDest.top;

	if ((origSrcDimX <= 1) ||
		(origSrcDimY <= 1) ||
		(origDestDimX <= 1) ||
		(origDestDimY <= 1))
		return EmulatedBlt(pBltParms);		
                    
    ScaleXn = (origSrcDimX-1)/(origDestDimX-1);
    ScaleXd = ((origSrcDimX-1)<<13)/(origDestDimX-1) - (ScaleXn<<13);

    ScaleYn = (origSrcDimY-1)/(origDestDimY-1);
    ScaleYd = ((origSrcDimY-1)<<13)/(origDestDimY-1) - (ScaleYn<<13);            

    SrcLn = pd->rSrc.left;
    SrcLd = 0;

    SrcRn = pd->rSrc.right;
    SrcRd = 0;

    SrcTn = pd->rSrc.top;
    SrcTd = 0;

    SrcBn = pd->rSrc.bottom;
    SrcBd = 0;

    SrcDimX = pd->rSrc.right - pd->rSrc.left;
    SrcDimY = pd->rSrc.bottom - pd->rSrc.top;

    DestDimX = pd->rDest.right - pd->rDest.left;
    DestDimY = pd->rDest.bottom - pd->rDest.top;

	WaitForNotBusy();

  	POKE_32(CSC_CONSTANTS, 
		FIELD_VALUE(0, CSC_CONSTANTS, Y, 0) |
		FIELD_VALUE(0, CSC_CONSTANTS, R, 0) |
		FIELD_VALUE(0, CSC_CONSTANTS, G, 0) |
		FIELD_VALUE(0, CSC_CONSTANTS, B, 0) |
		0);

	POKE_32(CSC_Y_SOURCE_X, 
		FIELD_VALUE(0, CSC_Y_SOURCE_X, INTEGER, SrcLn) |
		FIELD_VALUE(0, CSC_Y_SOURCE_X, FRACTION, SrcLd) |
		0);

	POKE_32(CSC_Y_SOURCE_Y, 
		FIELD_VALUE(0, CSC_Y_SOURCE_Y, INTEGER, SrcTn) |
		FIELD_VALUE(0, CSC_Y_SOURCE_Y, FRACTION, SrcTd) |
		0);

	POKE_32(CSC_SOURCE_DIMENSION, 
		FIELD_VALUE(0, CSC_SOURCE_DIMENSION, X, SrcDimX) |
		FIELD_VALUE(0, CSC_SOURCE_DIMENSION, Y, SrcDimY) |
		0);

	POKE_32(CSC_SOURCE_PITCH, 
		FIELD_VALUE(0, CSC_SOURCE_PITCH, Y, SrcYPitch >> 4) |
		FIELD_VALUE(0, CSC_SOURCE_PITCH, UV, SrcUVPitch >> 4) |
		0);

	POKE_32(CSC_DESTINATION, 
		FIELD_SET(0, CSC_DESTINATION, WRAP, DISABLE) |
		FIELD_VALUE(0, CSC_DESTINATION, X, pd->rDest.left) |
		FIELD_VALUE(0, CSC_DESTINATION, Y, pd->rDest.top) |
		0);

	POKE_32(CSC_DESTINATION_DIMENSION, 
		FIELD_VALUE(0, CSC_DESTINATION_DIMENSION, X, DestDimX) |
		FIELD_VALUE(0, CSC_DESTINATION_DIMENSION, Y, DestDimY) |
		0);

	POKE_32(CSC_DESTINATION_PITCH, 
		FIELD_VALUE(0, CSC_DESTINATION_PITCH, X, DestPitch >> 4) |
		FIELD_VALUE(0, CSC_DESTINATION_PITCH, Y, DestHeight) |
		0);

	POKE_32(CSC_SCALE_FACTOR,
		FIELD_VALUE(0, CSC_SCALE_FACTOR, HORIZONTAL, (ScaleXn<<13 | ScaleXd)) |
		FIELD_VALUE(0, CSC_SCALE_FACTOR, VERTICAL, (ScaleYn<<13 | ScaleYd)) |
		0);

	POKE_32(CSC_Y_SOURCE_BASE, 
		FIELD_SET(0, CSC_Y_SOURCE_BASE, EXT, LOCAL) |
		FIELD_VALUE(0, CSC_Y_SOURCE_BASE, ADDRESS, SrcYBase) |
		0);

	POKE_32(CSC_U_SOURCE_BASE, 
		FIELD_SET(0, CSC_U_SOURCE_BASE, EXT, LOCAL) |
		FIELD_VALUE(0, CSC_U_SOURCE_BASE, ADDRESS, SrcUBase) |
		0);

	POKE_32(CSC_V_SOURCE_BASE, 
		FIELD_SET(0, CSC_V_SOURCE_BASE, EXT, LOCAL) |
		FIELD_VALUE(0, CSC_V_SOURCE_BASE, ADDRESS, SrcVBase) |
		0);

	POKE_32(CSC_DESTINATION_BASE, 
		FIELD_SET(0, CSC_DESTINATION_BASE, EXT, LOCAL) |
		FIELD_VALUE(0, CSC_DESTINATION_BASE, ADDRESS, DestBase) |
		0);

	POKE_32(CSC_CONTROL, 
		FIELD_SET(0, CSC_CONTROL, STATUS, START) |
		FIELD_VALUE(0, CSC_CONTROL, SOURCE_FORMAT, SrcFormat) |
		FIELD_VALUE(0, CSC_CONTROL, DESTINATION_FORMAT, DstFormat) |
		FIELD_VALUE(0, CSC_CONTROL, HORIZONTAL_FILTER, HFilter) |
		FIELD_VALUE(0, CSC_CONTROL, VERTICAL_FILTER, VFilter) |
		FIELD_VALUE(0, CSC_CONTROL, BYTE_ORDER, byOrder) |
		0);

	return S_OK;
};

// SrcCopy 192Byte limititation Patch
SCODE SMI::SrcCopy(GPEBltParms *pBltParms)
{
	// Start x,y of Src
	int xSrc = pBltParms->prclSrc->left;
	int ySrc = pBltParms->prclSrc->top;
	// Start x,y of Dst
	int xDst = pBltParms->prclDst->left;
	int yDst = pBltParms->prclDst->top;
	// dimention x and y
	int xDim = pBltParms->prclDst->right - xDst;
	int yDim = pBltParms->prclDst->bottom - yDst;
	// Width dst and src
	int wDst = ((SMISurf*) (pBltParms->pDst))->AlignedWidth();
	int wSrc = ((SMISurf*) (pBltParms->pSrc))->AlignedWidth();
	DWORD dwTransp = 0;
	COLOR color;

	ULONG ulDir;