//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
// Copyright (c) Samsung Electronics. Co. LTD. All rights reserved.

/*++

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:

    ddoverlay.cpp

Abstract:

    This module implements the main class that derived from DDGPE of display driver to support DirectDraw
    In this part, there are codes that implement base logical HW control functions to use DirectDraw Overlay

Functions:

    Overlay Resource Control, Overlay Enable/Disable

Notes:

--*/

#include "precomp.h"

BOOL
S3C6410Disp::OverlayAllocResource(BOOL bLocalPath)
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++%s(%d)\n\r"), _T(__FUNCTION__), bLocalPath));

    DWORD dwBytes;

    // Request FIMD Win0 H/W Resource to Video Engine Driver for Overlay Window
    if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_REQUEST_FIMD_WIN0, NULL, 0, NULL, 0, &dwBytes, NULL) )
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] %s() : IOCTL_SVE_RSC_REQUEST_FIMD_WIN0 Failed\n\r"), _T(__FUNCTION__)));
        goto AllocFail;
    }

    if (bLocalPath)
    {
        // Request Post Processor H/W Resource to Video Engine Driver for Overlay Window
        if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_REQUEST_POST, NULL, 0, NULL, 0, &dwBytes, NULL) )
        {
            RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] %s() : IOCTL_SVE_RSC_REQUEST_POST Failed\n\r"), _T(__FUNCTION__)));
            goto AllocFail;
        }
    }

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] --%s()\n\r"), _T(__FUNCTION__)));

    return TRUE;

AllocFail:

    // Release Partially Allocated Resource
    OverlayReleaseResource(bLocalPath);

    RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] --%s() : Failed\n\r"), _T(__FUNCTION__)));

    return FALSE;
}


BOOL
S3C6410Disp::OverlayReleaseResource(BOOL bLocalPath)
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++%s(%d)\n\r"), _T(__FUNCTION__), bLocalPath));

    BOOL bRet = TRUE;
    DWORD dwBytes;

    // Release FIMD Win0 H/W Resource to Video Engine Driver for Overlay Window
    if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_RELEASE_FIMD_WIN0, NULL, 0, NULL, 0, &dwBytes, NULL) )
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] %s() : IOCTL_SVE_RSC_RELEASE_FIMD_WIN0 Failed\n\r"), _T(__FUNCTION__)));
        bRet = FALSE;
    }

    if (bLocalPath)
    {
        // Release Post Processor H/W Resource to Video Engine Driver for Overlay Window
        if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_RELEASE_POST, NULL, 0, NULL, 0, &dwBytes, NULL) )
        {
            RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] %s() : IOCTL_SVE_RSC_RELEASE_POST Failed\n\r"), _T(__FUNCTION__)));
            bRet = FALSE;
        }
    }

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] --%s()\n\r"), _T(__FUNCTION__)));

    return bRet;
}


