FullScreen.cpp

#include "stdafx.h"

#define SCREEN_WIDTH    1280
#define SCREEN_HEIGHT   1024
#define SCREEN_DEPTH    32

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <windowsx.h>
#include <ddraw.h>
#include <stdlib.h>
#include <stdarg.h>
#include "dvcAPI.h"
#include "dvcImage.h"
#include <stdio.h>

BOOL InitCamera( void );
BOOL GetBitMaskInfo( DWORD dwBitMask, DWORD* pdwShift, DWORD* pdwBits );
BOOL UpdateDisplay( void ) ;

HANDLE                  hDevice = INVALID_HANDLE_VALUE ;
HANDLE                  hReadEvent = INVALID_HANDLE_VALUE ;
CDVCImage               m_Image ;
ULONG                   screenWidth = SCREEN_WIDTH ;
ULONG                   screenHeight = SCREEN_WIDTH ;
ULONG                   screenDepth = SCREEN_DEPTH ;
BOOL                    bShowHelp = FALSE ;
BOOL                    bScaleLuts = FALSE ;
BOOL                    bPauseVideo = FALSE ;
BOOL                    bShowStats = TRUE ;
BOOL                    bChangeDisplay = FALSE ;

#define TIMER_ID        1
#define TIMER_RATE      100

ULONG timerRate = TIMER_RATE ;

LPDIRECTDRAW            lpDD;           // DirectDraw object
LPDIRECTDRAWSURFACE     lpDDSPrimary;   // DirectDraw primary surface
LPDIRECTDRAWSURFACE     lpDDSBack;      // DirectDraw back surface
LPDIRECTDRAWSURFACE     lpDDSOne;       // Offscreen surface 1
LPDIRECTDRAWSURFACE     lpDDSTwo;       // Offscreen surface 2
BOOL                    bActive;        // is application active?

/*
 * finiObjects
 * finished with all objects we use; release them
 */
static void finiObjects( void )
{
    if( lpDD != NULL )
    {
        if( lpDDSPrimary != NULL )
        {
            lpDDSPrimary->Release();
            lpDDSPrimary = NULL;
        }
        if( lpDDSOne != NULL )
        {
            lpDDSOne->Release();
            lpDDSOne = NULL;
        }
        if( lpDDSTwo != NULL )
        {
            lpDDSTwo->Release();
            lpDDSTwo = NULL;
        }
        
        lpDD->Release();
        lpDD = NULL;
    }

    dvcStopSequence(hDevice);
    dvcSetReadCompleteEvent(hDevice, NULL);
    CloseHandle(hReadEvent);
    dvcCloseCamera(hDevice);

} /* finiObjects */

/*
 * restoreAll
 *
 * restore all lost objects
 */
HRESULT restoreAll( void )
{
    HRESULT     ddrval;

    ddrval = lpDDSPrimary->Restore();
    if( ddrval == DD_OK )
    {
        ddrval = lpDDSOne->Restore();
        if( ddrval == DD_OK )
        {
                ddrval = lpDDSTwo->Restore();
        }
    }
    return ddrval;

} /* restoreAll */

