Пример #1
0
static void * Lock( win32_driver_t * win32_driver, void * surface )
{
  LPDIRECTDRAWSURFACE	lock_surface = ( LPDIRECTDRAWSURFACE ) surface;
  HRESULT		result;

  if( !surface )
    return 0;

  memset( &win32_driver->ddsd, 0, sizeof( win32_driver->ddsd ) );
  win32_driver->ddsd.dwSize = sizeof( win32_driver->ddsd );

  result = IDirectDrawSurface_Lock( lock_surface, 0, &win32_driver->ddsd, DDLOCK_WAIT | DDLOCK_NOSYSLOCK, 0 );
  if( result == DDERR_SURFACELOST )
    {
      IDirectDrawSurface_Restore( lock_surface );
      result = IDirectDrawSurface_Lock( lock_surface, 0, &win32_driver->ddsd, DDLOCK_WAIT | DDLOCK_NOSYSLOCK, 0 );

      if( result != DD_OK )
	return 0;

    }
  else if( result != DD_OK )
    {
      if( result == DDERR_GENERIC )
	{
	  Error( 0, "surface->Lock : error, DDERR_GENERIC" );
	  exit( 1 );
	}
    }

  return win32_driver->ddsd.lpSurface;
}
Пример #2
0
/* Display buffer */
static void PaintDD()
{
    DWORD ddrval;
    if (!IsWindowVisible(hWnd) || !active || !initialized
	|| !BackSurface[0])
	return;
    IDirectDrawSurface_Unlock(BackSurface[0], surface[0].lpSurface);
    IDirectDrawSurface_Unlock(BackSurface[1], surface[1].lpSurface);
    if (directX == DXFULLSCREEN) {
	if (storeddata)
	    free(storeddata), storeddata = NULL;
	storeddata =
	    store(currentbuff ? buffer2 : buffer1, bitDepth, lineSize,
		  displayX, displayY, mouseX, mouseY);
	drawmouse(currentbuff ? buffer2 : buffer1, mousepointer, bitDepth,
		  lineSize, displayX, displayY, mouseX, mouseY);
	ddrval =
	    IDirectDrawSurface_BltFast(lpSurfaces[0], 0, 0,
				       BackSurface[currentbuff], &rcScreen,
				       FALSE);
	restore(currentbuff ? buffer2 : buffer1, storeddata, bitDepth,
		lineSize, displayX, displayY, mouseX, mouseY);
	oldmouseX = mouseX;
	oldmouseY = mouseY;
    } else {
	ddrval = IDirectDrawSurface_Blt(lpSurfaces[0], &rcScreen,
					BackSurface[currentbuff],
					&rcViewport, DDBLT_WAIT, NULL);
    }
    if (ddrval != DD_OK) {
	if ((int) ddrval == (int) DDERR_SURFACELOST) {
	    IDirectDrawSurface_Restore(lpSurfaces[0]);
	    IDirectDrawSurface_Restore(BackSurface[0]);
	    IDirectDrawSurface_Restore(BackSurface[1]);
	    ddrval = IDirectDrawSurface_Blt(lpSurfaces[0], &rcScreen,
					    BackSurface[currentbuff],
					    &rcViewport, DDBLT_WAIT, NULL);
	    //if (ddrval == DDERR_SURFACELOST) resized=1; /*We've lost our fractal*/
	}
    }
    ddrval = IDirectDrawSurface_Lock(BackSurface[0], NULL, &surface[0],
				     DDLOCK_WAIT, NULL);
    ddrval = IDirectDrawSurface_Lock(BackSurface[1], NULL, &surface[1],
				     DDLOCK_WAIT, NULL);
    if (buffer1 != (char *) surface[0].lpSurface ||
	buffer2 != (char *) surface[1].lpSurface) {
	DeInitDD();
	x_fatalerror
	    ("Unexpected event - buffers moved! Please contact authors!");
    }
    needredraw = 0;

}
Пример #3
0
static void dctest_surf(IDirectDrawSurface *surf, int ddsdver) {
    HRESULT hr;
    HDC dc, dc2 = (HDC) 0x1234;
    DDSURFACEDESC ddsd;
    DDSURFACEDESC2 ddsd2;

    memset(&ddsd, 0, sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
    memset(&ddsd2, 0, sizeof(ddsd2));
    ddsd2.dwSize = sizeof(ddsd2);

    hr = IDirectDrawSurface_GetDC(surf, &dc);
    ok(hr == DD_OK, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr);

    hr = IDirectDrawSurface_GetDC(surf, &dc);
    ok(hr == DDERR_DCALREADYCREATED, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr);
    ok(dc2 == (HDC) 0x1234, "The failed GetDC call changed the dc: %p\n", dc2);

    hr = IDirectDrawSurface_Lock(surf, NULL, ddsdver == 1 ? &ddsd : ((DDSURFACEDESC *) &ddsd2), 0, NULL);
    ok(hr == DDERR_SURFACEBUSY, "IDirectDrawSurface_Lock returned 0x%08x, expected DDERR_SURFACEBUSY\n", hr);

    hr = IDirectDrawSurface_ReleaseDC(surf, dc);
    ok(hr == DD_OK, "IDirectDrawSurface_ReleaseDC failed: 0x%08x\n", hr);
    hr = IDirectDrawSurface_ReleaseDC(surf, dc);
    ok(hr == DDERR_NODC, "IDirectDrawSurface_ReleaseDC returned 0x%08x, expected DDERR_NODC\n", hr);
}
Пример #4
0
static void UpdateMouseDD()
{
    DDSURFACEDESC m_surface;
    PUCHAR dst;
    DWORD ddrval;
    memset(&m_surface, 0, sizeof(DDSURFACEDESC));
    m_surface.dwSize = sizeof(DDSURFACEDESC);
    ddrval = IDirectDrawSurface_Lock(lpSurfaces[0], NULL, &m_surface,
				     DDLOCK_WAIT, NULL);
    if (ddrval != DD_OK) {
	return;
    }

    dst = (PUCHAR) m_surface.lpSurface;
    if (storeddata) {
	restore(dst, storeddata, bitDepth, m_surface.u1.lPitch, displayX,
		displayY, oldmouseX, oldmouseY);
	free(storeddata);
    }
    storeddata =
	store(dst, bitDepth, m_surface.u1.lPitch, displayX, displayY,
	      mouseX, mouseY);
    drawmouse(dst, mousepointer, bitDepth, m_surface.u1.lPitch, displayX,
	      displayY, mouseX, mouseY);
    oldmouseX = mouseX;
    oldmouseY = mouseY;
    IDirectDrawSurface_Unlock(lpSurfaces[0], m_surface.lpSurface);
}
Пример #5
0
//
// Lock surface before multiple drawings by hand, for speed
//
boolean LockScreen(VOID)
{
	DDSURFACEDESC ddsd;
	HRESULT ddrval;

	ZeroMemory(&ddsd, sizeof (ddsd));
	ddsd.dwSize = sizeof (ddsd);

	// attempt to Lock the surface
	ddrval = IDirectDrawSurface_Lock(ScreenVirtual, NULL, &ddsd, DDLOCK_WAIT, NULL);

	// Always, always check for errors with DirectX!
	// If the surface was lost, restore it.
	if (ddrval == DDERR_SURFACELOST)
	{
		ddrval = IDirectDrawSurface_Restore(ScreenReal);

		// now retry to get the lock
		ddrval = IDirectDrawSurface_Lock(ScreenVirtual, NULL, &ddsd, DDLOCK_WAIT, NULL);
	}

	if (ddrval == DD_OK)
	{
		ScreenLocked = TRUE;
		ScreenPtr    = (LPBYTE)ddsd.lpSurface;
		ScreenPitch = ddsd.
#ifdef DUMMYUNIONNAMEN
		 DUMMYUNIONNAMEN(1).
#endif
		 lPitch;
	}
	else
	{
		ScreenLocked = FALSE;
		ScreenPtr = NULL;
		ScreenPitch = 0;
		//I_Error("LockScreen() : couldn't restore the surface.");
		return false;
	}
	return true;
}
Пример #6
0
LPSTR VGA_Lock(unsigned*Pitch,unsigned*Height,unsigned*Width,unsigned*Depth)
{
    if (!lpddraw) return NULL;
    if (!lpddsurf) return NULL;
    if (IDirectDrawSurface_Lock(lpddsurf,NULL,&sdesc,0,0)) {
        ERR("could not lock surface!\n");
        return NULL;
    }
    if (Pitch) *Pitch=sdesc.u1.lPitch;
    if (Height) *Height=sdesc.dwHeight;
    if (Width) *Width=sdesc.dwWidth;
    if (Depth) *Depth=sdesc.ddpfPixelFormat.u1.dwRGBBitCount;
    return sdesc.lpSurface;
}
Пример #7
0
static void dctest_sysvidmem(IDirectDrawSurface *surf, int ddsdver) {
    HRESULT hr;
    HDC dc, dc2 = (HDC) 0x1234;
    DDSURFACEDESC ddsd;
    DDSURFACEDESC2 ddsd2;

    memset(&ddsd, 0, sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
    memset(&ddsd2, 0, sizeof(ddsd2));
    ddsd2.dwSize = sizeof(ddsd2);

    hr = IDirectDrawSurface_GetDC(surf, &dc);
    ok(hr == DD_OK, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr);

    hr = IDirectDrawSurface_GetDC(surf, &dc2);
    ok(hr == DD_OK, "IDirectDrawSurface_GetDC failed: 0x%08x\n", hr);
    ok(dc == dc2, "Got two different DCs\n");

    hr = IDirectDrawSurface_Lock(surf, NULL, ddsdver == 1 ? &ddsd : ((DDSURFACEDESC *) &ddsd2), 0, NULL);
    ok(hr == DD_OK, "IDirectDrawSurface_Lock returned 0x%08x, expected DD_OK\n", hr);

    hr = IDirectDrawSurface_Lock(surf, NULL, ddsdver == 1 ? &ddsd : ((DDSURFACEDESC *) &ddsd2), 0, NULL);
    ok(hr == DDERR_SURFACEBUSY, "IDirectDrawSurface_Lock returned 0x%08x, expected DDERR_SURFACEBUSY\n", hr);

    hr = IDirectDrawSurface_Unlock(surf, NULL);
    ok(hr == DD_OK, "IDirectDrawSurface_Unlock returned 0x%08x, expected DD_OK\n", hr);
    hr = IDirectDrawSurface_Unlock(surf, NULL);
    ok(hr == DDERR_NOTLOCKED, "IDirectDrawSurface_Unlock returned 0x%08x, expected DDERR_NOTLOCKED\n", hr);

    hr = IDirectDrawSurface_ReleaseDC(surf, dc);
    ok(hr == DD_OK, "IDirectDrawSurface_ReleaseDC failed: 0x%08x\n", hr);
    hr = IDirectDrawSurface_ReleaseDC(surf, dc);
    ok(hr == DD_OK, "IDirectDrawSurface_ReleaseDC failed: 0x%08x\n", hr);
    /* That works any number of times... */
    hr = IDirectDrawSurface_ReleaseDC(surf, dc);
    ok(hr == DD_OK, "IDirectDrawSurface_ReleaseDC failed: 0x%08x\n", hr);
}
Пример #8
0
void DDLockCanvas(dd_grs_canvas *canvas)
{
	HRESULT ddresult;
	DDSURFACEDESC ddsd;
	RECT rect;
	grs_bitmap *bmp;


	bmp = &canvas->canvas.cv_bitmap;
	memset(&ddsd, 0, sizeof(ddsd));
	ddsd.dwSize = sizeof(ddsd);
	
	if (canvas->lock_count == 0) {
	// Obtain info about a rectangle on the surface
		SetRect(&rect, bmp->bm_x, bmp->bm_y, 
				bmp->bm_x+bmp->bm_w, bmp->bm_y+bmp->bm_h);

	RetryLock:

		ddresult = IDirectDrawSurface_Lock(canvas->lpdds, 	
										&rect,
										&ddsd,
										DDLOCK_WAIT,
										NULL);
		if (ddresult != DD_OK) {
			if (ddresult == DDERR_SURFACELOST) {
				if (!DDRestoreCanvas(canvas))
					Error("Unable to restore surface for lock:");
				else goto RetryLock;
			}
			else {
				while (canvas->lock_count) DDUnlockCanvas(canvas);
				Error("Unable to lock canvas: %x\n", ddresult);
			}
		}
		bmp->bm_data = (unsigned char *)ddsd.lpSurface;
		bmp->bm_rowsize = (short)ddsd.lPitch;

//		if (canvas->sram && !GRMODEINFO(modex)) {
//		//	Manually calculate?
//			bmp->bm_data = bmp->bm_data + (bmp->bm_y*bmp->bm_rowsize);
//			bmp->bm_data += bmp->bm_x;
//		} 

		_DDLockCounter++;
	}
	canvas->lock_count++;
}
Пример #9
0
static void flip_page(void)
{
    DDSURFACEDESC2 ddsd;
    HRESULT dxresult;

    IDirectDrawSurface_Unlock(g_lpddsBack, NULL);

    if (g_doublebuffer) {
        dxresult = IDirectDrawSurface_Flip(g_lpddsOverlay, NULL, DDFLIP_WAIT);
        if (dxresult == DDERR_SURFACELOST) {
            av_log(NULL, AV_LOG_INFO, "vo_directx: Lost, Restoring Surface\n");
            IDirectDrawSurface_Restore(g_lpddsBack);
            IDirectDrawSurface_Restore(g_lpddsOverlay);
            IDirectDrawSurface_Restore(g_lpddsPrimary);
            dxresult = IDirectDrawSurface_Flip(g_lpddsOverlay, NULL, DDFLIP_WAIT);
        }
        if (dxresult != DD_OK) {
            av_log(NULL, AV_LOG_ERROR, "vo_directx: can not flip page\n");
        }
    } else {
        DDBLTFX ddbltfx;
        memset(&ddbltfx, 0, sizeof(DDBLTFX));
        ddbltfx.dwSize = sizeof(DDBLTFX);
        ddbltfx.dwDDFX = DDBLTFX_NOTEARING;
        IDirectDrawSurface_Blt(g_lpddsPrimary, &rd, g_lpddsBack, NULL, DDBLT_WAIT,
                               &ddbltfx);
    }

    memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
    ddsd.dwSize = sizeof(DDSURFACEDESC2);
    if (IDirectDrawSurface_Lock(g_lpddsBack, NULL, &ddsd,
                                DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL) == DD_OK) {
        if (tmp_image) {
            free(tmp_image);
            tmp_image = NULL;
        }
        g_dstride = ddsd.lPitch;
        g_image = ddsd.lpSurface;
    } else {
        if (!tmp_image) {
            av_log(NULL, AV_LOG_INFO,
                   "Locking the surface failed, rendering to a hidden surface!\n");
            tmp_image = g_image = calloc(1, g_image_height * g_dstride * 2);
        }
    }
}
Пример #10
0
static int dx_alloc_buffers(char **b1, char **b2)
{
    DWORD ddrval;
    DDSURFACEDESC ddsd;
    int i;
    currentbuff = 0;
    memset(surface, 0, sizeof(DDSURFACEDESC) * 2);
    memset(&ddsd, 0, sizeof(DDSURFACEDESC));
    ddsd.dwSize = sizeof(ddsd);
    if (IDirectDrawSurface_GetSurfaceDesc(lpSurfaces[0], &ddsd) != DD_OK) {
	DeInitDD();
	x_error("Failed to get pixel format");
	return 0;
    }
    for (i = 0; i < 2; i++) {
	ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
	ddsd.dwWidth = displayX;
	ddsd.dwHeight = displayY;
	ddsd.ddsCaps.dwCaps =
	    DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;

	ddrval =
	    IDirectDraw_CreateSurface(lpDD, &ddsd, &BackSurface[i], NULL);
	if (ddrval != DD_OK) {
	    DeInitDD();
	    x_error("Failed to create back surface");
	    return 0;
	}
    }
    for (i = 0; i < 2; i++) {
	surface[i].dwSize = sizeof(DDSURFACEDESC);
	ddrval = IDirectDrawSurface_Lock(BackSurface[i], NULL, surface + i,
					 DDLOCK_WAIT, NULL);
	if (ddrval != DD_OK) {
	    DeInitDD();
	    x_fatalerror("Failed to lock offscreen surfaces");
	}
    }
    buffer1 = *b1 = (char *) surface[0].lpSurface;
    buffer2 = *b2 = (char *) surface[1].lpSurface;
    lineSize = surface[0].u1.lPitch;
    initialized = 1;
    return lineSize;
}
Пример #11
0
static void DDCopy(GE2DBitmapType *p)
{
	DDSURFACEDESC Desc;
	memset(&Desc,0,sizeof(DDSURFACEDESC));
	Desc.dwSize = sizeof(DDSURFACEDESC);

	if (IDirectDrawSurface_Lock(DDBuffer,NULL,&Desc,DDLOCK_WAIT,NULL) == DD_OK)
	{
		int y,n;
		uint8_t* i = (uint8_t*)Desc.lpSurface;
		n = Desc.lPitch*p->height;
		for (y=0;y<p->height;++y)
			memcpy(i+y*Desc.lPitch,(char*)p->plane1P+p->pitch*y,p->width);
		for (y=0;y<(p->height/2);++y)
		{
			memcpy(i+n+y*(Desc.lPitch/2),(char*)p->plane2P+p->chromaPitch*y,p->width/2);
			memcpy(i+n+n/4+y*(Desc.lPitch/2),(char*)p->plane3P+p->chromaPitch*y,p->width/2);
		}
		IDirectDrawSurface_Unlock(DDBuffer,NULL);
	}
}
Пример #12
0
Файл: ddgfx.c Проект: btb/d2x
int dd_gfx_loadbitmap2D(unsigned short handle, void *buf, int rleflag)
{
	HRESULT ddresult;
	DDSURFACEDESC ddsd;
	char *ptr;
	int pitch, i;
	grs_bitmap tbmp;

	Assert(handle != 0);

	if (!dd_gfx_initialized) return 0;

	handle--;									// Convert to valid handle

RedoLock:

	memset(&ddsd, 0, sizeof(ddsd));
	ddsd.dwSize = sizeof(ddsd);

	ddresult = IDirectDrawSurface_Lock(gfxBitmap[handle].lpdds, NULL,	&ddsd, DDLOCK_WAIT, NULL);
	if (ddresult != DD_OK) {
		if (ddresult == DDERR_SURFACELOST) {
			ddresult = IDirectDrawSurface_Restore(gfxBitmap[handle].lpdds);
			if (ddresult != DD_OK) {
				if (ddresult != DDERR_WRONGMODE) {
					logentry("DDGFX::Restore::Surface err: %x\n", ddresult);		
					return 1;
				}
				else {
					LPDIRECTDRAWSURFACE lpdds;
					DDCOLORKEY ddck;

					IDirectDrawSurface_Release(lpdds);
					gfxBitmap[handle].lpdds = NULL;

					memset(&ddsd, 0, sizeof(ddsd));
					ddsd.dwSize = sizeof(ddsd);
					ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
					ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY;
					ddsd.dwWidth = gfxBitmap[handle].w;
					ddsd.dwHeight = gfxBitmap[handle].h;

					ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &lpdds, NULL);

					if (ddresult != DD_OK) {
						mprintf((0, "DDGFX: Failed to restore vidmem 2d bitmap.\n"));
						return 1;
					}
   				ddck.dwColorSpaceLowValue = TRANSPARENCY_COLOR;
   				ddck.dwColorSpaceHighValue = TRANSPARENCY_COLOR;
   				IDirectDrawSurface_SetColorKey(lpdds, DDCKEY_SRCBLT, &ddck);
					gfxBitmap[handle].lpdds = lpdds;
				}
			}
			
			goto RedoLock;
		}
		else {
			mprintf((0, "DDGFX:Unable to lock surface!!\n"));
			return 1;
		}
	}

//	Locked!
	ptr = ddsd.lpSurface;
	pitch = ddsd.lPitch;	

	gr_init_bitmap(&tbmp, BM_LINEAR, 0,0,gfxBitmap[handle].w, gfxBitmap[handle].h, gfxBitmap[handle].w, buf);
	if (rleflag) tbmp.bm_flags = BM_FLAG_RLE;

	for(i = 0; i < gfxBitmap[handle].h; i++) 
	{
		extern ubyte scale_rle_data[];
		if (rleflag) {
			decode_row(&tbmp,i);
			memcpy(ptr+(i*pitch), scale_rle_data, gfxBitmap[handle].w);
		} 
	  	else memcpy(ptr+(i*pitch), (ubyte*)(buf)+(i*gfxBitmap[handle].w), gfxBitmap[handle].w);
	}
	
	IDirectDrawSurface_Unlock(gfxBitmap[handle].lpdds, ptr);

//	Unlocked...

	return 0;
}
Пример #13
0
static int vo_dx_init(void)
{
    DDSURFACEDESC2 ddsd;

    dw = g_image_width = dlpctxp->pwidth;
    dh = g_image_height = dlpctxp->pheight;
    g_screen_width = GetSystemMetrics(SM_CXSCREEN);
    g_screen_height = GetSystemMetrics(SM_CYSCREEN);
    dx = (g_screen_width - dw) / 2;
    dy = (g_screen_height - dh) / 2;

    if (FALSE == DxCreateWindow()) {
        av_log(NULL, AV_LOG_ERROR, "DxCreateWindow step\n");
        return -1;
    }

    if (FALSE == DxInitDirectDraw()) {
        av_log(NULL, AV_LOG_ERROR, "DxInitDirectDraw step\n");
        return -1;
    }

    if (FALSE == DxCreatePrimarySurface()) {
        av_log(NULL, AV_LOG_ERROR, "DxCreatePrimarySurface step\n");
        return -1;
    }

    if (FALSE == DxCreateOverlay()) {
        av_log(NULL, AV_LOG_ERROR, "DxCreateOverlay step\n");
        if (FALSE == DxCreateOffbuffer()) {
            av_log(NULL, AV_LOG_ERROR, "DxCreateOffbuffer step\n");
            return -1;
        }
    }

    if (FALSE == DxGetCaps()) {
        av_log(NULL, AV_LOG_ERROR, "DxGetCaps step\n");
        return -1;
    }
    if (FALSE == DxManageOverlay()) {
        av_log(NULL, AV_LOG_ERROR, "DxManageOverlay step\n");
        return -1;
    }

    memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
    ddsd.dwSize = sizeof(DDSURFACEDESC2);
    if (IDirectDrawSurface_Lock(g_lpddsBack, NULL, &ddsd,
                                DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL) != DD_OK) {
        av_log(NULL, AV_LOG_ERROR, "Lock Back Buffer step\n");
        return -1;
    }
    g_dstride = ddsd.lPitch;
    g_image = ddsd.lpSurface;
    av_log(NULL, AV_LOG_ERROR, "vo dx init ok\n");

    /* -------- create picture ----------------- */
    my_pic = av_mallocz(sizeof(AVPicture));
    if (-1 == avpicture_alloc(my_pic, g_image_format, g_image_width,
                              g_image_height)) {
        av_log(NULL, AV_LOG_ERROR, "avpicture alloc error\n");
        return -1;
    }

    g_inited = 1;
    return 0;
}