blt.cpp

Sm501 VGA芯片wince下驱动代码

	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;
};


SCODE SMI::SrcCopyRotation90(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;
    int DestXR=xDst;
    int DestYR=yDst;
    // 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;
    DWORD cmd;

    cmd =   FIELD_INIT(DE_CONTROL, STATUS, START) |
        FIELD_INIT(DE_CONTROL, COMMAND, ROTATE) |
        FIELD_INIT(DE_CONTROL, ROP_SELECT, ROP3) |
        FIELD_INIT(DE_CONTROL, ROTATION, 90) |
        FIELD_INIT_VAL(DE_CONTROL, ROP, (pBltParms->rop4 & 0xFF));
    
    DestXR = yDst;
    DestYR = pBltParms->pDst->Width()-xDst-1;
    
    WaitForNotBusy();

    POKE_32(   
        REG(DE_PITCH),
        FIELD_INIT_VAL(DE_PITCH, DESTINATION, wDst) |
        FIELD_INIT_VAL(DE_PITCH, SOURCE, wSrc)
        );

    POKE_32( 
        REG(DE_WINDOW_WIDTH),
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, DESTINATION, wDst) |
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, SOURCE, wSrc)
        );

    POKE_32(
        REG(DE_WINDOW_SOURCE_BASE),
        ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory()
        );
    POKE_32(
        REG(DE_WINDOW_DESTINATION_BASE),
        ((SMISurf*) (pBltParms->pDst))->OffsetInVideoMemory()
        );
    
#if 1  //Copy strip by strip to work around rotationBLT garbage issue
	{
		int r_block_width;
		int num_block;
        int i;
		
		num_block = xDim / RotBLT_Width;
		r_block_width = xDim % RotBLT_Width;
		for (i=0; i<num_block; i++)
		{
            WaitForNotBusy();
            
            POKE_32(
                REG(DE_DESTINATION),
                FIELD_INIT_VAL(DE_DESTINATION, X, DestXR) |
                FIELD_INIT_VAL(DE_DESTINATION, Y, DestYR-i*RotBLT_Width)
					);

			POKE_32(
				REG(DE_SOURCE),
                FIELD_INIT_VAL(DE_SOURCE, X_K1, xSrc+i*RotBLT_Width) |
				FIELD_INIT_VAL(DE_SOURCE, Y_K2, ySrc)
				);
			
			POKE_32(
				REG(DE_DIMENSION),
				FIELD_INIT_VAL(DE_DIMENSION, X, RotBLT_Width) |
				FIELD_INIT_VAL(DE_DIMENSION, Y_ET, yDim)
				);

			POKE_32(
				REG(DE_CONTROL), cmd);
		}
		
		if (r_block_width)
        {
            WaitForNotBusy();
            POKE_32(
                REG(DE_DESTINATION),
                FIELD_INIT_VAL(DE_DESTINATION, X, DestXR) |
                FIELD_INIT_VAL(DE_DESTINATION, Y, DestYR-i*RotBLT_Width)
                );
            
            POKE_32(
				REG(DE_SOURCE),
				FIELD_INIT_VAL(DE_SOURCE, X_K1, xSrc+i*RotBLT_Width) |
				FIELD_INIT_VAL(DE_SOURCE, Y_K2, ySrc)
				);
			
			POKE_32(
				REG(DE_DIMENSION),
				FIELD_INIT_VAL(DE_DIMENSION, X, r_block_width) |
				FIELD_INIT_VAL(DE_DIMENSION, Y_ET, yDim)
				);
			POKE_32(
				REG(DE_CONTROL), cmd);
		}
	}
