// g_pGPE and g_pDDrawPrimarySurface were already set up by HalInit
        unsigned long physicalVideoMemoryStart;
        g_pGPE->GetPhysicalVideoMemory( &physicalVideoMemoryStart, &g_nVideoMemorySize );
        DEBUGMSG(GPE_ZONE_INIT,
            (TEXT("GetPhysicalVideoMemory returned phys=0x%08x size=%d\r\n"),
            physicalVideoMemoryStart, g_nVideoMemorySize));

        // Allocate some virtual memory space for video memory
        // This has already been done in GDI driver initialization
        // so we need not to allocate/copy virtual memory here.
        g_pVideoMemory = (BYTE*)physicalVideoMemoryStart;
        DEBUGMSG(GPE_ZONE_INIT,
            (TEXT("gpVidMem=%08x\r\n"), g_pVideoMemory ));
    }

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

    lpddhi->vmiData.fpPrimary = (unsigned long)(g_pVideoMemory)
            + g_pDDrawPrimarySurface->OffsetInVideoMemory();    // pointer to primary surface

    lpddhi->vmiData.dwFlags = 0;        // flags
    lpddhi->vmiData.dwDisplayWidth = modeInfo[modeidx].dwWidth; // current display width
    lpddhi->vmiData.dwDisplayHeight = modeInfo[modeidx].dwHeight; // current display height
    lpddhi->vmiData.lDisplayPitch = g_pDDrawPrimarySurface->Stride();
    DEBUGMSG(GPE_ZONE_INIT,
        (TEXT("stride: %d\r\n"), lpddhi->vmiData.lDisplayPitch ));
    lpddhi->vmiData.ddpfDisplay.dwSize = sizeof(DDPIXELFORMAT);
    lpddhi->vmiData.ddpfDisplay.dwFourCC = 0;

    if (modeInfo[modeidx].dwAlphaBitMask != 0)	// ARGB1555
        lpddhi->vmiData.ddpfDisplay.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
    else
        lpddhi->vmiData.ddpfDisplay.dwFlags = DDPF_RGB;

    lpddhi->vmiData.ddpfDisplay.dwRGBBitCount = modeInfo[modeidx].dwBPP;
    lpddhi->vmiData.ddpfDisplay.dwRBitMask = modeInfo[modeidx].dwRBitMask;
    lpddhi->vmiData.ddpfDisplay.dwGBitMask = modeInfo[modeidx].dwGBitMask;
    lpddhi->vmiData.ddpfDisplay.dwBBitMask = modeInfo[modeidx].dwBBitMask;
    lpddhi->vmiData.ddpfDisplay.dwRGBAlphaBitMask = modeInfo[modeidx].dwAlphaBitMask;

    lpddhi->vmiData.dwOffscreenAlign = 16;      // byte alignment for offscreen surfaces
    lpddhi->vmiData.dwOverlayAlign = 16;         // byte alignment for overlays
    lpddhi->vmiData.dwTextureAlign = 0;         // byte alignment for textures
    lpddhi->vmiData.dwZBufferAlign = 0;         // byte alignment for z buffers
    lpddhi->vmiData.dwAlphaAlign = 0;           // 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 DirectDraw surfaces
        // DDCAPS_PALETTEVSYNC |                // Palette changes can be syncronized with the
                                                // vertical blank timing
        // 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
        DDCAPS_COLORKEY |                       // Supports color key
        // DDCAPS_ALPHA |                       // Supports alpha surfaces
        // DDCAPS_COLORKEYHWASSIST |            // colorkey is hardware assisted
        // 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
        // DDCAPS2_VIDEOPORT |                  // Display hardware contains a video port
        // 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
        // DDCAPS2_FLIPNOVSYNC |                // Driver supports flipping while not in vsync.
        0 ;

    lpddhi->ddCaps.dwCKeyCaps =         // color key capabilities of the surface
        DDCKEYCAPS_DESTOVERLAY |                // Supports RGB overlaying with dest color key
        DDCKEYCAPS_DESTOVERLAYONEACTIVE |       // Supports only one active dest color key value
        DDCKEYCAPS_SRCBLT |                     // Hardware can use colorkey for transparent blt
        DDCKEYCAPS_SRCOVERLAY |                 // Supports RGB overlaying with source color key
        DDCKEYCAPS_SRCOVERLAYONEACTIVE |        // Supports only one active source color key value
        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
        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;// No Alpha Blt's
    lpddhi->ddCaps.dwAlphaBltPixelBitDepths = 0;
    lpddhi->ddCaps.dwAlphaBltSurfaceBitDepths = 0;
    lpddhi->ddCaps.dwZBufferBitDepths=0;        // No z buffer
    lpddhi->ddCaps.dwVidMemTotal = g_nVideoMemorySize;  // total amount of video memory
    lpddhi->ddCaps.dwVidMemFree = g_nVideoMemorySize;   // amount of free video memory

    lpddhi->ddCaps.dwMaxVisibleOverlays = 0;    // maximum number of visible overlays
    lpddhi->ddCaps.dwCurrVisibleOverlays = 0;   // current number of visible overlays
    lpddhi->ddCaps.dwNumFourCCCodes = 0;        // number of four cc codes
    lpddhi->ddCaps.dwAlignBoundarySrc = 0;      // source rectangle alignment
    lpddhi->ddCaps.dwAlignSizeSrc = 0;          // source rectangle byte size
    lpddhi->ddCaps.dwAlignBoundaryDest = 0;     // dest rectangle alignment
    lpddhi->ddCaps.dwAlignSizeDest = 0;         // dest rectangle byte size
    lpddhi->ddCaps.dwAlignStrideAlign = 0;      // 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
        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);

    lpddhi->ddCaps.dwSVBCaps =          // caps for system to video blts
        DDCAPS_BLT |                            // Display hardware is capable of 
                                                // 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_COLORKEY |                       // Supports color key
        // DDCAPS_COLORKEYHWASSIST |            // colorkey is hardware assisted
        DDCAPS_BLTCOLORFILL |                   // Display hardware is capable of 
                                                // color fill with bltter
        0;
    lpddhi->ddCaps.dwSVBCKeyCaps =      // color key capabilities of the surface
        DDCKEYCAPS_SRCBLT |                     // Hardware can use colorkey for
                                                // transparent blts
        0;
    lpddhi->ddCaps.dwSVBFXCaps=         // stretching and effects capabilites
        0;

    SETROPBIT(lpddhi->ddCaps.dwSVBRops,SRCCOPY);// ROPs for system to video blts
    SETROPBIT(lpddhi->ddCaps.dwSVBRops,PATCOPY);
    SETROPBIT(lpddhi->ddCaps.dwSVBRops,BLACKNESS);
    SETROPBIT(lpddhi->ddCaps.dwSVBRops,WHITENESS);

    lpddhi->dwMonitorFrequency = modeInfo[modeidx].wRefreshRate;
                                                // Monitor frequency in current mode
    lpddhi->dwModeIndex = modeidx;              // current mode: index into array
    lpddhi->lpdwFourCC = 0;                     // 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;
    lpddhi->lpPDevice = (LPVOID)0;              // physical device ptr
    lpddhi->hInstance = (DWORD)0;               // instance handle of driver
}