long FAR PASCAL WindowProc( HWND hWnd, UINT message, 
                            WPARAM wParam, LPARAM lParam )
{

    switch( message )
    {
        case WM_ACTIVATEAPP:
                bActive = wParam;
                break;

        case WM_CREATE:
                break;

        case WM_SETCURSOR:
                SetCursor(NULL);
                return TRUE;

        case WM_TIMER:
                UpdateDisplay() ;
                break;
 
        case WM_KEYDOWN:
                switch( wParam )
                {
                case VK_ESCAPE:
                        PostMessage(hWnd, WM_CLOSE, 0, 0);
                        break ;

                case VK_F1:
                        bShowHelp = !bShowHelp ;
                        break;

                case VK_F2:
                        bScaleLuts = TRUE ;
                        break;

                case VK_TAB:
                        bShowStats = !bShowStats ;
                        break ;

                case VK_UP:
                {
                        int nGain ;
                        int maxGain ;
                        dvcGetGain(hDevice, &nGain);
                        dvcGetParmRange(hDevice, aGain, NULL, &maxGain, NULL, NULL) ;
                        nGain += 1 ;
                        if(nGain > maxGain) nGain = maxGain ;
                        dvcSetGain(hDevice, nGain);
                }
                        break;

                case VK_DOWN:
                {
                        int nGain ;
                        dvcGetGain(hDevice, &nGain);
                        nGain -= 1 ;
                        if(nGain < 0) nGain = 0 ;
                        dvcSetGain(hDevice, nGain);
                }
                        break;

                case VK_PRIOR:
                {
                        double dExpose = dvcGetExposeMsec(hDevice) ;
                        double dExposeInterval ;
                        dvcGetExposeInterval(hDevice,-1,-1,-1, &dExposeInterval) ;
                        double dNew = dvcSetExposeMsec(hDevice,dExpose+dExposeInterval);
                        int itt = 0 ;
                        while(dNew == dExpose && itt++ < 10)
                        {
                                dExposeInterval += 10.0 ;
                                dNew = dvcSetExposeMsec(hDevice,dExpose+dExposeInterval);
                        }
                }
                        break ;

                case VK_NEXT:
                {
                        double dExpose = dvcGetExposeMsec(hDevice) ;
                        double dExposeInterval ;
                        dvcGetExposeInterval(hDevice,-1,-1,-1, &dExposeInterval) ;
                        if(dExposeInterval == dExpose) dExposeInterval = 10.0 ;
                        double dNew = dvcSetExposeMsec(hDevice,dExpose-dExposeInterval);
                        int itt = 0 ;
                        while(dNew == dExpose && itt++ < 10)
                        {
                                dExposeInterval -= 10.0 ;
                                dNew = dvcSetExposeMsec(hDevice,dExpose+dExposeInterval);
                        }
                }
                        break ;

                case VK_LEFT:
                {
                        int nOffset ;
                        dvcGetOffset(hDevice, &nOffset);
                        nOffset -= 1 ;
                        if(nOffset < 0) nOffset = 0 ;
                        dvcSetOffset(hDevice, nOffset);
                }
                        break ;

                case VK_RIGHT:
                {
                        int nOffset ;
                        int maxOffset ;
                        dvcGetOffset(hDevice, &nOffset);
                        dvcGetParmRange(hDevice,aOffset,NULL,&maxOffset,NULL,NULL) ;
                        nOffset += 1 ;
                        if(nOffset > maxOffset) nOffset = maxOffset ;
                        dvcSetOffset(hDevice, nOffset);
                }
                        break ;

                case VK_HOME:
                {
                        int nDefault ;
                        dvcGetParmRange(hDevice,aGain,NULL,NULL,NULL, &nDefault);
                        dvcSetGain(hDevice,nDefault);
                        dvcGetParmRange(hDevice,aOffset,NULL,NULL,NULL, &nDefault);
                        dvcSetOffset(hDevice,nDefault);
                        dvcGetParmRange(hDevice,aExposureMode,NULL,NULL,NULL,&nDefault);
                        dvcSetExposureMode(hDevice,nDefault);
                        dvcGetParmRange(hDevice,aExposureDuration,
                                        NULL,NULL,NULL,&nDefault);
                        dvcSetExposureDuration(hDevice,nDefault);
                }
                        break ;

                case VK_SPACE:
                {
                        bPauseVideo = !bPauseVideo ;
                        if(bPauseVideo) dvcStopSequence(hDevice);
                        else dvcStartSequence(hDevice, 0) ;
                }
                        break ;
        }
                break;

        case WM_DESTROY:
                finiObjects();
                PostQuitMessage( 0 );
                break;
    }

    return DefWindowProc(hWnd, message, wParam, lParam);

} /* WindowProc */

/*
 * This function is called if the initialization function fails
 */
BOOL initFail( HWND hwnd )
{
    finiObjects();
    MessageBox( hwnd, "FullScreen Init FAILED", "DVCVideo", MB_OK );
    DestroyWindow( hwnd );
    return FALSE;

} /* initFail */

/*
 * doInit - do work required for every instance of the application:
 *                create the window, initialize data
 */
