sa2video.cpp

Windows CE 6.0 BSP for VOIPAC Board (PXA270) Version 2b.

        }
        case IOCTL_POWER_CAPABILITIES:
            if ( pvOut != NULL && cjOut == sizeof(POWER_CAPABILITIES) )
            {
                DEBUGMSG(ZONE_PM, (TEXT("SA2Video::SA2VIDEO:IOCTL_POWER_CAPABILITIES\r\n")));
                PPOWER_CAPABILITIES PowerCaps = (PPOWER_CAPABILITIES) pvOut;

                memcpy(PowerCaps, &DisplayDrvPowerCaps, sizeof(DisplayDrvPowerCaps));
                RetVal = 1;
            }
            else
            {
                SetLastError(MMSYSERR_INVALPARAM);
                RetVal = -1;
            }
            break;

        case IOCTL_POWER_QUERY:
            DEBUGMSG(ZONE_PM, (TEXT("SA2VIDEO::IOCTL_POWER_QUERY\r\n")));
            if ( pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE) )
            {
                // Return a good status on any valid query since
                // we are always ready to change power states.
                NewDx = *(PCEDEVICE_POWER_STATE) pvOut;

                if ( ! VALID_DX(NewDx) )
                {
                    DEBUGMSG(ZONE_PM, (TEXT("SA2VIDEO::IOCTL_POWER_QUERY-(D%d) success\r\n"),NewDx));
                    RetVal = 1;
                    bErr = FALSE;
                }
            }

            if (bErr)
            {
                RETAILMSG(1, (TEXT("SA2VIDEO::IOCTL_POWER_QUERY-(D%d) failed\r\n"),NewDx));
                SetLastError(MMSYSERR_INVALPARAM);
                RetVal = -1;
            }
            break;

        case IOCTL_POWER_SET:
            if ( pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE) )
            {
                NewDx = *(PCEDEVICE_POWER_STATE)pvOut;

                if ( VALID_DX(NewDx) )
                {
                    DEBUGMSG(ZONE_PM, (TEXT("SA2VIDEO::IOCTL_POWER_SET-(D%d) success\r\n"), NewDx));
                    SetPmPowerState(NewDx);
                    RetVal = 1;
                    bErr = FALSE;
                }
            }

            if (bErr)
            {
                RETAILMSG(1, (TEXT("SA2VIDEO::IOCTL_POWER_SET-(D%d) failed\r\n"), NewDx));
                SetLastError(MMSYSERR_INVALPARAM);
                RetVal = -1;
            }
            break;

        case IOCTL_POWER_GET:
            DEBUGMSG(ZONE_PM, (TEXT("SA2VIDEO::IOCTL_POWER_GET\r\n")));
            if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
            {
                *(PCEDEVICE_POWER_STATE) pvOut = GetPmPowerState();
                RetVal = 1;
            }
            break;

        case QUERYESCSUPPORT:
            EscapeFunction = *(DWORD *)pvIn;
            if ((EscapeFunction == VERTICALBLANKINTERRUPT)   ||
                (EscapeFunction == SCROLL)                   ||
                (EscapeFunction == SETPOWERMANAGEMENT)       ||
                (EscapeFunction == GETPOWERMANAGEMENT)       ||
                (EscapeFunction == IOCTL_POWER_CAPABILITIES) ||
                (EscapeFunction == IOCTL_POWER_QUERY) ||
                (EscapeFunction == IOCTL_POWER_SET) ||
                (EscapeFunction == IOCTL_POWER_GET) ||
                (EscapeFunction == GETGXINFO))
            {
                RetVal = 1;
            }
            else if ((!g_fDisableRotation) &&
                ((EscapeFunction == DRVESC_GETSCREENROTATION) ||
                (EscapeFunction == DRVESC_SETSCREENROTATION)))
            {
                RetVal = 1;
            }
            break;

        case VERTICALBLANKINTERRUPT:
            RetVal = 1;
            break;

        case SCROLL:
            ScrollBuffer(cjIn);
            break;

        case DRVESC_GETSCREENROTATION:
            if (!g_fDisableRotation)
            {
                *(int *)pvOut = ((DMDO_0 | DMDO_90 | DMDO_180 | DMDO_270) << 8) | ((BYTE)m_iRotate);
                return DISP_CHANGE_SUCCESSFUL;
            }
            else
            {
                return DISP_CHANGE_FAILED;
            }
            break;

        case DRVESC_SETSCREENROTATION:
            if ((!g_fDisableRotation) &&
                ((cjIn == DMDO_0)    ||
                (cjIn == DMDO_90)    ||
                (cjIn == DMDO_180)    ||
                (cjIn == DMDO_270)))
                {
                    return DynRotate(cjIn);
                }

            return DISP_CHANGE_BADMODE;
            break;

        case GETGXINFO:
            // Fill out the GAPI data structure.  Assumes 16bpp or 8bpp, with RGB565 format.
            // Must change cBPP and ffFormat fields to accomodate other formats.
            // All of the button data that follows must be filled out to match the specific OEM device.
            // The data that is used to fill out the data structure here is copied from
            // the Microsoft example.
            if ((cjOut >= sizeof(GXDeviceInfo)) && (pvOut != NULL) )
            {
                if (((GXDeviceInfo *) pvOut)->idVersion == kidVersion100)
                {
                    pgxoi = (GXDeviceInfo *) pvOut;
                    pgxoi->idVersion = kidVersion100;
                    pgxoi->pvFrameBuffer = (void *) FRAME_BUFFER_0_BASE_VIRTUAL;

                    // cbStride reflects the physical properties of the display regardless of orientation.
                    // Using a native portrait mode display, stride will always be 480.
                    // If using native landscape mode display, stride would be 640.
                    if (((DispDrvr_cxScreen == 240) && (DispDrvr_cyScreen == 320)) ||
                        ((DispDrvr_cxScreen == 320) && (DispDrvr_cyScreen == 240)) )
                    {
                        if (bpp == 16)
                        {
                            pgxoi->cbStride = 480;
                            pgxoi->cBPP = 16;
                        }
                        if (bpp == 8)
                        {
                            pgxoi->cbStride = 240;
                            pgxoi->cBPP = 16;
                        }
                    }

                    // Using a native landscape mode display, stride will always be 1280.
                    // If using native portrait mode display, stride would be 960.

                    if (((DispDrvr_cxScreen == 480) && (DispDrvr_cyScreen == 640)) ||
                        ((DispDrvr_cxScreen == 640) && (DispDrvr_cyScreen == 480)) )
                    {
                        if (bpp == 16)
                        {
                            pgxoi->cbStride = 1280;
                            pgxoi->cBPP = 16;
                        }
                        if (bpp == 8)
                        {
                            pgxoi->cbStride = 640;
                            pgxoi->cBPP = 16;
                        }
                    }


                    pgxoi->cxWidth = DispDrvr_cxScreen;
                    pgxoi->cyHeight = DispDrvr_cyScreen;

                    // Set kfLandscape only if the display orientation is not in its native format
                    pgxoi->ffFormat= kfDirect565;


                    pgxoi->vkButtonUpPortrait = VK_UP;
                    pgxoi->vkButtonUpLandscape = VK_LEFT;
                    pgxoi->ptButtonUp.x = 120;
                    pgxoi->ptButtonUp.y = 350;
                    pgxoi->vkButtonDownPortrait = VK_DOWN;
                    pgxoi->vkButtonDownLandscape = VK_RIGHT;
                    pgxoi->ptButtonDown.x = 120;
                    pgxoi->ptButtonDown.y = 390;
                    pgxoi->vkButtonLeftPortrait = VK_LEFT;
                    pgxoi->vkButtonLeftLandscape = VK_DOWN;
                    pgxoi->ptButtonLeft.x = 100;
                    pgxoi->ptButtonLeft.y = 370;
                    pgxoi->vkButtonRightPortrait = VK_RIGHT;
                    pgxoi->vkButtonRightLandscape = VK_UP;
                    pgxoi->ptButtonRight.x = 140;
                    pgxoi->ptButtonRight.y = 370;
                    pgxoi->vkButtonAPortrait = 'A';
                    pgxoi->vkButtonALandscape = 'A';
                    pgxoi->ptButtonA.x = 100;
                    pgxoi->ptButtonA.y = 410;
                    pgxoi->vkButtonBPortrait = 'B';
                    pgxoi->vkButtonBLandscape = 'B';
                    pgxoi->ptButtonB.x = 120;
                    pgxoi->ptButtonB.y = 410;
                    pgxoi->vkButtonCPortrait = 'C';
                    pgxoi->vkButtonCLandscape = 'C';
                    pgxoi->ptButtonC.x = 140;
                    pgxoi->ptButtonC.y = 410;
                    pgxoi->vkButtonStartPortrait = 'D';
                    pgxoi->vkButtonStartLandscape = 'D';
                    pgxoi->ptButtonStart.x = 160;
                    pgxoi->ptButtonStart.y = 410;
                    pgxoi->pvReserved1 = (void *) 0;
                    pgxoi->pvReserved2 = (void *) 0;
                    RetVal = 1;

                } else
                {
                    SetLastError (ERROR_INVALID_PARAMETER);
                    RetVal = -1;
                }
            } else {
                SetLastError (ERROR_INVALID_PARAMETER);
                RetVal = -1;
            }
            break;

        default:
            RetVal = 0;
            break;
    }
    return RetVal;
}

