ddoverlay.cpp

来自「6410BSP3」· C++ 代码 · 共 936 行 · 第 1/3 页

    if (m_OverlayCtxt.uiDstWidth+m_OverlayCtxt.uiDstOffsetX > (unsigned int)m_dwDeviceScreenWidth)
    {
        //m_OverlayCtxt.uiDstWidth = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstOffsetX;    // Adjust Width
        m_OverlayCtxt.uiDstOffsetX = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstWidth;        // Adjust Offset
    }

    if (m_OverlayCtxt.uiDstHeight+m_OverlayCtxt.uiDstOffsetY  > (unsigned int)m_dwDeviceScreenHeight)
    {
        //m_OverlayCtxt.uiDstHeight = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstOffsetY;    // Adjust Height
        m_OverlayCtxt.uiDstOffsetY  = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstHeight;    // Adjust Offset
    }

    // Update TV DMA Context
    if (m_eTVDMAMode == TV_DMA_OVERLAY)
    {
        DevUpdateTVDMAContext();
    }

    DevOverlayInitialize();

CleanUp:

    LeaveCriticalSection(&m_csDevice);

    return bRet;
}


void
S3C6410Disp::OverlaySetPosition(UINT32 uiOffsetX, UINT32 uiOffsetY)
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("OverlaySetPosition(%d,%d)\n\r"), uiOffsetX, uiOffsetY));

    EnterCriticalSection(&m_csDevice);

    switch(m_iRotate)
    {
    case DMDO_0:
    default:
        m_OverlayCtxt.uiDstOffsetX = uiOffsetX;
        m_OverlayCtxt.uiDstOffsetY = uiOffsetY;
        break;
    case DMDO_90:
        m_OverlayCtxt.uiDstOffsetX = uiOffsetY;
        m_OverlayCtxt.uiDstOffsetY = m_pPrimarySurface->ScreenHeight()
                                        - m_OverlayCtxt.uiDstHeight - uiOffsetX;
        break;
    case DMDO_180:
        m_OverlayCtxt.uiDstOffsetX = m_pPrimarySurface->ScreenWidth()
                                        - m_OverlayCtxt.uiDstWidth - uiOffsetX;
        m_OverlayCtxt.uiDstOffsetY = m_pPrimarySurface->ScreenHeight()
                                        - m_OverlayCtxt.uiDstHeight - uiOffsetY;
        break;
    case DMDO_270:
        m_OverlayCtxt.uiDstOffsetX = m_pPrimarySurface->ScreenWidth()
                                        - m_OverlayCtxt.uiDstWidth - uiOffsetY;
        m_OverlayCtxt.uiDstOffsetY = uiOffsetX;
        break;
    }

    // Adjust for Post Processor and FIMD restriction
    if (m_OverlayCtxt.pSurface->PixelFormat() == ddgpePixelFormat_565)
    {
        m_OverlayCtxt.uiDstOffsetX = m_OverlayCtxt.uiDstOffsetX-m_OverlayCtxt.uiDstOffsetX%2;
    }

    // Adjust for Overlay Window Position
    if (m_OverlayCtxt.uiDstWidth+m_OverlayCtxt.uiDstOffsetX > (unsigned int)m_dwDeviceScreenWidth)
    {
        //m_OverlayCtxt.uiDstWidth = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstOffsetX;    // Adjust Width
        m_OverlayCtxt.uiDstOffsetX = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstWidth;        // Adjust Offset
    }

    if (m_OverlayCtxt.uiDstHeight+m_OverlayCtxt.uiDstOffsetY  > (unsigned int)m_dwDeviceScreenHeight)
    {
        //m_OverlayCtxt.uiDstHeight = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstOffsetY;    // Adjust Height
        m_OverlayCtxt.uiDstOffsetY  = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstHeight;    // Adjust Offset
    }

    DevOverlaySetPosition();

    LeaveCriticalSection(&m_csDevice);
}


void
S3C6410Disp::OverlayEnable(void)
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] %s()\n\r"), _T(__FUNCTION__)));

    EnterCriticalSection(&m_csDevice);

    m_OverlayCtxt.bShow = TRUE;

    DevOverlayEnable();

    if (m_eTVDMAMode == TV_DMA_OVERLAY)
    {
        DevOutputEnableTVDMA();
    }

    LeaveCriticalSection(&m_csDevice);
}


