fimgse2d.cpp

来自「6410BSP3」· C++ 代码 · 共 1,270 行 · 第 1/4 页

            {
                nIncr = nIncr | 1;
                uHSz -= uVSz;
            }
        }
        nIncr = (nIncr + 1) >> 1;
        if (usPosX1 > usPosX2)
        {
            nIncr = (~nIncr) + 1; // 2's complement
        }
        RETAILMSG(DISP_ZONE_LINE, (TEXT("XINCR: %x  "), nIncr ));
    }

    m_pG2DReg->FG_COLOR = uColor;

    uCmdRegVal = 0;

    SetAlphaMode(G2D_NO_ALPHA_MODE);   //< Constant Alpha
    SetAlphaValue(0xff);
    

    if(nMajorCoordX)
    {
        SetYIncr(nIncr);

        uCmdRegVal =
            (bIsDrawLastPoint == true) ? (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_X_BIT & G2D_DRAW_LAST_POINT_BIT) :
            (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_X_BIT | G2D_NOT_DRAW_LAST_POINT_BIT);
        
        RETAILMSG(DISP_ZONE_LINE,(TEXT("m_pG2DReg:0x%x, CMD: %x, XINCR: %x, YINCR: %x\n"), m_pG2DReg, uCmdRegVal, m_pG2DReg->X_INCR, m_pG2DReg->Y_INCR ));
    }
    else
    {
        SetXIncr(nIncr);

        uCmdRegVal =
            (bIsDrawLastPoint == true) ? (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_Y_BIT & G2D_DRAW_LAST_POINT_BIT) :
            (G2D_REND_LINE_BIT | G2D_MAJOR_COORD_Y_BIT | G2D_NOT_DRAW_LAST_POINT_BIT);

        RETAILMSG(DISP_ZONE_LINE,(TEXT("CMD: %x, XINCR: %x, YINCR: %x\n"), uCmdRegVal, m_pG2DReg->X_INCR, m_pG2DReg->Y_INCR ));
    }
    
    DoCmd(&(m_pG2DReg->CMDR0), uCmdRegVal, G2D_FASTRETURN);
}

/**
*    @fn    FIMGSE2D::DoCmd(DWORD *CmdRegister, DWORD CmdValue, DWORD CmdType)
*    @note  Submit the 2D Processing Command
*    @note  3 processing return Style is supported 
*           Asynchornous Return -> Not Recommended for all GDI call, very small transfer or just with DDraw
*           Synchornous Wait for interrupt -> Recommended for most case, Big Transfer
*           Synchrnous polling -> Recommended for very short process time, ex) LineDrawing, under tick(1 millisecond)
*/
BOOL FIMGSE2D::DoCmd(volatile UINT32 *CmdReg, DWORD CmdValue, G2D_CMDPROCESSING_TYPE eCmdType)
{
    DWORD bRetVal = 0;
    switch(eCmdType)
    {
    case G2D_FASTRETURN:
        DispPerfBeginWait();
        WaitForEmptyFifo();        //< This is check fully empty command fifo.
        DispPerfEndWait();
        
        *CmdReg = CmdValue;
        
        break;
    case G2D_INTERRUPT:
        RequestEmptyFifo(1);
        IntEnable();    
        
        *CmdReg = CmdValue;
        
        DispPerfBeginWait();        
        bRetVal = WaitForSingleObject(m_hInterrupt2D, 10000L);    //< Set Timeout as 10seconds.
        DispPerfEndWait();        
        
        if(bRetVal == WAIT_TIMEOUT)
        {
            RETAILMSG(DISP_ZONE_ERROR, (TEXT("2D Command take too long time. This command cannot be processed properly\r\n")));
        }

        IntDisable();    
        IntPendingClear();    

        InterruptDone(m_dwSysIntr2D);    
        break;
    case G2D_BUSYWAITING:
        RequestEmptyFifo(1);
        IntDisable();    

        *CmdReg = CmdValue;
        
        DispPerfBeginWait();
//        while(!WaitForFinish());      
        WaitForIdleStatus();                        // Polling Style    
        DispPerfEndWait();

//        IntDisable();    
       
        break;
    default:
        RETAILMSG(DISP_ZONE_ERROR,(TEXT("CMDPROCESSING TYPE is invalid : %d\n"), eCmdType));
        return FALSE;
    }
    return TRUE;
}