static BOOL doInit( HINSTANCE hInstance, int nCmdShow )
{
    HWND                hwnd;
    WNDCLASS            wc;
    DDSURFACEDESC       ddsd;
    DDSCAPS             ddscaps;
    HRESULT             ddrval;

    /*
     * set up and register window class
     */
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WindowProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon( hInstance, IDI_APPLICATION );
    wc.hCursor = LoadCursor( NULL, IDC_CROSS );
    wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wc.lpszMenuName = "DVCVideo";
    wc.lpszClassName = "DVCVideo";
    RegisterClass( &wc );
    
        screenWidth =  GetSystemMetrics(SM_CXSCREEN);
        screenHeight = GetSystemMetrics(SM_CYSCREEN);

    /*
     * create a window
     */
    hwnd = CreateWindowEx(
                        0,
                        "DVCVideo",
                        "FullScreen",
                        WS_POPUP,
                        0,
                        0,
                        screenWidth,
                        screenHeight,
                        NULL,
                        NULL,
                        hInstance,
                        NULL );

    if( !hwnd ) return FALSE;

        if(!InitCamera()) return initFail(hwnd);

    ShowWindow( hwnd, nCmdShow );
    UpdateWindow( hwnd );

    /*
     * create the main DirectDraw object
     */
    ddrval = DirectDrawCreate( NULL, &lpDD, NULL );
    if( ddrval != DD_OK ) return initFail(hwnd);

    // Get exclusive mode
    ddrval = lpDD->SetCooperativeLevel(
                                hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN 
                                        );
    if( ddrval != DD_OK ) return initFail(hwnd);

        if(bChangeDisplay)
        {
                ddrval = lpDD->SetDisplayMode( screenWidth, screenHeight, screenDepth);
                if( ddrval != DD_OK )
                {
                        screenDepth = 24 ;
                        ddrval = lpDD->SetDisplayMode(screenWidth,screenHeight,screenDepth);
                }
                if( ddrval != DD_OK )
                {
                        screenDepth = 16 ;
                        ddrval = lpDD->SetDisplayMode(screenWidth,screenHeight,screenDepth);
                }
                if( ddrval != DD_OK ) return initFail(hwnd);
        }

    // Create the primary surface with 1 back buffer
    ddsd.dwSize = sizeof( ddsd );
    ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
                          DDSCAPS_FLIP |
                          DDSCAPS_COMPLEX;
    ddsd.dwBackBufferCount = 1;
    ddrval = lpDD->CreateSurface( &ddsd, &lpDDSPrimary, NULL );
    if( ddrval != DD_OK ) return initFail(hwnd);

    ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
    ddrval = lpDDSPrimary->GetAttachedSurface(&ddscaps, &lpDDSBack);
    if( ddrval != DD_OK ) return initFail(hwnd);

    // Create a offscreen bitmap.
    ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
    ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
    ddsd.dwHeight = screenHeight;
    ddsd.dwWidth = screenWidth;
    ddrval = lpDD->CreateSurface( &ddsd, &lpDDSOne, NULL );
    if( ddrval != DD_OK ) return initFail(hwnd);

    // Create another offscreen bitmap.
    ddrval = lpDD->CreateSurface( &ddsd, &lpDDSTwo, NULL );
    if( ddrval != DD_OK ) return initFail(hwnd);

    // Create a timer to flip the pages
    if( !SetTimer( hwnd, TIMER_ID, timerRate, NULL ) ) return initFail(hwnd);

    return TRUE;

} /* doInit */

/*
 * WinMain - initialization, message loop
 */
int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                        LPSTR lpCmdLine, int nCmdShow)
{
    MSG         msg;

    lpCmdLine = lpCmdLine;
    hPrevInstance = hPrevInstance;

    if( !doInit( hInstance, nCmdShow ) ) return FALSE;

    while( GetMessage( &msg, NULL, 0, 0 ) )
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return msg.wParam;

} /* WinMain */