void
S3C6410Disp::OverlayDisable(void)
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] %s()\n\r"), _T(__FUNCTION__)));

    m_OverlayCtxt.pSurface = NULL;
    m_OverlayCtxt.pPrevSurface = NULL;

    m_OverlayCtxt.bShow = FALSE;

    EnterCriticalSection(&m_csDevice);

    DevOverlayDisable();

    // Update TV DMA Context
    if (m_eTVDMAMode == TV_DMA_OVERLAY)
    {
        DevOutputDisableTVDMA();
    }

    LeaveCriticalSection(&m_csDevice);

    // Release H/W Resource for Overlay to Video Engine Driver
    OverlayReleaseResource(m_OverlayCtxt.bLocalPath);
}


void
S3C6410Disp::OverlayBlendDisable()
{
    m_OverlayCtxt.bBlendOn = FALSE;
    DevOverlayBlendDisable();
}


void
S3C6410Disp::OverlaySetColorKey(BOOL bSrcCKey, EDDGPEPixelFormat Format, DWORD ColorKey)
{
    m_OverlayCtxt.bBlendOn = TRUE;
    m_OverlayCtxt.bColorKey = TRUE;
    m_OverlayCtxt.bSrcCKey = bSrcCKey;

    if (Format == ddgpePixelFormat_565)    // RGB565
    {
        m_OverlayCtxt.ColorKey =
                    (((ColorKey&0xF800)>>11)<<19) |    // R bit
                    (((ColorKey&0x07E0)>>5)<<10) |    // G bit
                    ((ColorKey&0x001F)<<3);            // B bit
        m_OverlayCtxt.CompareKey = 0x00070307;
    }
    else    // if (Format == ddgpePixelFormat_8888)    // RGB888
    {
        m_OverlayCtxt.ColorKey = ColorKey;
        m_OverlayCtxt.CompareKey = 0x00000000;
    }

    DevOverlaySetColorKey();
}

void
S3C6410Disp::OverlaySetAlpha(BOOL bUsePixelBlend, DWORD Alpha)
{
    m_OverlayCtxt.bBlendOn = TRUE;
    m_OverlayCtxt.bColorKey = FALSE;
    m_OverlayCtxt.bUsePixelBlend = bUsePixelBlend;
    m_OverlayCtxt.Alpha = Alpha;

    DevOverlaySetAlpha();
}


void
S3C6410Disp::InitalizeOverlayContext(void)
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++InitalizeOverlayContext()\n\r")));

    m_OverlayCtxt.pSurface = NULL;            // Current Overlay Surface
    m_OverlayCtxt.pPrevSurface = NULL;

    m_OverlayCtxt.bLocalPath = FALSE;
    m_OverlayCtxt.uiSrcWidth = 0;
    m_OverlayCtxt.uiSrcHeight = 0;
    m_OverlayCtxt.uiSrcOffsetX = 0;
    m_OverlayCtxt.uiSrcOffsetY = 0;
    m_OverlayCtxt.uiDstWidth = 0;
    m_OverlayCtxt.uiDstHeight = 0;
    m_OverlayCtxt.uiDstOffsetX = 0;
    m_OverlayCtxt.uiDstOffsetY = 0;
    m_OverlayCtxt.bEnabled = FALSE;
    m_OverlayCtxt.bShow = FALSE;

    m_OverlayCtxt.bBlendOn = FALSE;
    m_OverlayCtxt.bColorKey = 0x0;
    m_OverlayCtxt.bSrcCKey = FALSE;
    m_OverlayCtxt.CompareKey = 0x0;
    m_OverlayCtxt.ColorKey = 0x0;
    m_OverlayCtxt.bUsePixelBlend = FALSE;
    m_OverlayCtxt.Alpha = 0x0;

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] --InitalizeOverlayContext()\n\r")));
}


S3C6410Surf*
S3C6410Disp::GetCurrentOverlaySurf(void)
{
    return m_OverlayCtxt.pSurface;
}


S3C6410Surf*
S3C6410Disp::GetPreviousOverlaySurf(void)
{
    return m_OverlayCtxt.pPrevSurface;
}