/**
*    @fn    FIMGSE2D::SetRopEtype(G2D_ROP_TYPE eRopType)
*    @note    Set Ternary Raster Operation
*    @note    Only support 7 raster operation (most used Rop)
*/
void FIMGSE2D::SetRopEtype(G2D_ROP_TYPE eRopType)
{
    DWORD uRopVal;

    uRopVal =
        (eRopType == ROP_SRC_ONLY) ? G2D_ROP_SRC_ONLY :
        (eRopType == ROP_DST_ONLY) ? G2D_ROP_DST_ONLY :
        (eRopType == ROP_PAT_ONLY) ? G2D_ROP_PAT_ONLY :
        (eRopType == ROP_SRC_AND_DST) ? G2D_ROP_SRC_AND_DST:
        (eRopType == ROP_SRC_AND_PAT) ? G2D_ROP_SRC_AND_PAT :
        (eRopType == ROP_DST_AND_PAT) ? G2D_ROP_DST_AND_PAT :
        (eRopType == ROP_SRC_OR_DST) ? G2D_ROP_SRC_OR_DST :
        (eRopType == ROP_SRC_OR_PAT) ? G2D_ROP_SRC_OR_PAT :
        (eRopType == ROP_DST_OR_PAT) ? G2D_ROP_DST_OR_PAT :
        (eRopType == ROP_SRC_XOR_DST) ? G2D_ROP_SRC_XOR_DST :
        (eRopType == ROP_SRC_XOR_PAT) ? G2D_ROP_SRC_XOR_PAT :
        (eRopType == ROP_DST_XOR_PAT) ? G2D_ROP_DST_XOR_PAT :
         G2D_ROP_SRC_ONLY;

    SetRopValue(uRopVal);

}



void FIMGSE2D::SetStencilKey(DWORD uIsColorKeyOn, DWORD uIsInverseOn, DWORD uIsSwapOn)
{
    RequestEmptyFifo(1);
    m_pG2DReg->COLORKEY_CNTL = ((uIsColorKeyOn&1)<<31)|((uIsInverseOn&1)<<23)|(uIsSwapOn&1);
}

void FIMGSE2D::SetStencilMinMax(DWORD uRedMin, DWORD uRedMax, DWORD uGreenMin, DWORD uGreenMax, DWORD uBlueMin, DWORD uBlueMax)
{
    RequestEmptyFifo(2);
    m_pG2DReg->COLORKEY_DR_MIN = ((uRedMin&0xff)<<16)|((uGreenMin&0xff)<<8)|(uBlueMin&0xff);
    m_pG2DReg->COLORKEY_DR_MAX = ((0xffU<<24)|(uRedMax&0xff)<<16)|((uGreenMax&0xff)<<8)|(uBlueMax&0xff);
}

void FIMGSE2D::SetColorExpansionMethod(bool bIsScr2Scr)
{
    m_bIsScr2Scr  = bIsScr2Scr;
}

void FIMGSE2D::BlendingOut(DWORD uSrcData, DWORD uDstData, BYTE ucAlphaVal, bool bFading, BYTE ucFadingOffset, DWORD *uBlendingOut)
{

    DWORD uSrcRed, uSrcGreen, uSrcBlue;
    DWORD uDstRed, uDstGreen, uDstBlue;
    DWORD uBldRed, uBldGreen, uBldBlue;

    uSrcRed= (uSrcData & 0x00ff0000)>>16;  // Mask R
    uSrcGreen = (uSrcData & 0x0000ff00)>>8;     // Mask G
    uSrcBlue = uSrcData & 0x000000ff;         // Mask B

    uDstRed = (uDstData & 0x00ff0000)>>16; // Mask R
    uDstGreen = (uDstData & 0x0000ff00)>>8;  // Mask G
    uDstBlue = uDstData & 0x000000ff;         // Mask B

    if(bFading) {
        uBldRed= ((uSrcRed*(ucAlphaVal+1))>>8) + ucFadingOffset; // R output
        uBldGreen= ((uSrcGreen*(ucAlphaVal+1))>>8) + ucFadingOffset; // G output
        uBldBlue= ((uSrcBlue*(ucAlphaVal+1)>>8)) + ucFadingOffset; // B output
        if(uBldRed>=256) uBldRed=255;
        if(uBldGreen>=256) uBldGreen=255;
        if(uBldBlue>=256) uBldBlue=255;
    }
    else {
        uBldRed= ((uSrcRed*(ucAlphaVal+1)) + (uDstRed*(256-ucAlphaVal)))>>8; // R output
        uBldGreen= ((uSrcGreen*(ucAlphaVal+1)) + (uDstGreen*(256-ucAlphaVal)))>>8; // G output
        uBldBlue= ((uSrcBlue*(ucAlphaVal+1)) + (uDstBlue*(256-ucAlphaVal)))>>8; // B output
    }

    *uBlendingOut = (uBldRed<<16) | (uBldGreen<<8) | uBldBlue;
}


