halcaps.cpp

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

{
//                              Bits/   Uses            -----------MASKS-------------
//      width   height  pitch   Pixel   Palette Freq    Red     Green   Blue    Alpha
#if FBBPP==24
    {   640,    480,   1920,    24,     0,      REFRESHRATE,        0xFF0000,   0xFF00, 0x00FF, 0   }
#elif FBBPP==16
    {   640,    480,   1280,    16,     0,      REFRESHRATE,        0xF800, 0x07E0, 0x001F, 0       }
#else
    {   640,    480,    640,    8,      1,      REFRESHRATE,        0,      0,      0,      0       }
#endif
};


EXTERN_C BOOL WINAPI 
HALInit(LPDDHALINFO lpddhi,
        BOOL reset,
        DWORD modeidx )
{
    DEBUGENTER(HALInit);

    // Initialize the hardware and the callbacks
    buildDDHALInfo(lpddhi, modeidx);

    DEBUGLEAVE(HALInit);

    return TRUE;
}

EXTERN_C void
buildDDHALInfo( LPDDHALINFO lpddhi, DWORD modeidx ) 
{
    CT69000 *pGPE=(CT69000 *)GetGPE();
    memset( lpddhi, 0, sizeof(DDHALINFO) );     // Clear the DDHALINFO structure

    // Populate the rest of the DDHALINFO structure:
    lpddhi->dwSize = sizeof(DDHALINFO);
    lpddhi->lpDDCallbacks = &cbDDCallbacks;
    lpddhi->lpDDSurfaceCallbacks = &cbDDSurfaceCallbacks;
    lpddhi->lpDDPaletteCallbacks = &cbDDPaletteCallbacks;
    lpddhi->lpDDExeBufCallbacks = NULL;//&cbDDExeBufCallbacks;
    lpddhi->GetDriverInfo = HalGetDriverInfo;

    GPESurf *lpPrimary=pGPE->PrimarySurface();
    lpddhi->vmiData.fpPrimary = (ULONG)lpPrimary->Buffer(); // pointer to primary surface
    lpddhi->vmiData.dwFlags = 0;                // flags
    lpddhi->vmiData.dwDisplayWidth = pGPE->ScreenWidth();
                                                // current display width
    lpddhi->vmiData.dwDisplayHeight = pGPE->ScreenHeight();
                                                // current display height
    lpddhi->vmiData.lDisplayPitch = lpPrimary->Stride(); 
    DEBUGMSG( GPE_ZONE_INIT,(TEXT("stride: %d\r\n"), lpddhi->vmiData.lDisplayPitch ));
                                                // current display pitch
    lpddhi->vmiData.ddpfDisplay.dwSize = sizeof(DDPIXELFORMAT);
                                                // ... = 8bit/pixel palettized
    lpddhi->vmiData.ddpfDisplay.dwFourCC = 0;   // (FOURCC code)
#if FBBPP==24
    lpddhi->vmiData.ddpfDisplay.dwFlags = DDPF_RGB;
    lpddhi->vmiData.ddpfDisplay.dwRBitMask = 0xFF0000;  // 8
    lpddhi->vmiData.ddpfDisplay.dwGBitMask = 0x00FF00;  // 8
    lpddhi->vmiData.ddpfDisplay.dwBBitMask = 0x0000FF;  // 8
    lpddhi->vmiData.ddpfDisplay.dwRGBBitCount = 24;
#elif FBBPP==16
    lpddhi->vmiData.ddpfDisplay.dwFlags = DDPF_RGB;
    lpddhi->vmiData.ddpfDisplay.dwRBitMask = 0xF800;    // 5
    lpddhi->vmiData.ddpfDisplay.dwGBitMask = 0x07E0;    // 6
    lpddhi->vmiData.ddpfDisplay.dwBBitMask = 0x001F;    // 5
    lpddhi->vmiData.ddpfDisplay.dwRGBBitCount = 16;
#else
    lpddhi->vmiData.ddpfDisplay.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
    lpddhi->vmiData.ddpfDisplay.dwRGBBitCount = 8;
#endif
                                                // how many bits per pixel (BD_4,8,16,24,32)
    lpddhi->vmiData.dwOffscreenAlign = 4;       // byte alignment for offscreen surfaces
    lpddhi->vmiData.dwOverlayAlign = 4;         // byte alignment for overlays
    lpddhi->vmiData.dwTextureAlign = 0;         // byte alignment for textures
    lpddhi->vmiData.dwZBufferAlign = 0;         // byte alignment for z buffers
    lpddhi->vmiData.dwAlphaAlign = 4;           // byte alignment for alpha
    lpddhi->vmiData.dwNumHeaps = 0;             // number of memory heaps in vmList
    lpddhi->vmiData.pvmList = (LPVIDMEM)NULL;   // array of heaps

    // hw specific caps:
    lpddhi->ddCaps.dwSize = sizeof(DDCAPS);     // size of the DDDRIVERCAPS structure
    lpddhi->ddCaps.dwCaps =                     // driver specific capabilities
        // DDCAPS_3D |                          // Display hardware has 3D acceleration
        DDCAPS_BLT |                            // Display hardware is capable of blt operations
        // DDCAPS_BLTQUEUE |                        // Display hardware is capable of asynchronous blt operations
        // DDCAPS_BLTFOURCC |                   // Display hardware is capable of color space conversions during the blt operation
        // DDCAPS_BLTSTRETCH |                  // Display hardware is capable of stretching during blt operations
        DDCAPS_GDI |                        // Display hardware is shared with GDI
        DDCAPS_OVERLAY |                    // Display hardware can overlay
        DDCAPS_OVERLAYCANTCLIP |            // Set if display hardware supports overlays but can not clip them
        DDCAPS_OVERLAYFOURCC |              // overlay hardware is capable of color space conversions
        DDCAPS_OVERLAYSTRETCH |             // Indicates that stretching can be done by the overlay hardware
        // DDCAPS_PALETTE |                     // unique DirectDrawPalettes can be created for DirectDrawSurfaces
        // DDCAPS_PALETTEVSYNC |                // palette changes can be syncd with the vertical
        DDCAPS_READSCANLINE |               // Display hardware can return the current scan line
        // DDCAPS_STEREOVIEW |                  // Display hardware has stereo vision capabilities
        ///DDCAPS_VBI |                             // Display hardware is capable of generating a vertical blank interrupt
        // DDCAPS_ZBLTS |                       // Supports the use of z buffers with blt operations
        // DDCAPS_ZOVERLAYS |                   // Supports Z Ordering of overlays
#if FBBPP!=24
        DDCAPS_COLORKEY |                       // Supports color key
        // DDCAPS_ALPHA |                       // Supports alpha surfaces
        DDCAPS_COLORKEYHWASSIST |           // colorkey is hardware assisted
#endif
        // DDCAPS_NOHARDWARE |                  // no hardware support at all
        DDCAPS_BLTCOLORFILL |                   // Display hardware is capable of color fill with bltter
        // DDCAPS_BANKSWITCHED |                // Display hardware is bank switched
        // DDCAPS_BLTDEPTHFILL |                // Display hardware is capable of depth filling Z-buffers with bltter
        // DDCAPS_CANCLIP |                     // Display hardware is capable of clipping while bltting
        // DDCAPS_CANCLIPSTRETCHED |            // Display hardware is capable of clipping while stretch bltting
        // DDCAPS_CANBLTSYSMEM |                // Display hardware is capable of bltting to or from system memory
        0;

    lpddhi->ddCaps.dwCaps2 =                    // more driver specific capabilities
        // DDCAPS2_CERTIFIED                    // Display hardware is certified
        // DDCAPS2_NO2DDURING3DSCENE |              // Driver cannot interleave 2D & 3D operations
#ifdef VIDEOPORT_SUPPORT
        DDCAPS2_VIDEOPORT |                 // Display hardware contains a video port
#endif
         ///DDCAPS2_AUTOFLIPOVERLAY |           // automatic doubled buffered display of video port
         //DDCAPS2_CANBOBINTERLEAVED |          // Overlay can display each field of interlaced data
         ///DDCAPS2_CANBOBNONINTERLEAVED |      // As above but for non-interleaved data
        // DDCAPS2_COLORCONTROLOVERLAY |        // The overlay surface contains color controls
        // DDCAPS2_COLORCONTROLPRIMARY |        // The primary surface contains color controls
        // DDCAPS2_CANDROPZ16BIT |              // RGBZ -> RGB supported for 16:16 RGB:Z
        // DDCAPS2_NONLOCALVIDMEM |             // Driver supports non-local video memory
        // DDCAPS2_NONLOCALVIDMEMCAPS |         // Dirver supports non-local video memory but has different capabilities
        // DDCAPS2_NOPAGELOCKREQUIRED |         // Driver neither requires nor prefers surfaces to be pagelocked
        // DDCAPS2_WIDESURFACES |                   // Driver can create surfaces which are wider than the primary surface
        // DDCAPS2_CANFLIPODDEVEN |             // Driver supports bob without using a video port
        // DDCAPS2_CANBOBHARDWARE |             // Driver supports bob using hardware
        // DDCAPS2_COPYFOURCC |                 // Driver supports bltting any FOURCC surface to another surface of the same FOURCC
        0 ;

    lpddhi->ddCaps.dwCKeyCaps =                 // color key capabilities of the surface
        DDCKEYCAPS_DESTOVERLAY          |
        DDCKEYCAPS_DESTOVERLAYYUV       |
        DDCKEYCAPS_DESTOVERLAYONEACTIVE |

        DDCKEYCAPS_SRCBLT |                         // Hardware can use colorkey (cf source only)
                                                    //   ..for transparent blts

        //DDCKEYCAPS_SRCOVERLAY          |
        //DDCKEYCAPS_SRCOVERLAYCLRSPACE  |
        //DDCKEYCAPS_SRCOVERLAYYUV       |
        //DDCKEYCAPS_SRCOVERLAYONEACTIVE |
        //DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV|
        0;
    lpddhi->ddCaps.dwFXCaps=                    // driver specific stretching and effects capabilites
        ///DDFXCAPS_BLTMIRRORUPDOWN |           // Supports vertical inversion Blts
        //DDFXCAPS_BLTSTRETCHY |                // Supports stretch blts in the Y-direction
        //DDFXCAPS_BLTSHRINKY |                 // Supports shrink blts in the Y-direction
        //DDFXCAPS_BLTSTRETCHX |                // Supports stretch blts in the X-direction
        //DDFXCAPS_BLTSHRINKX |                 // Supports shrink blts in the X-direction
        DDFXCAPS_OVERLAYSTRETCHX        |
        DDFXCAPS_OVERLAYSTRETCHXN       |
        DDFXCAPS_OVERLAYSTRETCHY        |
        DDFXCAPS_OVERLAYARITHSTRETCHYN  |
        DDFXCAPS_OVERLAYARITHSTRETCHY   |
        //DDFXCAPS_OVERLAYALPHA         |
        0;
    lpddhi->ddCaps.dwPalCaps;                   // palette capabilities
        // DDPCAPS_1BIT |                           // Simple 1-bit palette
        // DDPCAPS_2BIT |                           // Simple 2-bit palette
        // DDPCAPS_4BIT |                           // Simple 4-bit palette
        // DDPCAPS_8BITENTRIES |                // Palette indexes into 8 bit target
        DDPCAPS_8BIT |                          // Simple 8-bit palette
        DDPCAPS_INITIALIZE |                    // DDraw should initalize palette
                                                //   ..from lpDDColorArray
        DDPCAPS_PRIMARYSURFACE |                // Palette is attached to primary surface
        // DDPCAPS_PRIMARYSURFACELEFT |         // Palette is attached to left-eye primary surface
        DDPCAPS_ALLOW256 |                      // All 256 entries may be set
        0;
    lpddhi->ddCaps.dwSVCaps=0;                  // Stereo vision capabilities (none)
    lpddhi->ddCaps.dwAlphaBltConstBitDepths = 0;// Alpha Blt's
    lpddhi->ddCaps.dwAlphaBltPixelBitDepths = 0;
    lpddhi->ddCaps.dwAlphaBltSurfaceBitDepths = 0;
    lpddhi->ddCaps.dwAlphaOverlayConstBitDepths=DDBD_8;

    lpddhi->ddCaps.dwZBufferBitDepths=0;        // No z buffer
    lpddhi->ddCaps.dwVidMemTotal = pGPE->VideoMemorySize(); // total amount of video memory
    lpddhi->ddCaps.dwVidMemFree  = pGPE->VideoMemorySize(); // amount of free video memory
                                                        // report total free here incl. 
                                                        // memory already allocated by gdi

                                                // maximum number of visible overlays
    lpddhi->ddCaps.dwMaxVisibleOverlays = 1;
    lpddhi->ddCaps.dwCurrVisibleOverlays = 0;   // current number of visible overlays
    lpddhi->ddCaps.dwMinOverlayStretch=1000;
    lpddhi->ddCaps.dwMaxOverlayStretch=9999;
    lpddhi->ddCaps.dwNumFourCCCodes = 1;        // number of four cc codes
    lpddhi->ddCaps.dwAlignBoundarySrc = 4;      // source rectangle alignment
    lpddhi->ddCaps.dwAlignSizeSrc = 8;          // source rectangle byte size
    lpddhi->ddCaps.dwAlignStrideAlign = 8;      // stride alignment
    lpddhi->ddCaps.ddsCaps.dwCaps=              // DDSCAPS structure has all the general capabilities
        // DDSCAPS_ALPHA |                          // Can create alpha-only surfaces
        DDSCAPS_BACKBUFFER |                        // Can create backbuffer surfaces
        DDSCAPS_COMPLEX |                           // Can create complex surfaces
        DDSCAPS_FLIP |                              // Can flip between surfaces
#ifdef VIDEOPORT_SUPPORT
        DDSCAPS_VIDEOPORT |
#endif
        DDSCAPS_FRONTBUFFER |                       // Can create front-buffer surfaces
        DDSCAPS_OFFSCREENPLAIN |                    // Can create off-screen bitmaps
        DDSCAPS_OVERLAY |                       // Can create overlay surfaces
        DDSCAPS_PALETTE |                           // Has one palette ???
        DDSCAPS_PRIMARYSURFACE |                    // Has a primary surface
        // DDSCAPS_PRIMARYSURFACELEFT |             // Has a left-eye primary surface
        // DDSCAPS_TEXTURE |                        // Supports texture surrfaces
        // DDSCAPS_SYSTEMMEMORY |                   // Surfaces are in system memory
        DDSCAPS_VIDEOMEMORY |                       // Surfaces are in video memory 
        DDSCAPS_VISIBLE |                           // Changes are instant ???
        // DDSCAPS_ZBUFFER |                        // Can create (pseudo) Z buffer
        // DDSCAPS_EXECUTEBUFFER |                  // Can create execute buffer
        // DDSCAPS_3DDEVICE |                       // Surfaces can be 3d targets
        // DDSCAPS_WRITEONLY |                      // Can create write-only surfaces
        // DDSCAPS_ALLOCONLOAD |                    // Can create alloconload surfaces
        // DDSCAPS_MIPMAP |                         // Can create mipmap
        0;

    SETROPBIT(lpddhi->ddCaps.dwRops,SRCCOPY);       // Set bits for ROPS supported
    //SETROPBIT(lpddhi->ddCaps.dwRops,PATCOPY);
    SETROPBIT(lpddhi->ddCaps.dwRops,BLACKNESS);
    SETROPBIT(lpddhi->ddCaps.dwRops,WHITENESS);

    //
    //  for now we always use the same size as gdi
    //
    modeInfo[modeidx].dwHeight=pGPE->ScreenHeight();
    modeInfo[modeidx].dwWidth=pGPE->ScreenWidth();
    modeInfo[modeidx].lPitch =
    modeInfo[modeidx].wRefreshRate=(WORD)pGPE->RefreshRate();

    lpddhi->dwMonitorFrequency = modeInfo[modeidx].wRefreshRate;    // monitor frequency in current mode (60 field/sec)
    lpddhi->dwModeIndex = 0;                    // current mode: index into array
    lpddhi->lpdwFourCC = FourCC;                // fourcc codes supported
    lpddhi->dwNumModes = sizeof(modeInfo)/sizeof(DDHALMODEINFO);
                                                // number of modes supported
    lpddhi->lpModeInfo = modeInfo;              // mode information
    lpddhi->dwFlags =
                    DDHALINFO_MODEXILLEGAL |    // create flags
                    DDHALINFO_GETDRIVERINFOSET |
                    0;
    //
    //  fill both with pointer to our GPE object, otherwise ddraw runtime
    //  will null out hInstance. This way we can use hInstance from lpDD
    //  to get our device object
    //
    lpddhi->lpPDevice = (LPVOID)pGPE;           // physical device ptr
    lpddhi->hInstance = (DWORD)pGPE;            // instance handle of driver

#ifdef VIDEOPORT_SUPPORT
    lpddhi->ddCaps.dwMaxVideoPorts  = 1;
    lpddhi->ddCaps.dwCurrVideoPorts= 0;
#endif
}


#endif