void
S3C6410Disp::DevSetVisibleSurface(S3C6410Surf *pSurf, BOOL bWaitForVBlank)
{
    unsigned int uiBuffer;
    BOOL bRetry = TRUE;
    DWORD dwBytes;

    if (!pSurf)
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] %s() : pSurf is NULL\r\n"),_T(__FUNCTION__)));
        return;
    }

    if (pSurf->IsOverlay() == TRUE)
    {
        if (m_OverlayCtxt.bLocalPath)
        {
            SVEARG_POST_BUFFER tParam;

            tParam.dwBufferRGBY = m_OverlayCtxt.pSurface->OffsetInVideoMemory() + m_VideoMemoryPhysicalBase;
            tParam.dwBufferCb = tParam.dwBufferRGBY+m_OverlayCtxt.pSurface->m_uiOffsetCb;
            tParam.dwBufferCr = tParam.dwBufferRGBY+m_OverlayCtxt.pSurface->m_uiOffsetCr;
            tParam.bWaitForVSync = bWaitForVBlank;

            if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_POST_SET_NEXT_SOURCE_BUFFER, &tParam, sizeof(SVEARG_POST_BUFFER), NULL, 0, &dwBytes, NULL) )
            {
                RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DevOverlayInitialize() : IOCTL_SVE_POST_SET_NEXT_SOURCE_BUFFER Failed\n\r")));
            }
        }
        else
        {
            SVEARG_FIMD_WIN_FRAMEBUFFER tParam;

            // Change Frame Buffer
            tParam.dwWinNum = OVERLAY_WINDOW;
            tParam.dwFrameBuffer = pSurf->OffsetInVideoMemory() + m_VideoMemoryPhysicalBase;
            tParam.bWaitForVSync = bWaitForVBlank;
            if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_FIMD_SET_WINDOW_FRAMEBUFFER, &tParam, sizeof(SVEARG_FIMD_WIN_FRAMEBUFFER), NULL, 0, &dwBytes, NULL) )
            {
                RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] %s() : IOCTL_SVE_FIMD_SET_WINDOW_FRAMEBUFFER Failed\n\r"), _T(__FUNCTION__)));
            }
        }

        //---------------
        // For TV Out DMA
        //---------------
        if (m_eTVDMAMode == TV_DMA_OVERLAY)
        {
            uiBuffer = (unsigned int)(pSurf->OffsetInVideoMemory() + m_VideoMemoryPhysicalBase);
            DevSetTVDMABuffer(uiBuffer, uiBuffer+pSurf->m_uiOffsetCb, uiBuffer+pSurf->m_uiOffsetCr, bWaitForVBlank);
        }
    }
    else
    {
        SVEARG_FIMD_WIN_FRAMEBUFFER tParam;

        // Change Frame Buffer
        tParam.dwWinNum = PRIMARY_WINDOW;
        tParam.dwFrameBuffer = pSurf->OffsetInVideoMemory() + m_VideoMemoryPhysicalBase;
        tParam.bWaitForVSync = bWaitForVBlank;
        if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_FIMD_SET_WINDOW_FRAMEBUFFER, &tParam, sizeof(SVEARG_FIMD_WIN_FRAMEBUFFER), NULL, 0, &dwBytes, NULL) )
        {
            RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DevSetVisibleSurface() : IOCTL_SVE_FIMD_SET_WINDOW_FRAMEBUFFER Failed\n\r")));
        }

        //---------------
        // For TV Out DMA
        //---------------
        if (m_eTVDMAMode == TV_DMA_PRIMARY)
        {
            uiBuffer = (unsigned int)(pSurf->OffsetInVideoMemory() + m_VideoMemoryPhysicalBase);
            DevSetTVDMABuffer(uiBuffer, uiBuffer+pSurf->m_uiOffsetCb, uiBuffer+pSurf->m_uiOffsetCr, bWaitForVBlank);
        }
    }
}


void
S3C6410Disp::DevOverlayInitialize(void)
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++DevOverlayInitialize()\n\r")));

    DWORD dwBytes;

    // Display Overlay Window
    if (m_OverlayCtxt.bEnabled)
    {
        RETAILMSG(DISP_ZONE_TEMP, (_T("[DDHAL] DevOverlayInitialize() : Disable Overlay\n\r")));
        DevOverlayDisable();
    }