halsurf.cpp

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

        //
        //  flip to next buffer of overlay flipping chain
        //
        pGPE->OvlFlipTo(pSurf->OffsetInVideoMemory());

    } else
    {
        //
        //  normal flip of a flipping chain
        //
        pGPE->FlipTo(pSurf->OffsetInVideoMemory());

    } 

    pd->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetClipList( LPDDHAL_SETCLIPLISTDATA pd )
{
    DEBUGENTER( HalSetClipList );
    /*
    typedef struct _DDHAL_SETCLIPLISTDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_SETCLIPLIST   SetClipList;    // PRIVATE: ptr to callback
    } DDHAL_SETCLIPLISTDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalBlt( LPDDHAL_BLTDATA pd )
{
    DEBUGENTER( HalBlt );
    /*
    typedef struct _DDHAL_BLTDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDDestSurface;// dest surface
        RECTL                       rDest;          // dest rect
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSrcSurface; // src surface
        RECTL                       rSrc;           // src rect
        DWORD                       dwFlags;        // blt flags
        DWORD                       dwROPFlags;     // ROP flags (valid for ROPS only)
        DDBLTFX                     bltFX;          // blt FX
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_BLT           Blt;            // PRIVATE: ptr to callback
    } DDHAL_BLTDATA;
    */

    // Implementation
    CT69000 *pGPE=(CT69000 *)pd->lpDD->hInstance;
    LPDDRAWI_DDRAWSURFACE_GBL lpDstGbl=pd->lpDDDestSurface->lpGbl;

    //
    //  if we are still busy, do not blt and return
    //
    pd->ddRVal = UpdateFlipStatus(pGPE);
    if (pd->ddRVal != DD_OK)
    {
        return DDHAL_DRIVER_HANDLED;
    }

    DWORD dwFlags = pd->dwFlags;

    if ( !(dwFlags & DDBLT_ROP) )
    {
        if (dwFlags & DDBLT_COLORFILL)
        {
            ULONG ulHeight=pd->rDest.bottom-pd->rDest.top;
            ULONG ulWidth=pGPE->BytesPerPixel(pd->rDest.right-pd->rDest.left);
            ULONG ulDstAddress=lpDstGbl->fpVidMem-(DWORD)(pGPE->PrimarySurface()->Buffer());

            ulDstAddress += pGPE->BytesPerPixel(pd->rDest.left)+
                            pd->rDest.top*lpDstGbl->lPitch;

            pGPE->SetBRFill(lpDstGbl->lPitch,
                            pd->bltFX.dwFillColor,
                            (0xf0 & 0xff) | 
                            (1<<19) |                 // force bc color   
                            (1<<18),
                            ulDstAddress,
                            ulWidth,
                            ulHeight);

            pd->ddRVal = DD_OK;

            return DDHAL_DRIVER_HANDLED;
        } else
        {
            DEBUGMSG( CT69K_ZONE_ERROR,(TEXT("--HalBlt: unknown blt (no rop, no fill)")));
        }
    }

    LPDDRAWI_DDRAWSURFACE_LCL lpDDSrcSurface=pd->lpDDSrcSurface;
    LPDDRAWI_DDRAWSURFACE_GBL lpSrcGbl;
    

    //
    //  must be rop (SRCCPY) blt
    //

    ULONG ulCmd=HIWORD(pd->bltFX.dwROP);
    ULONG ulSrcSpan=0;
    ULONG ulSrcAddress=0;
    ULONG ulDstSpan=lpDstGbl->lPitch;
    ULONG ulHeight=pd->rDest.bottom-pd->rDest.top;
    ULONG ulWidth=pGPE->BytesPerPixel(pd->rDest.right-pd->rDest.left);
    ULONG ulDstAddress=lpDstGbl->fpVidMem-(DWORD)(pGPE->PrimarySurface()->Buffer());

    ulDstAddress += pGPE->BytesPerPixel(pd->rDest.left)+
                    pd->rDest.top*lpDstGbl->lPitch;
    
    //
    //  if there is a source
    //
    if (lpDDSrcSurface!=NULL)
    {
        
        lpSrcGbl=lpDDSrcSurface->lpGbl;
        ulSrcSpan=lpSrcGbl->lPitch;
        ulSrcAddress=lpSrcGbl->fpVidMem-(DWORD)(pGPE->PrimarySurface()->Buffer());
        ulSrcAddress += pGPE->BytesPerPixel(pd->rSrc.left)+
                        pd->rSrc.top*lpSrcGbl->lPitch;

        //
        //  check for overlapping blits if src==dst
        //

        if(  lpSrcGbl==lpDstGbl &&
           !(pd->rDest.left>pd->rSrc.right ||
             pd->rSrc.left>pd->rDest.right ||
             pd->rDest.top>pd->rSrc.bottom ||
             pd->rSrc.top>pd->rDest.bottom))
        {
            ULONG ulDelta;
            //
            //  if dest rect overlaps src rect on right side,
            //  start copy from right to left....
            //
            if (pd->rDest.left>pd->rSrc.left)
            {
                ulCmd |= 0x100;
                ulDelta = pGPE->BytesPerPixel(pd->rSrc.right-pd->rSrc.left-1);
                ulSrcAddress += ulDelta;
                ulDstAddress += ulDelta;
            }
            //
            //  same for top/bottom rects
            //
            if (pd->rDest.top>pd->rSrc.top)
            {
                ulCmd |= 0x200;
                ulDelta = (pd->rSrc.bottom-pd->rSrc.top-1)*ulSrcSpan;
                ulSrcAddress += ulDelta;
                ulDstAddress += ulDelta;
            }
        }
    }

    if ( dwFlags & ( DDBLT_KEYSRCOVERRIDE | DDBLT_KEYSRC ) )
    {
        // TRANSPARENT BLT
        DEBUGMSG(GPE_ZONE_BLT_LO,(TEXT("TRANSPARENT BLT\n")));

        DWORD dwKeyColor;

        if ( dwFlags & DDBLT_KEYSRCOVERRIDE )
        {
            DEBUGMSG(CT69K_ZONE_DDRAW,(TEXT("DDBLT_KEYSRCOVERRIDE, xparent = 0x%x\n"),pd->bltFX.ddckSrcColorkey.dwColorSpaceLowValue));
            dwKeyColor = pd->bltFX.ddckSrcColorkey.dwColorSpaceLowValue;
        }
        else
        {
            DEBUGMSG(CT69K_ZONE_DDRAW,(TEXT("DDBLT_KEYSRC, xparent = 0x%x\n"),pd->lpDDSrcSurface->ddckCKSrcBlt.dwColorSpaceLowValue));
            dwKeyColor = pd->lpDDSrcSurface->ddckCKSrcBlt.dwColorSpaceLowValue;
        }

        ulCmd |= (1 << 14);     // enable transparency

        pGPE->SetKey( dwKeyColor);
                      
    }

    pGPE->SetBRBlt( ulSrcSpan,
                    ulDstSpan,
                    ulCmd,
                    ulSrcAddress,
                    ulDstAddress,
                    ulWidth,
                    ulHeight);
    

    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

// not to be confused with
// DWORD WINAPI HalSetColorKey( LPDDHAL_DRVSETCOLORKEYDATA pd )
DWORD WINAPI HalSetColorKey( LPDDHAL_SETCOLORKEYDATA pd )
{
    DEBUGENTER( HalSetColorKey );
    /*
    typedef struct _DDHAL_SETCOLORKEYDATA
    {
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        DWORD                       dwFlags;        // flags
        DDCOLORKEY                  ckNew;          // new color key
        HRESULT                     ddRVal;         // return value
        LPDDHAL_SETCOLORKEY         SetColorKey;    // PRIVATE: ptr to callback
    } DDHAL_DRVSETCOLORKEYDATA;
    */

    CT69000 *pGPE=(CT69000 *)pd->lpDD->hInstance;

    if(pd->dwFlags & DDCKEY_DESTOVERLAY)
    { 
        // we always do colorkey for primary surface.
        pGPE->SetColorKey( pd->ckNew.dwColorSpaceHighValue);
        pGPE->ColorKeyOn();
    }
    
    pd->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalAddAttachedSurface( LPDDHAL_ADDATTACHEDSURFACEDATA pd )
{
    DEBUGENTER( HalAddAttachedSurface );
    /*
    typedef struct _DDHAL_ADDATTACHEDSURFACEDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpSurfAttached; // surface to attach
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_ADDATTACHEDSURFACE AddAttachedSurface;
                                                    // PRIVATE: ptr to callback
    } DDHAL_ADDATTACHEDSURFACEDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetBltStatus( LPDDHAL_GETBLTSTATUSDATA pd )
{
    DEBUGENTER( HalGetBltStatus );
    /*
    typedef struct _DDHAL_GETBLTSTATUSDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        DWORD                       dwFlags;        // flags
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_GETBLTSTATUS  GetBltStatus;   // PRIVATE: ptr to callback
    } DDHAL_GETBLTSTATUSDATA;
    */

    // Implementation
    GPE *pGPE=(GPE *)pd->lpDD->hInstance;

    pd->ddRVal = DD_OK;

    if (pGPE->IsBusy())
        pd->ddRVal = DDERR_WASSTILLDRAWING;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetFlipStatus( LPDDHAL_GETFLIPSTATUSDATA pd )
{
    DEBUGENTER( HalGetFlipStatus );
    /*
    typedef struct _DDHAL_GETFLIPSTATUSDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        DWORD                       dwFlags;        // flags
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_GETFLIPSTATUS GetFlipStatus;  // PRIVATE: ptr to callback
    } DDHAL_GETFLIPSTATUSDATA;
    */

    GPE *pGPE=(GPE *)pd->lpDD->hInstance;

    // Implementation
    pd->ddRVal = UpdateFlipStatus(pGPE);

    // pd->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI 
HalUpdateOverlay( LPDDHAL_UPDATEOVERLAYDATA pd ) 
{
    DEBUGENTER( HalUpdateOverlay );
    /*
//  typedef struct _DDHAL_UPDATEOVERLAYDATA
//  {
//      LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
//      LPDDRAWI_DDRAWSURFACE_LCL   lpDDDestSurface;// dest surface
//      RECTL                       rDest;          // dest rect
//      LPDDRAWI_DDRAWSURFACE_LCL   lpDDSrcSurface; // src surface
//      RECTL                       rSrc;           // src rect
//      DWORD                       dwFlags;        // flags
//      DDOVERLAYFX                 overlayFX;      // overlay FX
//      HRESULT                     ddRVal;         // return value
//      LPDDHALSURFCB_UPDATEOVERLAY UpdateOverlay;  // PRIVATE: ptr to callback
//  } DDHAL_UPDATEOVERLAYDATA;
//  */
//    

    CT69000 *pGPE=(CT69000 *)pd->lpDD->hInstance;
    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSrcSurface=pd->lpDDSrcSurface;

    if (pd->dwFlags & DDOVER_HIDE) {
        pGPE->OverlayOff();     
    } else
    {   
        CT69000Surf *pSrc=(CT69000Surf *)lpDDSrcSurface->lpGbl->dwReserved1;
        ULONG ulBase=pSrc->OffsetInVideoMemory();

        pGPE->SetOverlayWindow( pSrc->Stride(), 
                                &pd->rSrc,
                                &pd->rDest);
        pGPE->SetOvlPTR1( ulBase);

        DWORD dwOvlFormat=CT69000_OVLFORMAT_RGB565;
        if (lpDDSrcSurface->dwFlags & DDRAWISURF_HASPIXELFORMAT) 
        {
            LPDDPIXELFORMAT pddpf=&lpDDSrcSurface->lpGbl->ddpfSurface;

            // find source pixel format
            if (pddpf->dwFlags & DDPF_FOURCC) 
            {
                dwOvlFormat = CT69000_OVLFORMAT_YUV;
            }
            else if (pddpf->dwFlags & DDPF_RGB) 
            {
                // must be 15 or 16 bit...
                if (pddpf->dwRBitMask == 0x00007C00L)
                    dwOvlFormat = CT69000_OVLFORMAT_RGB555;
            }
        }

        pGPE->SetOvlFormat( dwOvlFormat);

        if (pd->dwFlags & DDOVER_SHOW) {
            pGPE->OverlayOn();
        }
    }

    if (pd->dwFlags & DDOVER_AUTOFLIP)
    {
        DEBUGMSG(CT69K_ZONE_DDRAW,(TEXT("DDOVER_AUTOFLIP not implemented\n")));
    }

    if (pd->dwFlags & DDOVER_KEYSRCOVERRIDE) 
    {
        DEBUGMSG(CT69K_ZONE_DDRAW,(TEXT("DDOVER_KEYSRCOVERRIDE not implemented\n")));
    }

    BOOL bColorKey=FALSE;
    DWORD dwKey;

    if (pd->dwFlags & DDOVER_KEYDEST)
    {
        bColorKey = TRUE;
        dwKey = pd->lpDDDestSurface->ddckCKDestOverlay.dwColorSpaceLowValue;
    } else 
    if (pd->dwFlags & DDOVER_KEYDESTOVERRIDE) 
    {
        bColorKey = TRUE;
        dwKey=pd->overlayFX.dckDestColorkey.dwColorSpaceLowValue;
    }

    if (bColorKey)
    {
        pGPE->SetColorKey( dwKey);
        pGPE->ColorKeyOn();
    } else
    {
        pGPE->ColorKeyOff();
    }

    pd->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI 
HalSetOverlayPosition( LPDDHAL_SETOVERLAYPOSITIONDATA pd ) 
{
    DEBUGENTER( HalSetOverlayPosition );
    /*
    typedef struct _DDHAL_SETOVERLAYPOSITIONDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSrcSurface; // src surface
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDDestSurface;// dest surface
        LONG                        lXPos;          // x position
        LONG                        lYPos;          // y position
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_SETOVERLAYPOSITION SetOverlayPosition;
                                                    // PRIVATE: ptr to callback
    } DDHAL_SETOVERLAYPOSITIONDATA;
    */

    CT69000 *pGPE=(CT69000 *)pd->lpDD->hInstance;

    pGPE->SetOverlayPosition( pd->lXPos, pd->lYPos);

    pd->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetPalette( LPDDHAL_SETPALETTEDATA pd )
{
    DEBUGENTER( HalSetPalette );
    /*
    typedef struct _DDHAL_SETPALETTEDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        LPDDRAWI_DDRAWPALETTE_GBL   lpDDPalette;    // palette to set to surface
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_SETPALETTE    SetPalette;     // PRIVATE: ptr to callback
        BOOL                        Attach;         // attach this palette?
    } DDHAL_SETPALETTEDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

#endif