BOOL InitCamera( void )
{
    ULONG camWidth, camHeight ;

    hDevice = dvcOpenCamera(1);
    if(hDevice == INVALID_HANDLE_VALUE) return FALSE ;
    hReadEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
    // dvcResetCamera(hDevice);
    dvcSetReadCompleteEvent(hDevice, hReadEvent);
    if(!dvcStartSequence(hDevice,0)) return FALSE ;

    camWidth = dvcGetXDim(hDevice);
    camHeight = dvcGetYDim(hDevice);

    if(bChangeDisplay)
    {
        if(camWidth >= 1280){
                screenWidth = 1280 ;
                screenHeight = 1024 ;
        } else if(camWidth >= 1024){
                screenWidth = 1024 ;
                screenHeight = 768 ;
        } else if(camWidth >= 800){
                screenWidth = 800 ;
                screenHeight = 600 ;
        } else {
                screenWidth = 640 ;
                screenHeight = 480 ;
        }
    }

    timerRate = (ULONG)dvcGetTimeToReadImage(hDevice) ;
    if(timerRate < 10) timerRate = 10 ;
    dvcRenderControl_t rs ;
    memset(&rs,0, sizeof(dvcRenderControl_t));

    m_Image.GetRenderMethod(&rs);
    int nLutSize = dvcGetNBits(hDevice) == 10 ? 1024 : 4096 ;
    if(!rs.nLutSize != nLutSize) {
        rs.nLutSize = nLutSize ;
        rs.pRedLut = new BYTE[rs.nLutSize] ;
        rs.pGreenLut = new BYTE[rs.nLutSize] ;
        rs.pBlueLut = new BYTE[rs.nLutSize] ;
        int shift = dvcGetNBits(hDevice) == 10 ? 2 : 4 ;
        for(int i = 0 ; i < rs.nLutSize ;i++ )
        {
                rs.pRedLut[i] = 
                rs.pGreenLut[i] = 
                rs.pBlueLut[i] = i >> shift ;
        }
        dvcSetRGBLuts(hDevice, rs.pRedLut, rs.pGreenLut,rs.pBlueLut, rs.nLutSize);
        m_Image.SetRenderMethod(&rs);
        delete rs.pRedLut ;
        delete rs.pGreenLut ;
        delete rs.pBlueLut;
    }
    return TRUE ;
}

BOOL
GetBitMaskInfo( DWORD dwBitMask, DWORD* pdwShift, DWORD* pdwBits )
{
    DWORD dwShift = 0;
    DWORD dwBits  = 0; 

    if( pdwShift == NULL || pdwBits == NULL ) return FALSE;

    if( dwBitMask )
    {
        while( (dwBitMask & 1) == 0 )
        {
            dwShift++;
            dwBitMask >>= 1;
        }
    }

    while( (dwBitMask & 1) != 0 )
    {
        dwBits++;
        dwBitMask >>= 1;
    }

    *pdwShift = dwShift;
    *pdwBits  = dwBits;

    return TRUE;
}

