sa2video.cpp

Intel PXA27X Display Driver Windows CE

            XllpLCD._DMA_CHANNEL_2_Y_FRAME_DESCRIPTOR_BASE_PHYSICAL = DMA_CHANNEL_2_Y_FRAME_DESCRIPTOR_BASE_PHYSICAL;
            XllpLCD._DMA_CHANNEL_3_Cb_FRAME_DESCRIPTOR_BASE_PHYSICAL = DMA_CHANNEL_3_Cb_FRAME_DESCRIPTOR_BASE_PHYSICAL;
            XllpLCD._DMA_CHANNEL_4_Cr_FRAME_DESCRIPTOR_BASE_PHYSICAL = DMA_CHANNEL_4_Cr_FRAME_DESCRIPTOR_BASE_PHYSICAL;

            if (frameDescriptorCh2_YCbCr_Y)
                VirtualFree((PVOID)frameDescriptorCh2_YCbCr_Y,0,MEM_RELEASE);

            frameDescriptorCh2_YCbCr_Y = (volatile LCD_FRAME_DESCRIPTOR *)VirtualAllocCopy(sizeof(LCD_FRAME_DESCRIPTOR), "DispDrvrInitialize : lcdFrameDescriptor", (PVOID)(DMA_CHANNEL_2_Y_FRAME_DESCRIPTOR_BASE_VIRTUAL));
            if (!frameDescriptorCh2_YCbCr_Y)
            {
                RetVal = 0;    
                break;
            }

            if (frameDescriptorCh3_YCbCr_Cb)
                VirtualFree((PVOID)frameDescriptorCh3_YCbCr_Cb,0,MEM_RELEASE);

            frameDescriptorCh3_YCbCr_Cb = (volatile LCD_FRAME_DESCRIPTOR *)VirtualAllocCopy(sizeof(LCD_FRAME_DESCRIPTOR), "DispDrvrInitialize : lcdFrameDescriptor", (PVOID)(DMA_CHANNEL_3_Cb_FRAME_DESCRIPTOR_BASE_VIRTUAL));
            if (!frameDescriptorCh3_YCbCr_Cb)
            {
                RetVal = 0;    
                break;
            }

            if (frameDescriptorCh4_YCbCr_Cr)
                VirtualFree((PVOID)frameDescriptorCh4_YCbCr_Cr,0,MEM_RELEASE);

            frameDescriptorCh4_YCbCr_Cr = (volatile LCD_FRAME_DESCRIPTOR *)VirtualAllocCopy(sizeof(LCD_FRAME_DESCRIPTOR), "DispDrvrInitialize : lcdFrameDescriptor", (PVOID)(DMA_CHANNEL_4_Cr_FRAME_DESCRIPTOR_BASE_VIRTUAL));
            if (!frameDescriptorCh4_YCbCr_Cr)
            {
                RetVal = 0;    
                break;
            }


            XllpLCD.frameDescriptorCh2_YCbCr_Y = frameDescriptorCh2_YCbCr_Y;
            XllpLCD.frameDescriptorCh3_YCbCr_Cb = frameDescriptorCh3_YCbCr_Cb; 
            XllpLCD.frameDescriptorCh4_YCbCr_Cr = frameDescriptorCh4_YCbCr_Cr;

            ((P_XLLP_OVERLAY_T)pvIn)->CH2_Y = OVERLAY2_VIRTUAL_BASE_ADDRESS;
            ((P_XLLP_OVERLAY_T)pvIn)->CH3_Cb = OVERLAY2_VIRTUAL_BASE_ADDRESS + ((P_XLLP_OVERLAY_T)pvIn)->ch2_size;
            ((P_XLLP_OVERLAY_T)pvIn)->CH4_Cr = OVERLAY2_VIRTUAL_BASE_ADDRESS + ((P_XLLP_OVERLAY_T)pvIn)->ch2_size + ((P_XLLP_OVERLAY_T)pvIn)->ch3_size;
            ((P_XLLP_OVERLAY_T)pvIn)->OverlayBPP = O_BPP_16;
            ((P_XLLP_OVERLAY_T)pvIn)->TmpBPP = XllpLCD.BPP;

            break;

        case DRVESC_GETSCREENROTATION:
            *(int *)pvOut = ((DMDO_0 | DMDO_90 | DMDO_180 | DMDO_270) << 8) | ((BYTE)m_iRotate);
            return DISP_CHANGE_SUCCESSFUL; 
            break;
    
        case DRVESC_SETSCREENROTATION:
            if ((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 = 0xC3;
                    pgxoi->ptButtonUp.x = -50;
                    pgxoi->ptButtonUp.y = 0;
                    pgxoi->vkButtonDownPortrait = VK_DOWN;
                    pgxoi->vkButtonDownLandscape = 0xC4;
                    pgxoi->ptButtonDown.x = -50;
                    pgxoi->ptButtonDown.y = 30;
                    pgxoi->vkButtonLeftPortrait = 0xC2;
                    pgxoi->vkButtonLeftLandscape = VK_DOWN;
                    pgxoi->ptButtonLeft.x = 25;
                    pgxoi->ptButtonLeft.y = 400;
                    pgxoi->vkButtonRightPortrait = 0xC3;
                    pgxoi->vkButtonRightLandscape = VK_UP;
                    pgxoi->ptButtonRight.x = 90;
                    pgxoi->ptButtonRight.y = 410;
                    pgxoi->vkButtonAPortrait = 0xC4;
                    pgxoi->vkButtonALandscape = 0xC2;
                    pgxoi->ptButtonA.x = 150;
                    pgxoi->ptButtonA.y = 410;
                    pgxoi->vkButtonBPortrait = 0xC5;
                    pgxoi->vkButtonBLandscape = 0xC5;
                    pgxoi->ptButtonB.x = 220;
                    pgxoi->ptButtonB.y = 400;
                    pgxoi->vkButtonCPortrait = VK_ESCAPE;
                    pgxoi->vkButtonCLandscape = VK_ESCAPE;
                    pgxoi->ptButtonC.x = -50;
                    pgxoi->ptButtonC.y = 100;
                    pgxoi->vkButtonStartPortrait = VK_F23;
                    pgxoi->vkButtonStartLandscape = VK_F23;
                    pgxoi->ptButtonStart.x = -50;
                    pgxoi->ptButtonStart.y = 15;
                    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;

    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 0:
                return DMDO_0;
            case 90: 
                return DMDO_90;
            case 180:
                return DMDO_180;
            case 270:
                return DMDO_270;
            default:
                return DMDO_0;
            }
        }

        RegCloseKey(hKey);
    }
    
    return DMDO_0;
}

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;
    }
}