int
SA2Video::GetRotateModeFromReg()
{
    HKEY hKey;
    int nRet = DMDO_0;

    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\ROTATION"),0,0, &hKey))
    {
        DWORD dwSize, dwAngle, dwType = REG_DWORD;
        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                               TEXT("ANGLE"),
                                               NULL,
                                               &dwType,
                                               (LPBYTE)&dwAngle,
                                               &dwSize))
        {
            switch (dwAngle)
            {
            case 90:
                nRet = DMDO_90;
                break;
            case 180:
                nRet = DMDO_180;
                break;
            case 270:
                nRet = DMDO_270;
                break;
            case 0:
                // fall through
            default:
                nRet = DMDO_0;
                break;
            }
        }

        RegCloseKey(hKey);
    }

    return nRet;
}

void
SA2Video::SetRotateParams()
{
    int iswap;
    switch(m_iRotate)
    {
    case DMDO_0:
        m_nScreenHeightSave = m_nScreenHeight;
        m_nScreenWidthSave = m_nScreenWidth;
        break;

    case DMDO_180:
        m_nScreenHeightSave = m_nScreenHeight;
        m_nScreenWidthSave = m_nScreenWidth;
        break;

    case DMDO_90:
    case DMDO_270:
        iswap = m_nScreenHeight;
        m_nScreenHeight = m_nScreenWidth;
        m_nScreenWidth = iswap;
        m_nScreenHeightSave = m_nScreenWidth;
        m_nScreenWidthSave = m_nScreenHeight;
        break;

    default:
        m_nScreenHeightSave = m_nScreenHeight;
        m_nScreenWidthSave = m_nScreenWidth;
        break;
    }

    return;
}