BOOL UpdateDisplay()
{
    static  int phase = 0;
    static  BOOL bFirst = TRUE ;
    RECT        rcRect;
    HRESULT     ddrval;
    LPDIRECTDRAWSURFACE pdds;
    rcRect.left = 0;
    rcRect.top = 0;
    rcRect.right = screenWidth;
    rcRect.bottom = screenHeight;
    if(phase)
    {
        pdds = lpDDSTwo;
        phase = 0;
    }
    else
    {
        pdds = lpDDSOne;
        phase = 1;
    }

    BOOL bDraw = FALSE ;

    // Was a frame delivered ?
    if(WaitForSingleObject(hReadEvent,100) == WAIT_OBJECT_0)
    {
        bDraw = TRUE ;
        ULONG xOffset = 0, yOffset = 0, uWidth, uHeight ;
        ULONG xDisplayOffset = 0, yDisplayOffset = 0 ;
        uWidth = dvcGetImageWidth(hDevice);
        uHeight = dvcGetImageHeight(hDevice);
        if(uWidth > screenWidth)
        {
                xOffset = (uWidth - screenWidth)/2 ;
                uWidth = screenWidth ;
        }
        else if(screenWidth > uWidth )
        {
                xDisplayOffset = (screenWidth - uWidth) / 2 ;
        }

        if(uHeight > screenHeight)
        {
                yOffset = (uHeight - screenHeight)/2 ;
                uHeight = screenHeight ;
        }
        else if(screenHeight > uHeight )
        {
                yDisplayOffset = (screenHeight - uHeight) / 2 ;
        }
        m_Image.ReadCamera(hDevice, xOffset, yOffset, uWidth, uHeight);
        DDSURFACEDESC ddsd;
        ZeroMemory( &ddsd,sizeof(ddsd) );
        ddsd.dwSize = sizeof(ddsd);

        ddrval  = pdds->Lock(NULL,&ddsd,DDLOCK_WAIT,NULL) ;
        if(ddrval != DD_OK) return FALSE ;
        DWORD rgbBits = ddsd.ddpfPixelFormat.dwRGBBitCount ;

        BYTE* pDDSColor = (BYTE*) ddsd.lpSurface;
        ZeroMemory( pDDSColor, screenWidth*screenHeight*rgbBits/8 );
        if(xDisplayOffset > 0 || yDisplayOffset > 0)
        {
                BYTE *pOffset = &pDDSColor[yDisplayOffset * ddsd.lPitch
                                + xDisplayOffset * rgbBits / 8 ] ;
                pDDSColor = pOffset ;
        }
        if(bFirst)
        {
                bFirst = FALSE ;
                dvcRenderControl_t rs ;
                memset(&rs,0, sizeof(dvcRenderControl_t));
                m_Image.GetRenderMethod(&rs);
                if(rs.nLutSize) {
                        rs.pRedLut = new BYTE[rs.nLutSize] ;
                        rs.pGreenLut = new BYTE[rs.nLutSize] ;
                        rs.pBlueLut = new BYTE[rs.nLutSize] ;
                        m_Image.GetRenderMethod(&rs);
                }
                DWORD rbits, rshift, gbits, gshift, bbits, bshift;
                rs.redMask = (USHORT)ddsd.ddpfPixelFormat.dwRBitMask ;
                rs.greenMask = (USHORT)ddsd.ddpfPixelFormat.dwGBitMask ;
                rs.blueMask = (USHORT)ddsd.ddpfPixelFormat.dwBBitMask ;

                GetBitMaskInfo(ddsd.ddpfPixelFormat.dwRBitMask,&rshift,&rbits);
                GetBitMaskInfo(ddsd.ddpfPixelFormat.dwGBitMask,&gshift,&gbits);
                GetBitMaskInfo(ddsd.ddpfPixelFormat.dwBBitMask,&bshift,&bbits);

                rs.redBits = (USHORT)rbits ; rs.redShift = (USHORT)rshift ;
                rs.greenBits = (USHORT)gbits ; rs.greenShift = (USHORT)gshift ;
                rs.blueBits = (USHORT)bbits ; rs.blueShift = (USHORT)bshift ;
                rs.eMethod = DVC_RENDER_RGB ;

                m_Image.SetRenderMethod(&rs);
                if(rs.nLutSize) {
                        delete rs.pRedLut ;
                        delete rs.pGreenLut ;
                        delete rs.pBlueLut ;
                }
        }

        if(bScaleLuts)
        {
                bScaleLuts = FALSE ;
                m_Image.ScaleLuts(-1,-1);
        }

        m_Image.Render((PVOID)pDDSColor,NULL,ddsd.lPitch,(BYTE)rgbBits);
        pdds->Unlock(NULL);

    }

    char szText[80] ;
    HDC hdc ;
    pdds->GetDC(&hdc) ;
    SetBkMode(hdc, TRANSPARENT);
    SetTextColor(hdc, RGB(255,255,255));

    if(bShowHelp)
    {
        sprintf(szText,"F1:         Toggle Help menu");
        TextOut( hdc, 20, 40, szText, strlen(szText) );

        sprintf(szText,"Esc:        Exit Application");
        TextOut( hdc, 20, 60, szText, strlen(szText) );

        int nGain ;
        dvcGetGain(hDevice, &nGain);
        sprintf(szText,"Up/Dn:      Gain [%d]", nGain);
        TextOut( hdc, 20, 80, szText, strlen(szText) );

        int nOffset;
        dvcGetOffset(hDevice, &nOffset);
        sprintf(szText,"Left/Right: Offset [%d]", nOffset);
        TextOut( hdc, 20, 100, szText, strlen(szText) );

        sprintf(szText,"Page Up/Dn: Exposure %6.2f ms",
                                        dvcGetExposeMsec(hDevice) );
        TextOut( hdc, 20, 120, szText, strlen(szText) );
        sprintf(szText,"Home:       Reset");
        TextOut( hdc, 20, 140, szText, strlen(szText) );

        sprintf(szText,"Tab:         Toggle status line");
        TextOut( hdc, 20, 160, szText, strlen(szText) );

        sprintf(szText,"Space:       Toggle Pause/Live video");
        TextOut( hdc, 20, 180, szText, strlen(szText) );

        if(bPauseVideo) bDraw = TRUE ;

    }

    if(bShowStats)
    {
        ULONG xOffset = 20, xEnd ;
        ULONG yOffset = screenHeight-20 ;
        TEXTMETRIC tm ;
        GetTextMetrics(hdc,&tm);

        sprintf(szText,"ESC:exit  F1:Help");
        TextOut( hdc, xOffset, yOffset, szText, strlen(szText) );

        //xOffset += strlen(szText)*10+20 ;
        xOffset += strlen(szText)*tm.tmAveCharWidth + 20 ;

        sprintf(szText,"FPS: %5.2f",dvcGetFrameRate(hDevice));
        // sprintf(szText,"Frame: %d",dvcGetFrameCount(hDevice));
        xEnd = xOffset + strlen(szText)*tm.tmAveCharWidth + 20 ;
        if(xEnd < screenWidth)
        {
                TextOut( hdc, xOffset, yOffset, szText, strlen(szText) );
                xOffset = xEnd ;
        }

        int nValue ;
        dvcGetGain(hDevice,&nValue);
        sprintf(szText,"Gain: %d", nValue);
        xEnd = xOffset + strlen(szText)*tm.tmAveCharWidth + 20 ;
        if(xEnd < screenWidth)
        {
                TextOut( hdc, xOffset, yOffset, szText, strlen(szText) );
                xOffset = xEnd ;
        }

        dvcGetOffset(hDevice,&nValue);
        sprintf(szText,"Offset: %d", nValue);
        xEnd = xOffset + strlen(szText)*tm.tmAveCharWidth + 20 ;
        if(xEnd < screenWidth)
        {
                TextOut( hdc, xOffset, yOffset, szText, strlen(szText) );
                xOffset = xEnd ;
        }

        double dExpose = dvcGetExposeMsec(hDevice);
        sprintf(szText,"Exposure: %6.2f ms", dExpose);
        xEnd = xOffset + strlen(szText)*tm.tmAveCharWidth + 20 ;
        if(xEnd < screenWidth)
        {
                TextOut( hdc, xOffset, yOffset, szText, strlen(szText) );
                xOffset = xEnd ;
        }

        double dMean, dSd ;
        ULONG lMin, lMax ;

        m_Image.HistogramStats(&dMean,&dSd,&lMin,&lMax);
        sprintf(szText,"Mean: %6.2f +/- %6.2f", dMean, dSd);
        xEnd = xOffset + strlen(szText)*tm.tmAveCharWidth + 20 ;
        if(xEnd < screenWidth)
        {
                TextOut( hdc, xOffset, yOffset, szText, strlen(szText) );
                xOffset = xEnd ;
        }

        sprintf(szText,"Range: %d - %d", lMin, lMax);
        xEnd = xOffset + strlen(szText)*tm.tmAveCharWidth + 20 ;
        if(xEnd < screenWidth)
        {
                TextOut( hdc, xOffset, yOffset, szText, strlen(szText) );
                xOffset = xEnd ;
        }
    }

    pdds->ReleaseDC(hdc);
            
    while( bDraw )
    {
        ddrval = lpDDSBack->BltFast( 0, 0, pdds, &rcRect, FALSE );
        if( ddrval == DD_OK ) break;
        if( ddrval == DDERR_SURFACELOST )
        {
            ddrval = restoreAll();
            if( ddrval != DD_OK ) break;
        }
        if( ddrval != DDERR_WASSTILLDRAWING ) break;
    }
    
    // Flip surfaces
    while( bDraw )
    {
        ddrval = lpDDSPrimary->Flip( NULL, 0 );
        if( ddrval == DD_OK ) break;
        if( ddrval == DDERR_SURFACELOST )
        {
            ddrval = restoreAll();
            if( ddrval != DD_OK ) break;
        }
        if( ddrval != DDERR_WASSTILLDRAWING ) break;
    }

    return TRUE ;

}

---