void FIMGSE2D::Convert24bpp(DWORD uSrcData, EGPEFormat eBpp, bool bSwap, DWORD *uConvertedData)
{

    DWORD uRed, uGreen, uBlue;

    switch(eBpp) {
        case  gpe8Bpp: // 15 bit color mode(ARGB:1555)
            if(bSwap == 1) {  // pde_state == 2(BitBlt)
                uRed = uSrcData & 0x00007c00;  // R
                uGreen = uSrcData & 0x000003e0;  // G
                uBlue = uSrcData & 0x0000001f;  // B
            
                *uConvertedData = uRed<<9 | uGreen<<6 | uBlue<<3; // SUM
            }
            else { //hsel = 0
                uRed = uSrcData & 0x7c000000;
                uGreen = uSrcData & 0x03e00000;
                uBlue = uSrcData & 0x001f0000;

                *uConvertedData = uRed>>7 | uGreen>>10 | uBlue>>13;
            } 
            break;
        case gpe16Bpp : // 16 bit color mode
            if(bSwap == 1) {
                uRed = uSrcData & 0x0000f800;
                uGreen = uSrcData & 0x000007e0;
                uBlue = uSrcData & 0x0000001f;

                *uConvertedData = uRed<<8 | uGreen<<5 | uBlue<<3;
            }
            else {
                uRed = uSrcData & 0xf8000000;
                uGreen = uSrcData & 0x07e00000;
                uBlue = uSrcData & 0x001f0000;

                *uConvertedData = uRed>>8 | uGreen>>11 | uBlue>>13;
            }
            break;    
        case gpe32Bpp : // 24 bit color mode
            *uConvertedData = uSrcData;
            break;
    } // End of switch
} // End of g2d_cvt24bpp function


void FIMGSE2D::GetRotateCoordinate(DWORD uDstX, DWORD uDstY, DWORD uOrgX, DWORD uOrgY, DWORD uRType, DWORD *uRsltX, DWORD *uRsltY)
{

    switch(uRType) {
        case  1 : // No Rotate. bypass.
            *uRsltX = uDstX;
            *uRsltY = uDstY;
            break;
        case  2 : // 90 degree Rotation
            *uRsltX = uOrgX + uOrgY - uDstY;
            *uRsltY = uDstX - uOrgX + uOrgY;
            break;
        case  4 : // 180 degree Rotation
            *uRsltX = 2*uOrgX - uDstX;
            *uRsltY = 2*uOrgY - uDstY;
            break;
        case  8 : // 270 degree Rotation
            *uRsltX = uDstY + uOrgX - uOrgY;
            *uRsltY = uOrgX + uOrgY - uDstX;
            break;
        case 16 : // X-flip
            *uRsltX = uDstX;
            *uRsltY = 2*uOrgY - uDstY;
            break;
        case 32 : // Y-flip
            *uRsltX = 2*uOrgX - uDstX;
            *uRsltY = uDstY;
            break;
        default :
            RETAILMSG(DISP_ZONE_ERROR, (TEXT("Invalid Rotation Type : %d"), uRType));
            break;
    }
}



BOOL FIMGSE2D::InitializeInterrupt(void)
{
    DWORD dwIRQ;

    dwIRQ = IRQ_2D;                    // 2D Accelerator IRQ
    m_dwSysIntr2D = SYSINTR_UNDEFINED;
    m_hInterrupt2D = NULL;

    if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIRQ, sizeof(DWORD), &m_dwSysIntr2D, sizeof(DWORD), NULL))
    {
        m_dwSysIntr2D = SYSINTR_UNDEFINED;
        return FALSE;
    }
    RETAILMSG(DISP_ZONE_INIT, (TEXT("2D Sysintr : %d\r\n"),m_dwSysIntr2D));

    m_hInterrupt2D = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(NULL == m_hInterrupt2D)
    {
        return FALSE;
    }

    if (!(InterruptInitialize(m_dwSysIntr2D, m_hInterrupt2D, 0, 0)))
    {
        return FALSE;
    }
    return TRUE;
}

void FIMGSE2D::DeinitInterrupt(void)
{
    if (m_dwSysIntr2D != SYSINTR_UNDEFINED)
    {
        InterruptDisable(m_dwSysIntr2D);
    }

    if (m_hInterrupt2D != NULL)
    {
        CloseHandle(m_hInterrupt2D);
    }

    if (m_dwSysIntr2D != SYSINTR_UNDEFINED)
    {
        KernelIoControl(IOCTL_HAL_RELEASE_SYSINTR, &m_dwSysIntr2D, sizeof(DWORD), NULL, 0, NULL);
    }
}