C++ (Cpp) LPDIRECTDRAW7::RestoreAllSurfaces Examples

Example #1

File: DirectDraw.cpp Project: hlemorvan/vision-stereo

//-----------------------------------------------------------------------------
// Name: dx_Restaure()
// Desc: Restaure les objets perdus (s'ils sont perdus)
//-----------------------------------------------------------------------------
void dx_Restaure ()
{
    if (SurfacePrimaire->IsLost () != DD_OK)
    {
        DirectDraw7->RestoreAllSurfaces ();
        (*Restaure)();
    }
}

Example #2

File: h264decode.cpp Project: blackart0/IPCStreamViewer

BOOL CH264Decode::PreviewDraw(H264_DEC_FRAME_S DecodeData)
{
	if (!m_bPreEnable)
	{
		return true;
	}

 	DDSURFACEDESC2 ddsd;
	const HI_U8 *pY = DecodeData.pY;
    const HI_U8 *pU = DecodeData.pU;
    const HI_U8 *pV = DecodeData.pV;
    HI_U32 width    = DecodeData.uWidth;
    HI_U32 height   = DecodeData.uHeight;
    HI_U32 yStride  = DecodeData.uYStride;
    HI_U32 uvStride = DecodeData.uUVStride;
	if (0 == width || 0 == height)
	{
		return true;
	}
	ZeroMemory(&ddsd,sizeof(DDSURFACEDESC2));
	ddsd.dwSize = sizeof(DDSURFACEDESC2);
	HRESULT hr;
	hr = m_pOffscreenSurface->Lock(NULL,&ddsd,DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,NULL);
	if (FAILED(hr))
	{
		m_dwLastError = hr;//GetLastError();
		switch(hr)
		{
		case DDERR_SURFACELOST:
			g_pDirectDraw7->RestoreAllSurfaces();
			break;
		case DDERR_SURFACEBUSY:
			m_pOffscreenSurface->Unlock(NULL);
			break;
		default:
			break;
		}
		return FALSE;
	}
	
	
	PBYTE pDestY = (PBYTE)ddsd.lpSurface;
	PBYTE pDestV = (PBYTE)ddsd.lpSurface + ddsd.lPitch * ddsd.dwHeight;
	PBYTE pDestU = (PBYTE)ddsd.lpSurface + ddsd.lPitch * ddsd.dwHeight*5/4;
	for (HI_U32 i = 0;i<height;i++)
	{
		memcpy(pDestY,pY,yStride);
		pDestY += ddsd.lPitch;
		pY += yStride;
	}
	

	for (i = 0;i<height/2;i++)
	{
		memcpy(pDestU,pU,uvStride);
		pDestU += ddsd.lPitch/2;
		pU += uvStride;
	}

	for (i = 0;i<height/2;i++)
	{
		memcpy(pDestV,pV,uvStride);
		pDestV += ddsd.lPitch/2;
		pV += uvStride;
	}
	hr = m_pOffscreenSurface->Unlock(NULL);

    EnterCriticalSection(&m_csCritial);
	if (m_PlayWnd != NULL)
	{
		RECT rcDsp;
		::GetClientRect( m_PlayWnd,&rcDsp);
		POINT ptTL;
		POINT ptRB;
		ptTL.x = rcDsp.left + 1;
		ptTL.y = rcDsp.top + 1;
		ptRB.x = rcDsp.right - 1;
		ptRB.y = rcDsp.bottom - 1;
		::ClientToScreen( m_PlayWnd,&ptTL);
		::ClientToScreen( m_PlayWnd,&ptRB);
		SetRect(&rcDsp,ptTL.x,ptTL.y,ptRB.x,ptRB.y);
		
		//写OSD

/*		HDC		dcTemp;
 		hr = m_pOSDSurface->GetDC(&dcTemp);
		DDSURFACEDESC2 ddsdOsd = {0};
		ddsdOsd.dwSize = sizeof(ddsdOsd);
		m_pOSDSurface->GetSurfaceDesc(&ddsdOsd);

		HBRUSH BackBrush = CreateSolidBrush(RGB(0,0,0));
		RECT rcOsd;
		SetRect(&rcOsd,0,0,ddsdOsd.dwWidth,ddsdOsd.dwHeight);
		FillRect(dcTemp,&rcOsd,BackBrush);
		DeleteObject(BackBrush);

		EnterCriticalSection(&m_csDcCallback);
 		if (NULL != dccallbackFun)
 		{
 			dccallbackFun(dcTemp,m_nDcChl,lpDcUser);
 		}
		LeaveCriticalSection(&m_csDcCallback);
		m_pOSDSurface->ReleaseDC(dcTemp);

		DDSURFACEDESC2 ddsdFin = {0};
		ddsdFin.dwSize = sizeof(ddsdFin);
		m_pFinSurface->GetSurfaceDesc(&ddsdFin);
		RECT rcFin;
		SetRect(&rcFin,0,0,ddsdFin.dwWidth,ddsdFin.dwHeight);

		hr = m_pFinSurface->Blt(&rcFin,m_pOffscreenSurface,&rcSrc,DDBLT_WAIT,NULL);
		hr = m_pFinSurface->Blt(&rcFin,m_pOSDSurface,NULL,DDBLT_WAIT | DDBLT_KEYSRC,NULL);*/
		RECT rcSrc;
		SetRect(&rcSrc,0,0,width,height);
		EnterCriticalSection(&g_csClipper);
		g_pClipper->SetHWnd(NULL,m_PlayWnd);
		if (::IsWindowVisible(m_PlayWnd))
		{
			g_pPrimarySurface->Blt(&rcDsp,m_pOffscreenSurface,&rcSrc,DDBLT_WAIT,0);	
		}
		LeaveCriticalSection(&g_csClipper);
	}
	 LeaveCriticalSection(&m_csCritial);

	return TRUE;
}