BOOL
S3C6410Disp::OverlayInitialize(S3C6410Surf* pOverlaySurface, RECT *pSrc, RECT *pDest)
{
    BOOL bRet = TRUE;

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DDHAL:INF] OverlayInitialize() (%d,%d) (%d,%d,%d,%d) (%d,%d,%d,%d)\n\r"),
                    pOverlaySurface->Width(), pOverlaySurface->Height(),
                    pSrc->left, pSrc->top, pSrc->right, pSrc->bottom,
                    pDest->left, pDest->top, pDest->right, pDest->bottom));

    EnterCriticalSection(&m_csDevice);

    m_OverlayCtxt.pSurface = pOverlaySurface;

    switch(m_iRotate)
    {
    case DMDO_0:
    default:
        // Driver support Overlay Source Clipping
        m_OverlayCtxt.uiSrcWidth = pSrc->right - pSrc->left;
        m_OverlayCtxt.uiSrcHeight = pSrc->bottom - pSrc->top;
        m_OverlayCtxt.uiSrcOffsetX = pSrc->left;
        m_OverlayCtxt.uiSrcOffsetY = pSrc->top;

        //  Driver support Overlay Destination Stretch
        m_OverlayCtxt.uiDstWidth = pDest->right - pDest->left;
        m_OverlayCtxt.uiDstHeight = pDest->bottom - pDest->top;
        m_OverlayCtxt.uiDstOffsetX = pDest->left;
        m_OverlayCtxt.uiDstOffsetY = pDest->top;
        break;
    case DMDO_90:
        // Driver support Overlay Source Clipping
        m_OverlayCtxt.uiSrcWidth = pSrc->bottom - pSrc->top;
        m_OverlayCtxt.uiSrcHeight = pSrc->right - pSrc->left;
        m_OverlayCtxt.uiSrcOffsetX = pSrc->top;
        m_OverlayCtxt.uiSrcOffsetY = pOverlaySurface->Height()
                                        - m_OverlayCtxt.uiSrcHeight - pSrc->left;

        //  Driver support Overlay Destination Stretch
        m_OverlayCtxt.uiDstWidth = pDest->bottom - pDest->top;
        m_OverlayCtxt.uiDstHeight = pDest->right - pDest->left;
        m_OverlayCtxt.uiDstOffsetX = pDest->top;
        m_OverlayCtxt.uiDstOffsetY = m_pPrimarySurface->ScreenHeight()
                                        - m_OverlayCtxt.uiDstHeight - pDest->left;
        break;
    case DMDO_180:
        // Driver support Overlay Source Clipping
        m_OverlayCtxt.uiSrcWidth = pSrc->right - pSrc->left;
        m_OverlayCtxt.uiSrcHeight = pSrc->bottom - pSrc->top;
        m_OverlayCtxt.uiSrcOffsetX = pOverlaySurface->Width()
                                        - m_OverlayCtxt.uiSrcWidth - pSrc->left;
        m_OverlayCtxt.uiSrcOffsetY = pOverlaySurface->Height()
                                        - m_OverlayCtxt.uiSrcHeight - pSrc->top;

        //  Driver support Overlay Destination Stretch
        m_OverlayCtxt.uiDstWidth = pDest->right - pDest->left;
        m_OverlayCtxt.uiDstHeight = pDest->bottom - pDest->top;
        m_OverlayCtxt.uiDstOffsetX = m_pPrimarySurface->ScreenWidth()
                                        - m_OverlayCtxt.uiDstWidth - pDest->left;
        m_OverlayCtxt.uiDstOffsetY = m_pPrimarySurface->ScreenHeight()
                                        - m_OverlayCtxt.uiDstHeight - pDest->top;
        break;
    case DMDO_270:
        // Driver support Overlay Source Clipping
        m_OverlayCtxt.uiSrcHeight = pSrc->right - pSrc->left;
        m_OverlayCtxt.uiSrcWidth = pSrc->bottom - pSrc->top;
        m_OverlayCtxt.uiSrcOffsetX = pOverlaySurface->Width()
                                        - m_OverlayCtxt.uiSrcWidth - pSrc->top;;
        m_OverlayCtxt.uiSrcOffsetY = pSrc->left;

        //  Driver support Overlay Destination Stretch
        m_OverlayCtxt.uiDstHeight = pDest->right - pDest->left;
        m_OverlayCtxt.uiDstWidth = pDest->bottom - pDest->top;
        m_OverlayCtxt.uiDstOffsetX = m_pPrimarySurface->ScreenWidth()
                                        - m_OverlayCtxt.uiDstWidth - pDest->top;
        m_OverlayCtxt.uiDstOffsetY = pDest->left;
        break;
    }

    switch(m_OverlayCtxt.pSurface->PixelFormat())
    {
    case ddgpePixelFormat_I420:    // YUV420
    case ddgpePixelFormat_YV12:    // YVU420
        m_OverlayCtxt.bLocalPath = TRUE;
        m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
        m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
        m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV420;
        break;
    case ddgpePixelFormat_YUYV:    // YUV422 (YCbYCr)
    case ddgpePixelFormat_YUY2:    // YUV422 (YCbYCr)
        m_OverlayCtxt.bLocalPath = TRUE;
        m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
        m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
        m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_CRYCBY;
        break;
    case ddgpePixelFormat_UYVY:    // YUV422 (CbYCrY)
        m_OverlayCtxt.bLocalPath = TRUE;
        m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
        m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
        m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_YCRYCB;
        break;
    case ddgpePixelFormat_YVYU:    // YUV422 (YCrYCb)
        m_OverlayCtxt.bLocalPath = TRUE;
        m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
        m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
        m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_CBYCRY;
        break;
    case ddgpePixelFormat_VYUY:    // YUV422 (CrYCbY)
        m_OverlayCtxt.bLocalPath = TRUE;
        m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
        m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
        m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_YCBYCR;
        break;
    case ddgpePixelFormat_565:
        if (    (m_OverlayCtxt.uiSrcWidth == pOverlaySurface->Width())
            && (m_OverlayCtxt.uiSrcHeight == pOverlaySurface->Height())
            && (m_OverlayCtxt.uiDstWidth == pOverlaySurface->Width())
            && (m_OverlayCtxt.uiDstHeight == pOverlaySurface->Height()))
        {
            // No Clipping and No Stretch, Don't Use Local Path for RGB
            m_OverlayCtxt.bLocalPath = FALSE;
            m_OverlayCtxt.dwWinMode = DISP_WIN0_DMA;
            m_OverlayCtxt.dwBPPMode = DISP_16BPP_565;
        }
        else
        {
            // Use Local Path for RGB
            m_OverlayCtxt.bLocalPath = TRUE;
            m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
            m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
            m_OverlayCtxt.dwPostSrcType = POST_SRC_RGB16;
        }
        break;
    //case ddgpePixelFormat_8880:    // FIMD can not support Packed RGB888
    case ddgpePixelFormat_8888:
        if (    (m_OverlayCtxt.uiSrcWidth == pOverlaySurface->Width())
            && (m_OverlayCtxt.uiSrcHeight == pOverlaySurface->Height())
            && (m_OverlayCtxt.uiDstWidth == pOverlaySurface->Width())
            && (m_OverlayCtxt.uiDstHeight == pOverlaySurface->Height()))
        {
            // No Clipping and No Stretch, Don't Use Local Path for RGB
            m_OverlayCtxt.bLocalPath = FALSE;
            m_OverlayCtxt.dwWinMode = DISP_WIN0_DMA;
            m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
        }
        else
        {
            // Use Local Path for RGB
            m_OverlayCtxt.bLocalPath = TRUE;
            m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
            m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
            m_OverlayCtxt.dwPostSrcType = POST_SRC_RGB24;
        }
        break;
    }

    // Request H/W Resource for Overlay to Video Engine Driver
    if (OverlayAllocResource(m_OverlayCtxt.bLocalPath) == FALSE)
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] OverlayInitialize() : OverlayAllocResource() Failed\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    // Adjust for Post Processor and FIMD restriction
    switch(m_OverlayCtxt.pSurface->PixelFormat())
    {
    case ddgpePixelFormat_I420:
    case ddgpePixelFormat_YV12:
        m_OverlayCtxt.uiSrcWidth = m_OverlayCtxt.uiSrcWidth-m_OverlayCtxt.uiSrcWidth%8;
        m_OverlayCtxt.uiSrcHeight = m_OverlayCtxt.uiSrcHeight-m_OverlayCtxt.uiSrcHeight%2;
        m_OverlayCtxt.uiSrcOffsetX = m_OverlayCtxt.uiSrcOffsetX-m_OverlayCtxt.uiSrcOffsetX%8;

        if (m_OverlayCtxt.uiSrcWidth < 8) m_OverlayCtxt.uiSrcWidth = 8;
        if (m_OverlayCtxt.uiSrcHeight < 4) m_OverlayCtxt.uiSrcHeight = 4;
        if (m_OverlayCtxt.uiDstHeight < 3) m_OverlayCtxt.uiDstHeight = 3;
        break;
    case ddgpePixelFormat_YUYV:
    case ddgpePixelFormat_YUY2:
    case ddgpePixelFormat_UYVY:
    case ddgpePixelFormat_YVYU:
    case ddgpePixelFormat_VYUY:
        m_OverlayCtxt.uiSrcWidth = m_OverlayCtxt.uiSrcWidth-m_OverlayCtxt.uiSrcWidth%2;
        m_OverlayCtxt.uiSrcHeight = m_OverlayCtxt.uiSrcHeight-m_OverlayCtxt.uiSrcHeight%2;
        m_OverlayCtxt.uiSrcOffsetX = m_OverlayCtxt.uiSrcOffsetX-m_OverlayCtxt.uiSrcOffsetX%2;

        if (m_OverlayCtxt.uiSrcWidth < 2) m_OverlayCtxt.uiSrcWidth = 2;
        if (m_OverlayCtxt.uiSrcHeight < 2) m_OverlayCtxt.uiSrcHeight = 2;
        break;
    case ddgpePixelFormat_565:
        m_OverlayCtxt.uiSrcWidth = m_OverlayCtxt.uiSrcWidth-m_OverlayCtxt.uiSrcWidth%2;
        m_OverlayCtxt.uiSrcHeight = m_OverlayCtxt.uiSrcHeight-m_OverlayCtxt.uiSrcHeight%2;
        m_OverlayCtxt.uiSrcOffsetX = m_OverlayCtxt.uiSrcOffsetX-m_OverlayCtxt.uiSrcOffsetX%2;

        m_OverlayCtxt.uiDstWidth = m_OverlayCtxt.uiDstWidth-m_OverlayCtxt.uiDstWidth%2;
        m_OverlayCtxt.uiDstOffsetX = m_OverlayCtxt.uiDstOffsetX-m_OverlayCtxt.uiDstOffsetX%2;

        if (m_OverlayCtxt.uiSrcWidth < 2) m_OverlayCtxt.uiSrcWidth = 2;
        if (m_OverlayCtxt.uiSrcHeight < 2) m_OverlayCtxt.uiSrcHeight = 2;
        if (m_OverlayCtxt.uiDstWidth < 2) m_OverlayCtxt.uiDstWidth = 2;
        break;
    }

    // Adjust for Overlay Window Position