/* 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; }
static void dx_free_buffers(char *b1, char *b2) { IDirectDrawSurface_Unlock(BackSurface[0], surface[0].lpSurface); IDirectDrawSurface_Unlock(BackSurface[1], surface[1].lpSurface); if (BackSurface[0]) IDirectDrawSurface_Release(BackSurface[0]); if (BackSurface[1]) IDirectDrawSurface_Release(BackSurface[1]); BackSurface[0] = NULL; BackSurface[1] = NULL; initialized = 0; buffer1 = buffer2 = NULL; }
void DDUnlockCanvas(dd_grs_canvas *canvas) { HRESULT ddresult; grs_bitmap *bmp; bmp = &canvas->canvas.cv_bitmap; if (canvas->lock_count == 1) { // if (canvas->sram && !GRMODEINFO(modex)) { // bmp->bm_data = bmp->bm_data - bmp->bm_x; // bmp->bm_data = bmp->bm_data - (bmp->bm_y*bmp->bm_rowsize); // } ddresult = IDirectDrawSurface_Unlock(canvas->lpdds, canvas->canvas.cv_bitmap.bm_data); if (ddresult != DD_OK) { Error("Unable to unlock canvas: %x\n", ddresult); exit(1); } canvas->canvas.cv_bitmap.bm_data = NULL; canvas->canvas.cv_bitmap.bm_rowsize = 0; _DDLockCounter--; } canvas->lock_count--; }
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); }
static void finiObjects() { if(lpDD!=NULL) { if(lpDDSPrimary!=NULL) { IDirectDrawSurface_Release(lpDDSPrimary); lpDDSPrimary=NULL; } if(lpDDSOne!=NULL) { IDirectDrawSurface_Unlock(lpDDSOne,NULL); IDirectDrawSurface_Release(lpDDSOne); lpDDSOne=NULL; } if(lpDDPal!=NULL) { IDirectDrawSurface_Release(lpDDPal); lpDDPal=NULL; } IDirectDrawSurface_Release(lpDD); lpDD=NULL; } if(mouse_hidden) ShowCursor(TRUE); }
// // Unlock surface // VOID UnlockScreen(VOID) { if (DD_OK != IDirectDrawSurface_Unlock(ScreenVirtual,NULL)) I_Error("Couldn't UnLock the renderer!"); ScreenLocked = FALSE; ScreenPtr = NULL; ScreenPitch = 0; }
static void Unlock( void * surface ) { LPDIRECTDRAWSURFACE lock_surface = ( LPDIRECTDRAWSURFACE ) surface; if( !surface ) return; IDirectDrawSurface_Unlock( lock_surface, 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); }
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); } } }
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); } }
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; }
void VGA_Unlock(void) { IDirectDrawSurface_Unlock(lpddsurf,sdesc.lpSurface); }