#else
    POKE_32(
        REG(DE_SOURCE),
        FIELD_INIT_VAL(DE_SOURCE, X_K1, xSrc) |
        FIELD_INIT_VAL(DE_SOURCE, Y_K2, ySrc)
        );
    POKE_32(
        REG(DE_DESTINATION),
        FIELD_INIT_VAL(DE_DESTINATION, X, DestXR) |
        FIELD_INIT_VAL(DE_DESTINATION, Y, DestYR)
        );
    POKE_32(
        REG(DE_DIMENSION),
        FIELD_INIT_VAL(DE_DIMENSION, X, xDim) |
        FIELD_INIT_VAL(DE_DIMENSION, Y_ET, yDim)
        );
    POKE_32(
        REG(DE_CONTROL), cmd);

#endif
	return (S_OK);
} /* SrcCopyRotation90 */


SCODE SMI::SrcCopyRotation180(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;
    int DestXR=xDst;
    int DestYR=yDst;
    // 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 cmd;
    int r_block_width;
    int num_block;
    int i;

    
    cmd =   FIELD_INIT(DE_CONTROL, STATUS, START) |
            FIELD_INIT(DE_CONTROL, COMMAND, ROTATE) |
            FIELD_INIT(DE_CONTROL, ROP_SELECT, ROP3) |
            FIELD_INIT(DE_CONTROL, ROTATION, 90) |
            FIELD_INIT_VAL(DE_CONTROL, ROP, (pBltParms->rop4 & 0xFF));
    
    //*************************************************
    //Step 1. RotBlt90 from src buffer to g_pbuffer180 
    //*************************************************
    DestXR = 0;
    DestYR = g_pbuffer180->Height()-1;
    
    WaitForNotBusy();
    
    POKE_32(   
        REG(DE_PITCH),
        FIELD_INIT_VAL(DE_PITCH, DESTINATION, m_pPrimarySurface->Width()) |
        FIELD_INIT_VAL(DE_PITCH, SOURCE, wSrc)
        ); //WinCE Node2D memory manager always use m_pPrimarySurface->Width() to manage the rectangular heap. If it is linear heap, it should use g_pbuffer180->Width().

    POKE_32( 
        REG(DE_WINDOW_WIDTH),
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, DESTINATION, m_pPrimarySurface->Width()) |
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, SOURCE, wSrc)
        ); //WinCE Node2D memory manager always use m_pPrimarySurface->Width() to manage the rectangular heap. If it is linear heap, it should use g_pbuffer180->Width().

    POKE_32(
        REG(DE_WINDOW_SOURCE_BASE),
        ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory()
        );

    POKE_32(REG(DE_WINDOW_DESTINATION_BASE), g_pbuffer180->OffsetInVideoMemory());
    
    POKE_32(REG(DE_DIMENSION), FIELD_INIT_VAL(DE_DIMENSION, X, RotBLT_Width) | FIELD_INIT_VAL(DE_DIMENSION, Y_ET, yDim));

    num_block = xDim / RotBLT_Width;
    r_block_width = xDim % RotBLT_Width;

    for (i=0; i<num_block; i++)
    {
        WaitForNotBusy();

        POKE_32(
            REG(DE_DESTINATION),
            FIELD_INIT_VAL(DE_DESTINATION, X, DestXR) |
            FIELD_INIT_VAL(DE_DESTINATION, Y, DestYR-i*RotBLT_Width)
            );
        
        POKE_32(
            REG(DE_SOURCE),
            FIELD_INIT_VAL(DE_SOURCE, X_K1, xSrc+i*RotBLT_Width) |
            FIELD_INIT_VAL(DE_SOURCE, Y_K2, ySrc)
            );
        
        POKE_32(
            REG(DE_CONTROL), cmd);
    }
    
    if (r_block_width)
    {
        WaitForNotBusy();

        POKE_32(
            REG(DE_DESTINATION),
            FIELD_INIT_VAL(DE_DESTINATION, X, DestXR) |
            FIELD_INIT_VAL(DE_DESTINATION, Y, DestYR-i*RotBLT_Width)
            );
        
        POKE_32(
            REG(DE_SOURCE),
            FIELD_INIT_VAL(DE_SOURCE, X_K1, xSrc+i*RotBLT_Width) |
            FIELD_INIT_VAL(DE_SOURCE, Y_K2, ySrc)
            );
        
        POKE_32(
            REG(DE_DIMENSION),
            FIELD_INIT_VAL(DE_DIMENSION, X, r_block_width) |
            FIELD_INIT_VAL(DE_DIMENSION, Y_ET, yDim)
            );
        POKE_32(
            REG(DE_CONTROL), cmd);
    }

    //*************************************************
    //Step 2. RotBlt90 from g_pbuffer180 to dest buffer
    //*************************************************
    DestXR = pBltParms->pDst->Width()-xDst-xDim;
    DestYR = pBltParms->pDst->Height()-yDst-1;

    WaitForNotBusy();
    
    POKE_32(   
        REG(DE_PITCH),
        FIELD_INIT_VAL(DE_PITCH, DESTINATION, wDst) |
        FIELD_INIT_VAL(DE_PITCH, SOURCE, m_pPrimarySurface->Width())
        ); //WinCE Node2D memory manager always use m_pPrimarySurface->Width() to manage the rectangular heap. If it is linear heap, it should use g_pbuffer180->Width().
    
    POKE_32( 
        REG(DE_WINDOW_WIDTH),
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, DESTINATION, wDst) |
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, SOURCE, m_pPrimarySurface->Width())
        ); //WinCE Node2D memory manager always use m_pPrimarySurface->Width() to manage the rectangular heap. If it is linear heap, it should use g_pbuffer180->Width().

    POKE_32(REG(DE_WINDOW_SOURCE_BASE), g_pbuffer180->OffsetInVideoMemory());
    
    POKE_32(REG(DE_WINDOW_DESTINATION_BASE), ((SMISurf*) (pBltParms->pDst))->OffsetInVideoMemory() );
    
    POKE_32(REG(DE_DIMENSION), FIELD_INIT_VAL(DE_DIMENSION, X, RotBLT_Width) | FIELD_INIT_VAL(DE_DIMENSION, Y_ET, xDim));
    
    num_block = yDim / RotBLT_Width;
    r_block_width = yDim % RotBLT_Width;
    
    for (i=0; i<num_block; i++)
    {
        WaitForNotBusy();

        POKE_32(
            REG(DE_DESTINATION),
            FIELD_INIT_VAL(DE_DESTINATION, X, DestXR) |
            FIELD_INIT_VAL(DE_DESTINATION, Y, DestYR-i*RotBLT_Width)
            );
        
        POKE_32(
            REG(DE_SOURCE),
            FIELD_INIT_VAL(DE_SOURCE, X_K1, i*RotBLT_Width) |
            FIELD_INIT_VAL(DE_SOURCE, Y_K2, g_pbuffer180->Height()-xDim)
            );
        
        POKE_32(
            REG(DE_CONTROL), cmd);
    }
    
    if (r_block_width)
    {
        WaitForNotBusy();

        POKE_32(
            REG(DE_DESTINATION),
            FIELD_INIT_VAL(DE_DESTINATION, X, DestXR) |
            FIELD_INIT_VAL(DE_DESTINATION, Y, DestYR-i*RotBLT_Width)
            );
        
        POKE_32(
            REG(DE_SOURCE),
            FIELD_INIT_VAL(DE_SOURCE, X_K1, i*RotBLT_Width) |
            FIELD_INIT_VAL(DE_SOURCE, Y_K2, g_pbuffer180->Height()-xDim)
            );
        
        POKE_32(
            REG(DE_DIMENSION),
            FIELD_INIT_VAL(DE_DIMENSION, X, r_block_width) |
            FIELD_INIT_VAL(DE_DIMENSION, Y_ET, xDim)
            );
        POKE_32(
            REG(DE_CONTROL), cmd);
    }


    return (S_OK);
} /* SrcCopyRotation180 */


SCODE SMI::SrcCopyRotation270(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;
    int DestXR=xDst;
    int DestYR=yDst;
    // 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 cmd;
    
    cmd =   FIELD_INIT(DE_CONTROL, ST