fimgse2d.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

    return ;
#endif

}

/**
 * Draw Line
 * (usPosX1, usPosY1) ~ (usPosX2, usPosY2)
 * Do not draw last point
 *   0 < usPosX, usPosY1, usPosX2, usPosY2 < 2048
 */
void FIMGSE2D::PutLine(DWORD usPosX1, DWORD usPosY1, DWORD usPosX2, DWORD usPosY2, DWORD uColor, bool bIsDrawLastPoint) //modification
{
    int nMajorCoordX;
    DWORD uHSz, uVSz;
    int i;
    int nIncr=0;
    DWORD uCmdRegVal;

    CheckFifo(7);

    m_pG2DReg->COORD0_X = usPosX1;
    m_pG2DReg->COORD0_Y = usPosY1;
    m_pG2DReg->COORD2_X = usPosX2;
    m_pG2DReg->COORD2_Y = usPosY2;    

    RETAILMSG(0,(TEXT("COORD0_X: %d, COORD0_Y:%d, COORD2_X:%d, COORD2_Y:%d\n"), 
            m_pG2DReg->COORD0 & (0x7ff),
            (m_pG2DReg->COORD0 & (0x7ff<<16)) >> 16,            
            m_pG2DReg->COORD2 & (0x7ff),
            (m_pG2DReg->COORD2 & (0x7ff<<16)) >> 16));            
    RETAILMSG(0,(TEXT("CLIP_LT_X: %d, CLIP_LT_Y:%d, CLIP_RB_X:%d, CLIP_RB_Y:%d\n"), 
            m_pG2DReg->CW_LEFT_TOP & (0x7ff),
            (m_pG2DReg->CW_LEFT_TOP & (0x7ff<<16)) >> 16,            
            m_pG2DReg->CW_RIGHT_BOTTOM & (0x7ff),
            (m_pG2DReg->CW_RIGHT_BOTTOM & (0x7ff<<16)) >> 16));                

    uVSz = ABS((WORD)usPosY1 - (WORD)usPosY2);
    uHSz = ABS((WORD)usPosX1 - (WORD)usPosX2);

    nMajorCoordX = (uHSz>=uVSz);

    if(nMajorCoordX)
    {
        for (i=0; i<12; i++)
        {
            uVSz <<= 1;
            nIncr <<= 1;
            if (uVSz >= uHSz)
            {
                nIncr = nIncr | 1;
                uVSz -= uHSz;
            }
        }
        nIncr = (nIncr + 1) >> 1;
        if (usPosY1 > usPosY2)
        {
            nIncr = (~nIncr) + 1; // 2's complement
        }
//        printf("pre YINCR: %x  ", nIncr );                        
  }
    else
    {
        for (i=0; i<12; i++)
        {
            uHSz <<= 1;
            nIncr <<= 1;
            if (uHSz >= uVSz)
            {
                nIncr = nIncr | 1;
                uHSz -= uVSz;
            }
        }
        nIncr = (nIncr + 1) >> 1;
        if (usPosX1 > usPosX2)
        {
            nIncr = (~nIncr) + 1; // 2's complement
        }
//        printf("pre XINCR: %x  ", nIncr );                
    }

    m_pG2DReg->FG_COLOR = uColor;

    uCmdRegVal = 0;

    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(0,(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(0,(TEXT("CMD: %x, XINCR: %x, YINCR: %x\n"), uCmdRegVal, m_pG2DReg->X_INCR, m_pG2DReg->Y_INCR ));
    }

#if    (G2D_CMDPROCESSING==G2D_FASTRETURN)
    WaitForEmptyFifo();        //< This is check fully empty command fifo.
    m_pG2DReg->CMDR0 = uCmdRegVal;
#elif (G2D_CMDPROCESSING==G2D_INTERRUPT)
    CheckFifo(1);
    IntEnable();    
    m_pG2DReg->CMDR0 = uCmdRegVal;
    WaitForSingleObject(m_hInterrupt2D, INFINITE);

    IntDisable();    
    IntPendingClear();    

    InterruptDone(m_dwSysIntr2D);
#elif (G2D_CMDPROCESSING==G2D_BUSYWAITING)
    CheckFifo(1);
    IntEnable();    
    while(!WaitForFinish());                        // Polling Style    
    m_pG2DReg->CMDR0 = uCmdRegVal;

    IntDisable();    
#else
    RETAILMSG(TRUE,(TEXT("CMDPROCESSING TYPE is invalid, Please Check Header Definition\n")));
    return FALSE;
#endif

    
}


/**
*    @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)
{    
    CheckFifo(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)
{
    CheckFifo(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) ? 1 :    0;
}

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  ARGB8: // 15 bit color mode
            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 RGB18 : // 18 bit color mode
            uRed = uSrcData & 0x0003f000;
            uGreen = uSrcData & 0x00000fc0;
            uBlue = uSrcData & 0x0000003f;
    
            *uConvertedData = uRed<<6 | uGreen<<4 | uBlue<<2;
            break;

        case RGB24 : // 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 :
            Assert(0);
            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(1, (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);
    }    
}