LONG
SA2Video::DynRotate(
    int angle
    )
{
    GPESurfRotate *pSurf = (GPESurfRotate *)m_pPrimarySurface;

    if (m_InDDraw)
    {
        return DISP_CHANGE_BADMODE;
    }

    if (angle == m_iRotate)
    {
        return DISP_CHANGE_SUCCESSFUL;
    }

    CursorOff();

    m_iRotate = angle;

    switch(m_iRotate)
    {
    case DMDO_0:
    case DMDO_180:
        m_nScreenHeight = m_nScreenHeightSave;
        m_nScreenWidth  = m_nScreenWidthSave;
        break;

    case DMDO_90:
    case DMDO_270:
        m_nScreenHeight = m_nScreenWidthSave;
        m_nScreenWidth  = m_nScreenHeightSave;
        break;
    }

    m_pMode->width  = m_nScreenWidth;
    m_pMode->height = m_nScreenHeight;
    pSurf->SetRotation(m_nScreenWidth, m_nScreenHeight, angle);

    CursorOn();

    return DISP_CHANGE_SUCCESSFUL;
}

void
SA2Video::CursorOn()
{
    USHORT * ptrScreen = (USHORT *)m_pPrimarySurface->Buffer();
    USHORT * ptrLine;
    USHORT * cbsLine;

    if (!m_CursorForcedOff && !m_CursorDisabled && !m_CursorVisible)
    {
        RECTL cursorRectSave = m_CursorRect;
        int   iRotate;

        RotateRectl(&m_CursorRect);
        for (int y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
        {
            if (y < 0)
            {
                continue;
            }
            if (y >= m_nScreenHeightSave)
            {
                break;
            }

            ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride() / 2];
            cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * m_CursorSize.x];

            for (int x = m_CursorRect.left; x < m_CursorRect.right; x++)
            {
                if (x < 0)
                {
                    continue;
                }
                if (x >= m_nScreenWidthSave)
                {
                    break;
                }

                // x' = x - m_CursorRect.left; y' = y - m_CursorRect.top;
                // Width = m_CursorSize.x;   Height = m_CursorSize.y;
                switch (m_iRotate)
                {
                    case DMDO_0:
                        iRotate = (y - m_CursorRect.top)*m_CursorSize.x + x - m_CursorRect.left;
                        break;
                    case DMDO_90:
                        iRotate = (x - m_CursorRect.left)*m_CursorSize.x + m_CursorSize.y - 1 - (y - m_CursorRect.top);
                        break;
                    case DMDO_180:
                        iRotate = (m_CursorSize.y - 1 - (y - m_CursorRect.top))*m_CursorSize.x + m_CursorSize.x - 1 - (x - m_CursorRect.left);
                        break;
                    case DMDO_270:
                        iRotate = (m_CursorSize.x -1 - (x - m_CursorRect.left))*m_CursorSize.x + y - m_CursorRect.top;
                        break;
                    default:
                        iRotate = (y - m_CursorRect.top)*m_CursorSize.x + x - m_CursorRect.left;
                        break;
                }

                cbsLine[x - m_CursorRect.left] = ptrLine[x];
                ptrLine[x] &= gCursorMask[iRotate];
                ptrLine[x] ^= gCursorData[iRotate];
            }
        }

        m_CursorRect    = cursorRectSave;
        m_CursorVisible = TRUE;
    }
}

void
SA2Video::CursorOff()
{
    USHORT * ptrScreen = (USHORT*)m_pPrimarySurface->Buffer();
    USHORT * ptrLine;
    USHORT * cbsLine;

    if (!m_CursorForcedOff && !m_CursorDisabled && m_CursorVisible)
    {
        RECTL rSave = m_CursorRect;
        RotateRectl(&m_CursorRect);

        for (int y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
        {
            // clip to displayable screen area (top/bottom)
            if (y < 0)
            {
                continue;
            }
            if (y >= m_nScreenHeightSave)
            {
                break;
            }

            ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride() / 2];
            cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * m_CursorSize.x];

            for (int x = m_CursorRect.left; x < m_CursorRect.right; x++)
            {
                // clip to displayable screen area (left/right)
                if (x < 0)
                {
                    continue;
                }
                if (x >= (int)m_nScreenWidthSave)
                {
                    break;
                }

                ptrLine[x] = cbsLine[x - m_CursorRect.left];
            }
        }

        m_CursorRect = rSave;
        m_CursorVisible = FALSE;
    }
}