Context Navigation

os2ddraw.cpp

Visit:

Last change on this file was 21916, checked in by dmik, 14 years ago
Merge branch gcc-kmk to trunk.
File size: 66.4 KB

Rev	Line
[5291]	1	/* $Id: OS2DDRAW.CPP,v 1.3 2001-03-09 22:48:47 mike Exp $ */
[3345]	2
	3	/*
	4	* DX Draw base class implementation
	5	*
	6	* Copyright 1998 Sander van Leeuwen
	7	* Copyright 1999 Markus Montkowski
	8	* Copyright 2000 Przemyslaw Dobrowolski
[5291]	9	* Copyright 2001 Michal Necasek
[3345]	10	*
	11	* Project Odin Software License can be found in LICENSE.TXT
	12	*
	13	*/
[5291]	14
[3345]	15	#include <stdlib.h>
	16	#include <string.h>
	17	#include <memory.h>
	18
	19	#define INITGUID
	20	#include "os2ddraw.h"
	21	#include "os2clipper.h"
	22	#include "os2palette.h"
	23	#include "os2surface.h"
	24	#define _OS2WIN_H
	25	#define FAR
	26	#include <misc.h>
	27	#include <string.h>
	28	#include <winreg.h>
	29	#include <winuser.h>
	30	#include <winerror.h>
	31	#include "cio2.h"
	32	#include "os2util.h"
	33	#include "os2fsdd.h"
	34	// include with the videomodes we support
	35	// better would be to get these modes from the card
	36	// But for now we use standard VESA 2.0 modes with 70Hz
	37	#include "os2ddrawmodes.h"
	38	#include "os2DDWindow.h"
	39	#include "os2palset.h"
	40
	41	#define KEY_DIRECT2 "\\Software\\Win32OS2\\Direct2"
	42	#define KEY_DIRECT2DRAW "\\Software\\Win32OS2\\Direct2\\Draw"
	43
	44	FOURCC SupportedFourCCs[] = {FOURCC_SCRN,FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_RGB4};
	45	//******************************************************************************
	46	//******************************************************************************
	47	OS2IDirectDraw::OS2IDirectDraw(GUID *lpGUID) :
	48	Referenced(0), lastError(DD_OK),
	49	pFrameBuffer(NULL), hwndClient(0), screenwidth(640),
[5291]	50	screenheight(480), screenbpp(8),PrimaryExists(FALSE),pPrimSurf(NULL)
[3345]	51
	52	{
	53	HKEY hkDirectDraw2;
	54	DWORD dwVSize, dwVType;
	55	ULONG rc;
	56	FOURCC fccModes[100];
	57
	58	// Setup table for 3d devices
	59	Vtbl3D.AddRef = D3DAddRef;
	60	Vtbl3D.Release = D3DRelease;
	61	Vtbl3D.QueryInterface = D3DQueryInterface;
	62	Vtbl3D.Initialize = D3DInitialize;
	63	Vtbl3D.EnumDevices = D3DEnumDevices;
	64	Vtbl3D.CreateLight = D3DCreateLight;
	65	Vtbl3D.CreateMaterial = D3DCreateMaterial;
	66	Vtbl3D.CreateViewport = D3DCreateViewport;
	67	Vtbl3D.FindDevice = D3DFindDevice;
	68
[5291]	69	// Org Interface
[3345]	70	Vtbl.AddRef = DrawAddRef;
	71	Vtbl.Release = DrawRelease;
	72	Vtbl.QueryInterface = DrawQueryInterface;
	73	Vtbl.Compact = DrawCompact;
	74	Vtbl.CreateClipper = DrawCreateClipper;
	75	Vtbl.CreatePalette = DrawCreatePalette;
	76	Vtbl.CreateSurface = DrawCreateSurface;
	77	Vtbl.DuplicateSurface = DrawDuplicateSurface;
	78	Vtbl.EnumDisplayModes = DrawEnumDisplayModes;
	79	Vtbl.EnumSurfaces = DrawEnumSurfaces;
	80	Vtbl.FlipToGDISurface = DrawFlipToGDISurface;
	81	Vtbl.GetCaps = DrawGetCaps;
	82	Vtbl.GetDisplayMode = DrawGetDisplayMode;
	83	Vtbl.GetFourCCCodes = DrawGetFourCCCodes;
	84	Vtbl.GetGDISurface = DrawGetGDISurface;
	85	Vtbl.GetMonitorFrequency = DrawGetMonitorFrequency;
	86	Vtbl.GetScanLine = DrawGetScanLine;
	87	Vtbl.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
	88	Vtbl.Initialize = DrawInitialize;
	89	Vtbl.RestoreDisplayMode = DrawRestoreDisplayMode;
	90	Vtbl.SetCooperativeLevel = DrawSetCooperativeLevel;
[5291]	91	Vtbl.SetDisplayMode = DrawSetDisplayMode;
[3345]	92	Vtbl.WaitForVerticalBlank = DrawWaitForVerticalBlank;
	93
[5291]	94	// V2 Interface
	95
	96	Vtbl2.AddRef = DrawAddRef;
	97	Vtbl2.Release = DrawRelease;
	98	Vtbl2.QueryInterface = DrawQueryInterface;
	99	Vtbl2.Compact = DrawCompact;
	100	Vtbl2.CreateClipper = DrawCreateClipper;
	101	Vtbl2.CreatePalette = DrawCreatePalette;
	102	Vtbl2.CreateSurface = DrawCreateSurface;
	103	Vtbl2.DuplicateSurface = DrawDuplicateSurface;
	104	Vtbl2.EnumDisplayModes = DrawEnumDisplayModes;
	105	Vtbl2.EnumSurfaces = DrawEnumSurfaces;
	106	Vtbl2.FlipToGDISurface = DrawFlipToGDISurface;
	107	Vtbl2.GetCaps = DrawGetCaps;
	108	Vtbl2.GetDisplayMode = DrawGetDisplayMode;
	109	Vtbl2.GetFourCCCodes = DrawGetFourCCCodes;
	110	Vtbl2.GetGDISurface = DrawGetGDISurface;
	111	Vtbl2.GetMonitorFrequency = DrawGetMonitorFrequency;
	112	Vtbl2.GetScanLine = DrawGetScanLine;
	113	Vtbl2.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
	114	Vtbl2.Initialize = DrawInitialize;
	115	Vtbl2.RestoreDisplayMode = DrawRestoreDisplayMode;
	116	Vtbl2.SetCooperativeLevel = DrawSetCooperativeLevel;
	117	Vtbl2.SetDisplayMode = DrawSetDisplayMode2;
	118	Vtbl2.WaitForVerticalBlank = DrawWaitForVerticalBlank;
	119	Vtbl2.GetAvailableVidMem = DrawGetAvailableVidMem;
	120
[3345]	121	// New V4 interface
	122	Vtbl4.AddRef = DrawAddRef; // todo change to a DrawAddRef4 as handling this has changed
	123	Vtbl4.Release = DrawRelease; // see above
	124	Vtbl4.QueryInterface = DrawQueryInterface;
	125	Vtbl4.Compact = DrawCompact;
	126	Vtbl4.CreateClipper = DrawCreateClipper;
[5291]	127	Vtbl4.CreatePalette = DrawCreatePalette;
[3345]	128	Vtbl4.CreateSurface = DrawCreateSurface4;//
	129	Vtbl4.DuplicateSurface = DrawDuplicateSurface4;//
	130	Vtbl4.EnumDisplayModes = DrawEnumDisplayModes4;//
	131	Vtbl4.EnumSurfaces = DrawEnumSurfaces4; //
	132	Vtbl4.FlipToGDISurface = DrawFlipToGDISurface;
	133	Vtbl4.GetCaps = DrawGetCaps;
	134	Vtbl4.GetDisplayMode = DrawGetDisplayMode4;//
	135	Vtbl4.GetFourCCCodes = DrawGetFourCCCodes;
	136	Vtbl4.GetGDISurface = DrawGetGDISurface4;//
	137	Vtbl4.GetMonitorFrequency = DrawGetMonitorFrequency;
	138	Vtbl4.GetScanLine = DrawGetScanLine;
	139	Vtbl4.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
	140	Vtbl4.Initialize = DrawInitialize;
	141	Vtbl4.RestoreDisplayMode = DrawRestoreDisplayMode;
	142	Vtbl4.SetCooperativeLevel = DrawSetCooperativeLevel;
	143	Vtbl4.SetDisplayMode = DrawSetDisplayMode2;
	144	Vtbl4.WaitForVerticalBlank = DrawWaitForVerticalBlank;
	145	Vtbl4.GetAvailableVidMem = DrawGetAvailableVidMem4;
	146	Vtbl4.GetSurfaceFromDC = DrawGetSurfaceFromDC;
	147	Vtbl4.RestoreAllSurfaces = DrawRestoreAllSurfaces;
	148	Vtbl4.TestCooperativeLevel = DrawTestCooperativeLevel;
	149	Vtbl4.GetDeviceIdentifier = DrawGetDeviceIdentifier;
	150
	151	if(lpGUID && *lpGUID == IID_IDirect3D)
	152	{
[5291]	153	dprintf(("DDRAW: D3D Interface -> using V4 Interface"));
[3345]	154
[5291]	155	lpVtbl = &Vtbl4;
[3345]	156	}
	157	else
	158	{
	159	if(lpGUID && *lpGUID == IID_IDirectDraw4)
	160	{
	161	dprintf(("DDRAW: V4 Interface\n"));
	162	lpVtbl = &Vtbl4;
	163	}
	164	else
	165	{
	166	dprintf(("DDRAW: <V4 Interface\n"));
	167	lpVtbl = (IDirectDraw4Vtbl *) &Vtbl;
	168	}
	169	}
	170
	171	lpVtbl2 = lpVtbl;
	172
	173	pdwUnknownData = (DWORD) malloc (255sizeof(DWORD));
	174	for(int i= 0 ;i<255;i++)
	175	pdwUnknownData[i] = 0;
	176
	177	rc = DiveOpen( &hDive,
	178	FALSE,
	179	&pFrameBuffer);
	180	if(rc)
	181	{
	182	dprintf(("DDRAW: ERROR: DiveOpen returned %d\n", rc));
	183	lastError = DDERR_GENERIC;
	184	hDive = NULL;
	185	}
	186	else
	187	{
	188	dprintf(("DDRAW: DiveOpen OK Framebuufer at 0x%08X\n",pFrameBuffer));
	189	}
	190	memset( &dCaps,
	191	0,
	192	sizeof(DIVE_CAPS) );
	193	dCaps.ulStructLen = sizeof(DIVE_CAPS);
	194	dCaps.ulFormatLength = 100;
	195	dCaps.pFormatData = &fccModes[0];
	196
	197	rc = DiveQueryCaps( &dCaps,
	198	DIVE_BUFFER_SCREEN);
	199
	200	dprintf(("DDRAW: DiveQueryCaps rc=0x%08X\n",rc));
	201
	202	pdwUnknownData[235] = dCaps.ulHorizontalResolution;
	203	pdwUnknownData[236] = dCaps.ulVerticalResolution;
	204	pdwUnknownData[241] = dCaps.ulDepth;
	205
	206	// Shall we run in FS mode ?
	207	if(ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,KEY_DIRECT2DRAW,&hkDirectDraw2))
	208	{
	209	dwVSize = 4;
	210	dwVType = REG_DWORD;
	211	if(ERROR_SUCCESS!=RegQueryValueExA(hkDirectDraw2,"Fullscreen",NULL,&dwVType,(LPBYTE)&bScale,&dwVSize))
	212	bScale = FALSE;
	213	}
	214	else
	215	bScale = FALSE;
	216
	217	rc = InitIO();
	218
	219	if(rc) // try to get IOPL for the thread
	220	{
	221	dprintf(("DDRAW: No IOPL\n"));
	222	}
	223	else
	224	{
	225	dprintf(("DDRAW: IOPL 3!\n"));
	226	}
	227
[5291]	228	// FSDDRAW additions
[3345]	229	rc = LoadPMIService();
	230
	231	dprintf(("DDRAW: LoadPMIService() rc=0x%08X\n",rc));
	232
	233	if (!rc)
	234	bPMILoaded=TRUE;
	235	else
	236	bPMILoaded=FALSE;
	237
	238	SetUpModeTable();
	239	}
	240	//******************************************************************************
	241	//******************************************************************************
	242	OS2IDirectDraw::~OS2IDirectDraw()
	243	{
	244	dprintf(("DDRAW: OS2IDirectDraw::~OS2IDirectDraw()\n"));
[5291]	245	if(hDive)
	246	DiveClose(hDive);
[3345]	247
	248	// Safty call in case the program did set the pal to all black
	249	// so if the destructor gets called we might be able change this back
	250	OS2ResetPhysPalette();
	251
[5291]	252	// FSDDRAW additions
	253	// we need this in Full Screen, but don't do anything in windowed
[3345]	254	// session.
	255	if (bPMILoaded)
	256	{
	257	RestorePM();
	258	FreeModeTable();
	259	}
	260	}
	261	//******************************************************************************
	262	//******************************************************************************
	263	FOURCC OS2IDirectDraw::GetScreenFourCC()
	264	{
	265	return SupportedFourCCs[screenbpp>>3];
	266	}
	267	//******************************************************************************
	268	//******************************************************************************
[5291]	269	HRESULT WIN32API DrawQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
[3345]	270	{
	271	OS2IDirectDraw me = (OS2IDirectDraw )This;
	272
[5291]	273	dprintf(("DDRAW: OS2IDirectDraw::QueryInterface %x %x %x", This, riid, ppvObj));
	274
[3345]	275	*ppvObj = NULL;
	276
	277	if(!IsEqualGUID(riid, CLSID_DirectDraw) &&
	278	!IsEqualGUID(riid, IID_IDirectDraw) &&
	279	!IsEqualGUID(riid, IID_IDirectDraw2) &&
[5291]	280	!IsEqualGUID(riid, IID_IDirectDraw4) &&
	281	!IsEqualGUID(riid, IID_IDirect3D))
	282	// !IsEqualGUID(riid, IID_IUnknown))
[3345]	283	return E_NOINTERFACE;
	284
[5291]	285	// ToDo Better way of returning differnent interfaces for same class
	286	if(IsEqualGUID(riid, IID_IDirect3D))
[3345]	287	{
[5291]	288	me->lpVtbl3D = &me->Vtbl3D;
	289	me->lpVtbl3D2 = me->lpVtbl3D;
	290	me->pdwUnknownData3D = me->pdwUnknownData;
	291	*ppvObj = (LPVOID)&me->lpVtbl3D;
	292	DrawAddRef(This);
	293	return DD_OK;
[3345]	294	}
	295	else
	296	{
[5291]	297	if(IsEqualGUID(riid, IID_IDirectDraw4))
	298	{
	299	dprintf(("DDRAW: IID_IDirectDraw4 Interface\n"));
	300	me->lpVtbl = &me->Vtbl4;
	301	}
	302	else
	303	{
	304	if(IsEqualGUID(riid, IID_IDirectDraw2))
	305	{
	306	dprintf(("DDRAW: IID_IDirectDraw2 Interface\n"));
	307	me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl2;
	308	}
	309	else
	310	{
	311	dprintf(("DDRAW: IID_IDirectDraw Interface\n"));
	312	me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
	313	}
	314	}
[3345]	315	}
[5291]	316	me->lpVtbl2 = me->lpVtbl;
[3345]	317	*ppvObj = This;
	318	DrawAddRef(This);
	319
	320	return(DD_OK);
	321	}
	322	//******************************************************************************
	323	//******************************************************************************
[5291]	324	ULONG WIN32API DrawAddRef(THIS This)
[3345]	325	{
	326	OS2IDirectDraw me = (OS2IDirectDraw )This;
	327
[5291]	328	dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
[3345]	329
	330	return ++me->Referenced;
	331	}
	332	//******************************************************************************
	333	//******************************************************************************
[5291]	334	ULONG WIN32API DrawRelease(THIS This)
[3345]	335	{
	336	OS2IDirectDraw me = (OS2IDirectDraw )This;
	337	ULONG rc;
	338
[5291]	339	dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
	340	dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
[3345]	341
	342	if(me->Referenced)
	343	{
	344
	345	me->Referenced--;
	346	if(me->Referenced == 0)
	347	{
	348	delete(me);
	349	rc = 0;
	350	}
	351	else
	352	rc = me->Referenced;
	353	}
	354	else
	355	rc = 0;
	356
	357	return rc;
	358	}
	359	//******************************************************************************
	360	//******************************************************************************
[5291]	361	HRESULT WIN32API DrawCompact(THIS)
[3345]	362	{
[5291]	363	dprintf(("DDRAW: Compact\n"));
[3345]	364
	365	return(DD_OK);
	366	}
	367	//******************************************************************************
	368	//******************************************************************************
[5291]	369	HRESULT WIN32API DrawCreateClipper(THIS This, DWORD, LPDIRECTDRAWCLIPPER FAR lplpDD, IUnknown FAR )
[3345]	370	{
	371	OS2IDirectDraw me = (OS2IDirectDraw )This;
	372	OS2IDirectDrawClipper *newclip;
	373	HRESULT rc;
	374
	375	newclip = new OS2IDirectDrawClipper(me);
	376
[5291]	377	dprintf(("DDRAW: CreateClipper\n"));
[3345]	378
	379	if(newclip == NULL)
	380	{
	381	rc = DDERR_OUTOFMEMORY;
	382	}
	383	else
	384	{
	385	newclip->Vtbl.AddRef((IDirectDrawClipper *)newclip);
	386	rc = newclip->GetLastError();
	387	if(rc != DD_OK)
	388	{
	389	*lplpDD = NULL;
	390	delete newclip;
	391	}
	392	else
	393	lplpDD = (IDirectDrawClipper )newclip;
	394	}
	395
	396	return(rc);
	397	}
	398	//******************************************************************************
	399	//******************************************************************************
[5291]	400	HRESULT WIN32API DrawCreatePalette(THIS This, DWORD dwFlags,
[3345]	401	LPPALETTEENTRY lpColorTable,
	402	LPDIRECTDRAWPALETTE FAR *lplpDD,
	403	IUnknown FAR *pUnkOuter)
	404	{
	405	OS2IDirectDraw me = (OS2IDirectDraw )This;
	406	OS2IDirectDrawPalette *newpal;
	407	HRESULT rc = DD_OK;
	408	int palsize = 0;
	409
	410	if(dwFlags & DDPCAPS_8BITENTRIES)
	411	{
	412	// We Don't support Indexed palettes...
	413
	414	rc = DDERR_INVALIDPARAMS;
	415	}
	416
	417	if(dwFlags & DDPCAPS_2BIT)
	418	palsize = 4;
	419	if(dwFlags & DDPCAPS_4BIT)
	420	palsize = 16;
	421	if(dwFlags & DDPCAPS_8BIT)
	422	palsize = 256;
	423	if(dwFlags & DDPCAPS_ALLOW256)
	424	palsize = 256;
	425
	426	if(palsize == 0)
	427	rc = DDERR_INVALIDPARAMS;
	428
	429	if(DD_OK == rc)
	430	{
[5291]	431	dprintf(("DDRAW: CreatePalette with %d colors\n", palsize));
[3345]	432
	433	newpal = new OS2IDirectDrawPalette((VOID*)me, palsize, lpColorTable, dwFlags);
	434
	435	if(newpal == NULL)
	436	{
	437	rc = DDERR_OUTOFMEMORY;
	438	}
	439	else
	440	{
	441	newpal->Vtbl.AddRef((IDirectDrawPalette *)newpal);
	442	rc = newpal->GetLastError();
	443
	444	if(DD_OK != rc)
	445	{
	446	*lplpDD = NULL;
	447	delete newpal;
	448	}
	449	else
	450	lplpDD = (IDirectDrawPalette )newpal;
	451	}
	452	}
	453
	454	return(rc);
	455	}
	456	//******************************************************************************
	457	//******************************************************************************
[5291]	458	HRESULT WIN32API DrawCreateSurface(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc,
[3345]	459	LPDIRECTDRAWSURFACE FAR *lplpDD,
	460	IUnknown FAR *pUnkOuter)
	461	{
	462	OS2IDirectDraw me = (OS2IDirectDraw )This;
	463	OS2IDirectDrawSurface *newsurf;
	464	HRESULT rc;
	465
[5291]	466	dprintf(("DDRAW: CreateSurface\n"));
	467	dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
	468	dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
	469	dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
	470	dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
	471	dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
	472	dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
	473	dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
	474	dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
	475	dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
[3345]	476
	477	newsurf = new OS2IDirectDrawSurface(me, (LPDDSURFACEDESC2)lpDDSurfaceDesc);
	478	if(newsurf == NULL)
	479	{
	480	rc = DDERR_OUTOFMEMORY;
	481	}
	482	else
	483	{
	484	newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
	485	rc = newsurf->GetLastError();
	486	if(rc != DD_OK)
	487	{
	488	dprintf(("DDRAW: Error createing Surface\n\n"));
	489	*lplpDD = NULL;
	490	delete newsurf;
	491	}
	492	else
	493	lplpDD = (IDirectDrawSurface )newsurf;
	494
	495	dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
	496	}
	497
	498	return(rc);
	499	}
	500	//******************************************************************************
	501	//******************************************************************************
[5291]	502	HRESULT WIN32API DrawCreateSurface4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
[3345]	503	LPDIRECTDRAWSURFACE4 FAR *lplpDD,
	504	IUnknown FAR *pUnkOuter)
	505	{
	506	OS2IDirectDraw me = (OS2IDirectDraw )This;
	507	OS2IDirectDrawSurface *newsurf;
	508	HRESULT rc;
	509
[5291]	510	dprintf(("DDRAW: CreateSurface4\n"));
	511	dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
	512	dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
	513	dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
	514	dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
	515	dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
	516	dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
	517	dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
	518	dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
[3345]	519
	520	newsurf = new OS2IDirectDrawSurface(me, lpDDSurfaceDesc2);
	521
	522	if(newsurf == NULL)
	523	{
	524	rc = DDERR_OUTOFMEMORY;
	525	}
	526	else
	527	{
	528	newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
	529	rc = newsurf->GetLastError();
	530	if(rc != DD_OK)
	531	{
	532	dprintf(("DDRAW: Error createing Surface\n\n"));
	533	*lplpDD = NULL;
	534
	535	delete newsurf;
	536	}
	537	else
	538	lplpDD = (IDirectDrawSurface4 )newsurf;
	539
	540	dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
	541	}
	542
	543	return(rc);
	544	}
	545	//******************************************************************************
	546	//******************************************************************************
[5291]	547	HRESULT WIN32API DrawDuplicateSurface(THIS, LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * )
[3345]	548	{
[5291]	549	dprintf(("DDRAW: DuplicateSurface NIY\n"));
	550
[3345]	551	return(DD_OK);
	552	}
	553	//******************************************************************************
	554	//******************************************************************************
[5291]	555	HRESULT WIN32API DrawDuplicateSurface4(THIS, LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * )
[3345]	556	{
[5291]	557	dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
[3345]	558
	559	return(DD_OK);
	560	}
	561	//******************************************************************************
	562	//******************************************************************************
[5291]	563	HRESULT WIN32API DrawEnumDisplayModes( THIS This,
[3345]	564	DWORD dwFlags,
	565	LPDDSURFACEDESC lpDDSurfaceDesc,
	566	LPVOID lpContext,
	567	LPDDENUMMODESCALLBACK lpDDEnumModesCallback)
	568	{
	569	int iMode = 0;
	570	DDSURFACEDESC DDSurfAct;
	571	BOOL fCallAgain;
	572	OS2IDirectDraw me = (OS2IDirectDraw )This;
	573
[5291]	574	dprintf(("DDRAW: EnumDisplayModes\n"));
[3345]	575
	576	// Check for Pointer to callback function
	577	if (NULL == lpDDEnumModesCallback)
	578	{
[5291]	579	dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
[3345]	580
	581	return(DDERR_GENERIC);
	582	}
	583
	584
	585	// Setting up the surface
	586	// During enum we report resolution and bitdepth, maybe we should
	587	// also report back : Caps and Pitch
	588	memset(&DDSurfAct,0,sizeof(DDSURFACEDESC));
	589	DDSurfAct.dwSize = sizeof(DDSURFACEDESC);
	590	DDSurfAct.dwFlags = DDSD_HEIGHT \| DDSD_WIDTH \| DDSD_PIXELFORMAT ;
	591	// Only report the bitdepth hope this is ok this way, we must set the BitMask fields
	592
	593	DDSurfAct.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
	594	DDSurfAct.ddpfPixelFormat.dwFlags = DDPF_RGB;
	595	// Check if we use DIVE or Voodoo
	596	if(me->lpVtbl != (IDirectDraw4Vtbl *) &(me->Vtbl3D))
	597	{
	598	// DIVE modes
	599
[5291]	600	dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
[3345]	601
	602	// Enumerate all modes ?
	603	if (NULL==lpDDSurfaceDesc)
	604	{
	605	// Check if we shall report 320x200 mode
	606
[5291]	607	dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
[3345]	608
	609	if(dwFlags && DDEDM_STANDARDVGAMODES)
	610	{
[5291]	611	dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
	612
[3345]	613	DDSurfAct.dwHeight = ModesDive[0].iYRes;
	614	DDSurfAct.dwWidth = ModesDive[0].iXRes;
	615	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
	616	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8 ;
	617	if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
	618	{
[5291]	619	dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
[3345]	620	return (DD_OK);
	621	}
	622	}
	623	// Don't know the flag for Mode X so we skip reporting it
	624
	625	// Now report all our modes
	626	iMode = 2;
	627	fCallAgain = TRUE;
	628	do
	629	{
	630	// if the mode fits in the current resolution report it
	631	// Change this if we support Fullscreen later !!!
	632
	633	if(ModesDive[iMode].iXRes < me->dCaps.ulHorizontalResolution)
	634	{
	635	DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
	636	DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
	637	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
	638	switch(ModesDive[iMode].iBits)
	639	{
	640	case 8:
	641	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
	642	break;
	643	case 16:
	644	// VESA uses 565 encoding in 16 bit modes
	645	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
	646	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
	647	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
	648	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
	649	break;
	650	case 24:
	651	// VESA uses per default RGB4
	652	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
	653	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
	654	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	655	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
	656	break;
	657	default:
	658	break;
	659	}
[5291]	660	dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
	661	DDSurfAct.dwHeight,
	662	DDSurfAct.dwWidth,
	663	DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
[3345]	664	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
[5291]	665	dprintf( ("EnumDisplayModes : Callback returned with %d\n",
	666	fCallAgain));
[3345]	667	}
	668	iMode++;
	669	}
	670	while( (iMode < NUM_MODES_DIVE) &&
	671	(ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
	672	(TRUE==fCallAgain) );
	673	}
	674	else
	675	{
	676	// No, so filter modes with lpDDSurfaceDesc
	677
	678	// Return Error if the program want to use other than the 3 supported values
	679	// for filtering
	680
	681	if (lpDDSurfaceDesc->dwFlags & !(DDSD_WIDTH\|DDSD_HEIGHT\|DDSD_PIXELFORMAT))
	682	return(DDERR_INVALIDPARAMS);
	683
	684	iMode = 0;
	685	if( (dwFlags && DDEDM_STANDARDVGAMODES) &&
	686	(
	687	(((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
	688	(ModesDive[iMode].iXRes==lpDDSurfaceDesc->dwWidth)
	689	)\|\|(!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
	690	(((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
	691	(ModesDive[iMode].iYRes==lpDDSurfaceDesc->dwHeight))\|\|
	692	(!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
	693	(((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
	694	(ModesDive[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))\|\|
	695	(!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
	696	)
	697	)
	698	{
	699	DDSurfAct.dwHeight = ModesDive[0].iYRes;
	700	DDSurfAct.dwWidth = ModesDive[0].iXRes;
	701	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
	702	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
	703	if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
	704	{
	705	return (DD_OK);
	706	}
	707	}
	708	// Don't know the flag for Mode X so we skip reporting it
	709
	710	// Now report all our modes
	711	iMode = 2;
	712	fCallAgain = TRUE;
	713	do
	714	{
	715	// if the mode fits in the current resolution and the filter applies report it
	716	// Change this if we support Fullscreen later !!!
	717	if( (ModesDive[iMode].iXRes < me->dCaps.ulHorizontalResolution)&&
	718	(
	719	(((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
	720	(ModesDive[iMode].iXRes==lpDDSurfaceDesc->dwWidth))\|\|
	721	(!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
	722	(((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
	723	(ModesDive[iMode].iYRes==lpDDSurfaceDesc->dwHeight))\|\|
	724	(!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
	725	(((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
	726	(ModesDive[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))\|\|
	727	(!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
	728	)
	729	)
	730	{
	731	DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
	732	DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
	733	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
	734	switch(ModesDive[iMode].iBits)
	735	{
	736	case 8:
	737	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
	738	break;
	739	case 16:
	740	// VESA uses 565 encoding in 16 bit modes
	741	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
	742	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
	743	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
	744	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
	745	break;
	746	case 24:
	747	// VESA uses per default RGB4
	748	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
	749	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
	750	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	751	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
	752	break;
	753	default:
	754	break;
	755	}
	756
	757	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
	758	}
	759	iMode++;
	760	}
	761	while((ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
	762	(iMode < NUM_MODES_DIVE) && (TRUE==fCallAgain));
	763
	764	}
	765	}
	766	else
	767	{
	768
	769	// VOODOO modes
	770
	771	// Enumerate all modes ?
	772	if (NULL==lpDDSurfaceDesc)
	773	{
	774
	775	// report all our modes
	776	iMode = 0;
	777	fCallAgain = TRUE;
	778	do
	779	{
	780	DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
	781	DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
	782	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
	783
	784	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
	785	iMode++;
	786	}
	787	while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
	788	}
	789	else
	790	{
	791	// No, so filter modes with lpDDSurfaceDesc
	792
	793	// Return Error if the program want to use other than the 3 supported values
	794	// for filtering
	795
	796	if (lpDDSurfaceDesc->dwFlags & !(DDSD_WIDTH\|DDSD_HEIGHT\|DDSD_PIXELFORMAT))
	797	{
	798	return(DDERR_INVALIDPARAMS);
	799	}
	800
	801	iMode = 2;
	802	fCallAgain = TRUE;
	803	// All reported mode are 16bit
	804	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
	805	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
	806	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
	807	do
	808	{
	809	// if the mode fits the filter applies report it
	810	if(
	811	(((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
	812	(ModesVoodoo[iMode].iXRes==lpDDSurfaceDesc->dwWidth))\|\|
	813	(!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
	814	(((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
	815	(ModesVoodoo[iMode].iYRes==lpDDSurfaceDesc->dwHeight))\|\|
	816	(!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
	817	(((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
	818	(ModesVoodoo[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))\|\|
	819	(!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
	820	)
	821	{
	822	DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
	823	DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
	824	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
	825
	826	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
	827	}
	828	iMode++;
	829	}
	830	while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
	831
	832	}
	833
	834	}
	835
	836
	837
	838	return(DD_OK);
	839	}
	840	//******************************************************************************
	841	//******************************************************************************
[5291]	842	HRESULT WIN32API DrawEnumDisplayModes4(THIS This, DWORD dwFlags, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
[3345]	843	LPVOID lpContext, LPDDENUMMODESCALLBACK2 lpDDEnumModesCallback2)
	844	{
	845	int iMode = 0;
[5291]	846	#if 0
[3345]	847	DDSURFACEDESC DDSurfAct;
	848	BOOL fCallAgain;
[5291]	849	#endif
[3345]	850	OS2IDirectDraw me = (OS2IDirectDraw )This;
	851
[5291]	852	dprintf(("DDRAW: EnumDisplayModes4 NIY\n"));
[3345]	853	return(DD_OK);
	854	}
[5291]	855
[3345]	856	//******************************************************************************
	857	//******************************************************************************
[5291]	858	HRESULT WIN32API DrawEnumSurfaces(THIS, DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK )
[3345]	859	{
[5291]	860	dprintf(("DDRAW: EnumSurfaces NIY\n"));
[3345]	861
	862	return(DD_OK);
	863	}
[5291]	864
[3345]	865	//******************************************************************************
	866	//******************************************************************************
[5291]	867	HRESULT WIN32API DrawEnumSurfaces4(THIS, DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 )
[3345]	868	{
[5291]	869	dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
[3345]	870
	871	return(DD_OK);
	872	}
[5291]	873
[3345]	874	//******************************************************************************
	875	//******************************************************************************
[5291]	876	HRESULT WIN32API DrawFlipToGDISurface(THIS)
[3345]	877	{
[5291]	878	dprintf(("DDRAW: FlipToGDISurface NIY\n"));
[3345]	879
	880	return(DD_OK);
	881	}
[5291]	882
[3345]	883	//******************************************************************************
	884	//******************************************************************************
[5291]	885	HRESULT WIN32API DrawGetCaps(THIS This, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
[3345]	886	{
[5291]	887	DWORD dwSize;
	888	OS2IDirectDraw me = (OS2IDirectDraw )This;
[3345]	889
[5291]	890	dprintf(("DDRAW: DDGetCaps %x %x %x", This, lpDDDriverCaps, lpDDHELCaps));
[3345]	891
	892	if( (NULL==lpDDDriverCaps) && (NULL==lpDDHELCaps) )
	893	return(DDERR_INVALIDPARAMS);
	894
	895	if(NULL!=lpDDDriverCaps)
	896	{
	897	// Caller want Driver Caps
	898
	899	dprintf(("DDRAW: Driver\n"));
	900
	901	if( (sizeof(DDCAPS)!=lpDDDriverCaps->dwSize) &&
	902	(sizeof(DDCAPS_DX5)!=lpDDDriverCaps->dwSize) &&
	903	(sizeof(DDCAPS_DX3)!=lpDDDriverCaps->dwSize) )
	904	{
	905	dprintf( ("Size %d Not supported ",
	906	lpDDDriverCaps->dwSize));
	907	return(DDERR_INVALIDPARAMS);
	908	}
	909	// Clear structure so we only have to set the supported flags
	910
	911	dwSize = lpDDDriverCaps->dwSize;
	912	memset( lpDDDriverCaps,
	913	0,
	914	lpDDDriverCaps->dwSize);
	915
	916
	917	// Reset the size
	918	lpDDDriverCaps->dwSize = dwSize;
	919
	920	// Now report the CAPs back which we support
	921	lpDDDriverCaps->dwCaps = DDCAPS_BLT \| // We do blitting
[5291]	922	DDCAPS_BLTSTRETCH \|
[3345]	923	DDCAPS_BLTCOLORFILL \| // We do colorfills
[5291]	924	DDCAPS_BLTDEPTHFILL \|
[3345]	925	DDCAPS_COLORKEY \| // We support Colorkeying
	926	DDCAPS_COLORKEYHWASSIST \| // But we (may) use the CPU
	927	DDCAPS_GDI \| // Maybe check if we are on Voodoo ?
[5291]	928	DDCAPS_PALETTEVSYNC \| // Got VSync
	929	// DDCAPS_READSCANLINE \|
	930	DDCAPS_BLTFOURCC;
[3345]	931
	932	lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED \| // Who cares so say yes
[5291]	933	DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
[3345]	934	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
	935	DDCAPS2_NONLOCALVIDMEM \| // All surfaces are in memory
	936	DDCAPS2_WIDESURFACES; // Any size you want!
	937
	938	lpDDDriverCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	939
[5291]	940	lpDDDriverCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN \|
	941	DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
[3345]	942	// Maybe later add stretching support?
	943
	944	lpDDDriverCaps->dwPalCaps = DDPCAPS_8BIT \| // Only 8 Bits pals
	945	DDPCAPS_ALLOW256 \| // But all 256 colors
	946	DDPCAPS_VSYNC \| // Vsync yet
	947	DDPCAPS_PRIMARYSURFACE; //
[5291]	948	lpDDDriverCaps->dwVidMemTotal = me->dCaps.ulApertureSize; // total video memory
	949	lpDDDriverCaps->dwVidMemFree = me->dCaps.ulApertureSize; // total free video memory
	950	lpDDDriverCaps->dwNumFourCCCodes = MAX_FOURCC_CODES; // number of supported FOURCC codes
[3345]	951	/*
	952	ToDo: must finde out ow the array is used for this
	953	lpDDDriverCaps->dwRops[DD_ROP_SPACE] = SRCCOPY \|
	954	BLACKNESS \|
	955	WHITENESS; // Raster OPs implemented
	956	*/
	957	lpDDDriverCaps->dwSVBCaps = DDCAPS_BLT \| // We do blitting
	958	DDCAPS_BLTCOLORFILL \| // We do colorfills
	959	DDCAPS_COLORKEY \| // We support Colorkeying
	960	DDCAPS_COLORKEYHWASSIST;
	961	lpDDDriverCaps->dwSVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	962	lpDDDriverCaps->dwSVBFXCaps = DDCAPS_BLT \| // We do blitting
	963	DDCAPS_BLTCOLORFILL \| // We do colorfills
	964	DDCAPS_COLORKEY \| // We support Colorkeying
	965	DDCAPS_COLORKEYHWASSIST;
	966	/*
	967	ToDo: must finde out ow the array is used for this
	968	lpDDDriverCaps->dwSVBRops[DD_ROP_SPACE] = SRCCOPY \|
	969	BLACKNESS \|
	970	WHITENESS; // Raster OPs implemented
	971	*/
	972	lpDDDriverCaps->dwVSBCaps = DDCAPS_BLT \| // We do blitting
	973	DDCAPS_BLTCOLORFILL \| // We do colorfills
	974	DDCAPS_COLORKEY \| // We support Colorkeying
	975	DDCAPS_COLORKEYHWASSIST;
	976	lpDDDriverCaps->dwVSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	977	lpDDDriverCaps->dwVSBFXCaps = DDCAPS_BLT \| // We do blitting
	978	DDCAPS_BLTCOLORFILL \| // We do colorfills
	979	DDCAPS_COLORKEY \| // We support Colorkeying
	980	DDCAPS_COLORKEYHWASSIST;
	981	/*
	982	ToDo: must finde out ow the array is used for this
	983	lpDDDriverCaps->dwVSBRops[DD_ROP_SPACE] = SRCCOPY \|
	984	BLACKNESS \|
	985	WHITENESS; // Raster OPs implemented
	986	*/
	987	lpDDDriverCaps->dwSSBCaps = DDCAPS_BLT \| // We do blitting
	988	DDCAPS_BLTCOLORFILL \| // We do colorfills
	989	DDCAPS_COLORKEY \| // We support Colorkeying
	990	DDCAPS_COLORKEYHWASSIST;
	991	lpDDDriverCaps->dwSSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	992	lpDDDriverCaps->dwSSBFXCaps = DDCAPS_BLT \| // We do blitting
	993	DDCAPS_BLTCOLORFILL \| // We do colorfills
	994	DDCAPS_COLORKEY \| // We support Colorkeying
	995	DDCAPS_COLORKEYHWASSIST;
	996	/*
	997	ToDo: must finde out ow the array is used for this
	998	lpDDDriverCaps->dwSSBRops[SRCCOPY] = 1;
	999	lpDDDriverCaps->dwSSBRops[BLACKNESS] = 1;
	1000	lpDDDriverCaps->dwSSBRops[WHITENESS] = 1; // Raster OPs implemented
	1001	*/
	1002	// These are ony in >DX5
	1003	if(dwSize>sizeof(DDCAPS_DX3))
	1004	{
	1005	lpDDDriverCaps->dwSVBCaps2 = //DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
	1006	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
	1007	DDCAPS2_WIDESURFACES; // Any size you want!
	1008	lpDDDriverCaps->dwNLVBCaps = DDCAPS_BLT \| // We do blitting
	1009	DDCAPS_BLTCOLORFILL \| // We do colorfills
	1010	DDCAPS_COLORKEY \| // We support Colorkeying
	1011	DDCAPS_COLORKEYHWASSIST;
	1012	lpDDDriverCaps->dwNLVBCaps2 = //DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
	1013	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
	1014	DDCAPS2_WIDESURFACES; // Any size you want!
	1015	lpDDDriverCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	1016	lpDDDriverCaps->dwNLVBFXCaps = DDCAPS_BLT \| // We do blitting
	1017	DDCAPS_BLTCOLORFILL \| // We do colorfills
	1018	DDCAPS_COLORKEY \| // We support Colorkeying
	1019	DDCAPS_COLORKEYHWASSIST;
	1020	lpDDDriverCaps->dwNLVBRops[DD_ROP_SPACE];// ToDo: Again the array ...
	1021
	1022	// General Surface caps only in DX6
	1023	if(dwSize>sizeof(DDCAPS_DX5))
	1024	{
	1025	lpDDDriverCaps->ddsCaps.dwCaps = DDSCAPS_ALPHA \| DDSCAPS_BACKBUFFER \|
	1026	DDSCAPS_COMPLEX \| DDSCAPS_FLIP \|
	1027	DDSCAPS_FRONTBUFFER \| DDSCAPS_LOCALVIDMEM \|
	1028	DDSCAPS_NONLOCALVIDMEM \| DDSCAPS_OFFSCREENPLAIN \|
	1029	// DDSCAPS_OVERLAY \|
	1030	DDSCAPS_PALETTE \| DDSCAPS_PRIMARYSURFACE \|
	1031	DDSCAPS_SYSTEMMEMORY \|DDSCAPS_VIDEOMEMORY \|
	1032	DDSCAPS_VISIBLE;
	1033
	1034	#ifdef USE_OPENGL
	1035	lpDDDriverCaps->dwCaps \|= DDCAPS_3D \| DDCAPS_ZBLTS;
	1036	// ToDO find and put the value for DDCAPS2_NO2DDURING3DSCENE in ddraw.h
	1037	// lpDDDriverCaps->dwCaps2 \|= DDCAPS2_NO2DDURING3DSCENE;
	1038	lpDDDriverCaps->ddsCaps.dwCaps \|= DDSCAPS_3DDEVICE \| DDSCAPS_MIPMAP \|
	1039	DDSCAPS_TEXTURE \| DDSCAPS_ZBUFFER;
	1040	#endif
	1041	}
	1042	}
	1043
	1044
	1045	}
	1046
	1047	if(NULL!=lpDDHELCaps)
	1048	{
	1049	// Caller wants HEL Caps
[5291]	1050	dprintf(("DDRAW: CHEL\n"));
[3345]	1051
[5291]	1052	//SvL: PowerDVD uses size 316
	1053	if( (sizeof(DDCAPS) != lpDDHELCaps->dwSize) &&
	1054	(sizeof(DDCAPS_DX5) != lpDDHELCaps->dwSize) &&
	1055	(sizeof(DDCAPS_DX3) != lpDDHELCaps->dwSize) )
[3345]	1056	{
[5291]	1057	dprintf( ("Size %d Not supported ",
	1058	lpDDHELCaps->dwSize));
[3345]	1059	return(DDERR_INVALIDPARAMS);
	1060	}
	1061	// Clear structure so we only have to set the supported flags
	1062
[5291]	1063	dwSize = lpDDHELCaps->dwSize;
	1064	memset( lpDDHELCaps,
	1065	0,
	1066	lpDDHELCaps->dwSize);
[3345]	1067
	1068	// Reset the size
[5291]	1069	lpDDHELCaps->dwSize = dwSize;
[3345]	1070
	1071	// Now report the CAPs back which we support
	1072	lpDDHELCaps->dwCaps = DDCAPS_BLT \| // We do blitting
[5291]	1073	DDCAPS_BLTCOLORFILL \| // We do colorfills
	1074	DDCAPS_COLORKEY \| // We support Colorkeying
	1075	//SvL: This is the emulation layer; no hw support here
	1076	// DDCAPS_COLORKEYHWASSIST \| // But we (may) use the CPU
	1077	DDCAPS_GDI \| // Maybe check if we are on Voodoo ?
	1078	DDCAPS_PALETTEVSYNC \| // Got VSync
	1079	DDCAPS_BLTFOURCC;
[3345]	1080
	1081	lpDDHELCaps->dwCaps2 = DDCAPS2_CERTIFIED \| // Who cares so say yes
[5291]	1082	DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
	1083	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
	1084	DDCAPS2_NONLOCALVIDMEM \| // All surfaces are in memory
	1085	DDCAPS2_WIDESURFACES; // Any size you want!
[3345]	1086
	1087	lpDDHELCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	1088
[5291]	1089	lpDDHELCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN \|
	1090	DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
[3345]	1091	// Maybe later add stretching support?
	1092
	1093	lpDDHELCaps->dwPalCaps = DDPCAPS_8BIT \| // Only 8 Bits pals
[5291]	1094	DDPCAPS_ALLOW256 \| // But all 256 colors
	1095	DDPCAPS_VSYNC \| // Vsync yet
	1096	DDPCAPS_PRIMARYSURFACE;
	1097
	1098	//Video memory for emulation layer must be 0 (verified in NT)
	1099	lpDDHELCaps->dwVidMemTotal = 0; // total video memory
	1100	lpDDHELCaps->dwVidMemFree = 0; // total free video memory
	1101
	1102	lpDDHELCaps->dwNumFourCCCodes = MAX_FOURCC_CODES; // number of supported FOURCC codes
[3345]	1103	lpDDHELCaps->dwRops[DD_ROP_SPACE]; // supported raster ops
	1104	lpDDHELCaps->dwSVBCaps = DDCAPS_BLT \| // We do blitting
	1105	DDCAPS_BLTCOLORFILL \| // We do colorfills
	1106	DDCAPS_COLORKEY \| // We support Colorkeying
	1107	DDCAPS_COLORKEYHWASSIST;
	1108	lpDDHELCaps->dwSVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	1109	lpDDHELCaps->dwSVBFXCaps; // .
	1110	lpDDHELCaps->dwSVBRops[DD_ROP_SPACE]; // .
	1111	lpDDHELCaps->dwVSBCaps = DDCAPS_BLT \| // We do blitting
	1112	DDCAPS_BLTCOLORFILL \| // We do colorfills
	1113	DDCAPS_COLORKEY \| // We support Colorkeying
	1114	DDCAPS_COLORKEYHWASSIST;
	1115	lpDDHELCaps->dwVSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	1116	lpDDHELCaps->dwVSBFXCaps; // .
	1117	lpDDHELCaps->dwVSBRops[DD_ROP_SPACE]; // .
	1118	lpDDHELCaps->dwSSBCaps = DDCAPS_BLT \| // We do blitting
	1119	DDCAPS_BLTCOLORFILL \| // We do colorfills
	1120	DDCAPS_COLORKEY \| // We support Colorkeying
	1121	DDCAPS_COLORKEYHWASSIST;
	1122	lpDDHELCaps->dwSSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	1123	lpDDHELCaps->dwSSBFXCaps; // .
	1124	lpDDHELCaps->dwSSBRops[DD_ROP_SPACE]; // .
[5291]	1125	// These are ony in >DX5
	1126	if(dwSize>sizeof(DDCAPS_DX3))
	1127	{
	1128	lpDDHELCaps->dwSVBCaps2 = DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
	1129	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
	1130	DDCAPS2_WIDESURFACES; // Any size you want!
	1131	lpDDHELCaps->dwNLVBCaps = DDCAPS_BLT \| // We do blitting
	1132	DDCAPS_BLTCOLORFILL \| // We do colorfills
	1133	DDCAPS_COLORKEY \| // We support Colorkeying
	1134	DDCAPS_COLORKEYHWASSIST;
	1135	lpDDHELCaps->dwNLVBCaps2 = DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
	1136	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
	1137	DDCAPS2_WIDESURFACES; // Any size you want!
	1138	lpDDHELCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
	1139	lpDDHELCaps->dwNLVBFXCaps; // .
	1140	lpDDHELCaps->dwNLVBRops[DD_ROP_SPACE];// .
	1141	}
[3345]	1142
	1143	}
	1144
	1145	return(DD_OK);
	1146	}
	1147	//******************************************************************************
	1148	//******************************************************************************
[5291]	1149	HRESULT WIN32API DrawGetDisplayMode(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc)
[3345]	1150	{
	1151	OS2IDirectDraw me = (OS2IDirectDraw )This;
	1152
[5291]	1153	dprintf(("DDRAW: GetDisplayMode %x %x", This, lpDDSurfaceDesc));
	1154
[3345]	1155	// Check Parameter
	1156	if(NULL==lpDDSurfaceDesc)
	1157	return(DDERR_INVALIDPARAMS);
	1158
	1159	if(sizeof(DDSURFACEDESC)!=lpDDSurfaceDesc->dwSize)
	1160	return(DDERR_INVALIDPARAMS);
	1161
	1162	// We report back the DIVE caps. maybe we should set up a local DDSURFACEDESC
	1163	// for the object so we can change the values when we switch modes (or say so)
	1164	// as a program may use this function to check the values after a mode change
	1165	// An other reason to to so is Voodoo supports maybe more functions
	1166
	1167	// Tell what we report
	1168	lpDDSurfaceDesc->dwFlags = DDSD_HEIGHT \| DDSD_WIDTH \| DDSD_PIXELFORMAT;
	1169	lpDDSurfaceDesc->dwHeight = me->dCaps.ulHorizontalResolution;
	1170	lpDDSurfaceDesc->dwWidth = me->dCaps.ulVerticalResolution;
	1171	// Set the PixelFormat
	1172	lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
	1173
	1174	lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC = me->dCaps.fccColorEncoding;
	1175	lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = me->dCaps.ulDepth;
	1176	lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask = 0; // No Alpha support
	1177	switch(me->dCaps.ulDepth)
	1178	{
	1179	case 4:
	1180	// Assume that no one will run OS/2 PM with less then 16 colors and try
	1181	// to start a DirectX program ;)
	1182	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED4;
	1183	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0;
	1184	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0;
	1185	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0;
	1186	break;
	1187	case 8:
	1188	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED8 \|
	1189	DDPF_FOURCC;
	1190	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0;
	1191	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0;
	1192	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0;
	1193	break;
	1194	case 15:
	1195	case 16:
	1196	lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = 16; // No sure about 15Bit modes
	1197	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
	1198	if (FOURCC_R555 == me->dCaps.fccColorEncoding)
	1199	{
	1200	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00007C00;
	1201	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000003E0;
	1202	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
	1203	}
	1204	else
	1205	{
	1206	if(FOURCC_R565 == me->dCaps.fccColorEncoding)
	1207	{
	1208	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
	1209	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000007E0;
	1210	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
	1211	}
	1212	else
	1213	{
	1214	// R664
	1215	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
	1216	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000003F0;
	1217	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000000F;
	1218	}
	1219	}
	1220	break;
	1221	case 24:
	1222	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
	1223	if(FOURCC_RGB3 == me->dCaps.fccColorEncoding)
	1224	{
	1225	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
	1226	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1227	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
	1228	}
	1229	else
	1230	{
	1231	// BGR3
	1232	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x000000FF;
	1233	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1234	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
	1235	}
	1236	break;
	1237	case 32:
	1238	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
	1239	if(FOURCC_RGB4 == me->dCaps.fccColorEncoding)
	1240	{
	1241	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
	1242	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1243	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
	1244	}
	1245	else
	1246	{
	1247	// BGR4
	1248	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x000000FF;
	1249	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1250	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
	1251	}
	1252	break;
	1253	default:
[5291]	1254	dprintf(("DDRAW: Unsupported mode\n"));
[3345]	1255	return(DDERR_UNSUPPORTEDMODE);
	1256	}
	1257
	1258	return(DD_OK);
	1259	}
	1260	//******************************************************************************
	1261	//******************************************************************************
[5291]	1262	HRESULT WIN32API DrawGetDisplayMode4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2)
[3345]	1263	{
	1264	OS2IDirectDraw me = (OS2IDirectDraw )This;
	1265
[5291]	1266	dprintf(("DDRAW: GetDisplayMode4 %x %x", This, lpDDSurfaceDesc2));
	1267
[3345]	1268	// Check Parameter
	1269	if(NULL==lpDDSurfaceDesc2)
	1270	return(DDERR_INVALIDPARAMS);
	1271
	1272	if(sizeof(DDSURFACEDESC)!=lpDDSurfaceDesc2->dwSize)
	1273	return(DDERR_INVALIDPARAMS);
	1274
	1275	// We report back the DIVE caps. maybe we should set up a local DDSURFACEDESC
	1276	// for the object so we can change the values when we switch modes (or say so)
	1277	// as a program may use this function to check the values after a mode change
	1278	// An other reason to to so is Voodoo supports maybe more functions
	1279
	1280	// Tell what we report
	1281	lpDDSurfaceDesc2->dwFlags = DDSD_HEIGHT \| DDSD_WIDTH \| DDSD_PIXELFORMAT;
	1282	lpDDSurfaceDesc2->dwHeight = me->dCaps.ulHorizontalResolution;
	1283	lpDDSurfaceDesc2->dwWidth = me->dCaps.ulVerticalResolution;
	1284	// Set the PixelFormat
	1285	lpDDSurfaceDesc2->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
	1286
	1287	lpDDSurfaceDesc2->ddpfPixelFormat.dwFourCC = me->dCaps.fccColorEncoding;
	1288	lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount = me->dCaps.ulDepth;
	1289	lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBAlphaBitMask = 0; // No Alpha support
	1290	switch(me->dCaps.ulDepth)
	1291	{
	1292	case 4:
	1293	// Assume that no one will run OS/2 PM with less then 16 colors and try
	1294	// to start a DirectX program ;)
	1295	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED4;
	1296	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0;
	1297	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0;
	1298	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0;
	1299	break;
	1300	case 8:
	1301	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED8 \|
	1302	DDPF_FOURCC;
	1303	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0;
	1304	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0;
	1305	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0;
	1306	break;
	1307	case 15:
	1308	case 16:
	1309	lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount = 16; // No sure about 15Bit modes
	1310	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
	1311	if (FOURCC_R555 == me->dCaps.ulDepth)
	1312	{
	1313	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00007C00;
	1314	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000003E0;
	1315	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000001F;
	1316	}
	1317	else
	1318	{
	1319	if(FOURCC_R565 == me->dCaps.fccColorEncoding)
	1320	{
	1321	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x0000F800;
	1322	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000007E0;
	1323	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000001F;
	1324	}
	1325	else
	1326	{
	1327	// R664
	1328	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x0000F800;
	1329	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000003F0;
	1330	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000000F;
	1331	}
	1332	}
	1333	break;
	1334	case 24:
	1335	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
	1336	if(FOURCC_RGB3 == me->dCaps.fccColorEncoding)
	1337	{
	1338	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
	1339	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1340	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x000000FF;
	1341	}
	1342	else
	1343	{
	1344	// BGR3
	1345	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x000000FF;
	1346	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1347	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
	1348	}
	1349	break;
	1350	case 32:
	1351	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
	1352	if(FOURCC_RGB4 == me->dCaps.fccColorEncoding)
	1353	{
	1354	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
	1355	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1356	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x000000FF;
	1357	}
	1358	else
	1359	{
	1360	// BGR4
	1361	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x000000FF;
	1362	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
	1363	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
	1364	}
	1365	break;
	1366	default:
[5291]	1367	dprintf(("DDRAW: Unsupported mode\n"));
[3345]	1368	return(DDERR_UNSUPPORTEDMODE);
	1369	}
	1370
	1371	return(DD_OK);
	1372	}
	1373	//******************************************************************************
	1374	//******************************************************************************
[5291]	1375	HRESULT WIN32API DrawGetFourCCCodes(THIS This, LPDWORD lpNumCodes, LPDWORD lpCodes)
[3345]	1376	{
[5291]	1377	// DWORD dwFCC[MAX_FOURCC_CODES] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_YUY2};
	1378	DWORD dwFCC[MAX_FOURCC_CODES] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3};
[3345]	1379
[5291]	1380	dprintf(("DDRAW: GetFourCCCodes %x %x %x", This, lpNumCodes, lpCodes));
	1381
[3345]	1382	if(NULL==lpNumCodes)
	1383	return(DDERR_INVALIDPARAMS);
	1384
	1385	if(NULL==lpCodes)
	1386	{
[5291]	1387	*lpNumCodes = MAX_FOURCC_CODES; // LUT8, R565, RGB3 are the FourCC we support for now
[3345]	1388	}
	1389	else
	1390	{
[5291]	1391	for(int i=0;(i<MAX_FOURCC_CODES)&&(i<*lpNumCodes);i++)
[3345]	1392	{
	1393	*lpCodes = dwFCC[i];
[5291]	1394	lpCodes++;
[3345]	1395	}
[5291]	1396	*lpNumCodes = MAX_FOURCC_CODES;
[3345]	1397	}
	1398	return(DD_OK);
	1399	}
	1400	//******************************************************************************
	1401	//******************************************************************************
[5291]	1402	HRESULT WIN32API DrawGetGDISurface(THIS, LPDIRECTDRAWSURFACE FAR *)
[3345]	1403	{
[5291]	1404	dprintf(("DDRAW: GetGDISurface NYI\n"));
[3345]	1405
	1406	return(DD_OK);
	1407	}
	1408	//******************************************************************************
	1409	//******************************************************************************
[5291]	1410	HRESULT WIN32API DrawGetGDISurface4(THIS, LPDIRECTDRAWSURFACE4 FAR *)
[3345]	1411	{
[5291]	1412	dprintf(("DDRAW: GetGDISurface NYI\n"));
[3345]	1413
	1414	return(DD_OK);
	1415	}
	1416	//******************************************************************************
	1417	//******************************************************************************
[5291]	1418	HRESULT WIN32API DrawGetMonitorFrequency(THIS This, LPDWORD lpdwFreq)
[3345]	1419	{
	1420	ULONG ulTime1, ulTime2;
	1421	DWORD dwFlags = DDWAITVB_BLOCKBEGIN;
[5291]	1422	dprintf(("DDRAW: GetMonitorFrequency\n"));
[3345]	1423	if(NULL==lpdwFreq)
	1424	return(DDERR_INVALIDPARAMS);
	1425
	1426
	1427
	1428	if(DD_OK==DrawWaitForVerticalBlank(This, dwFlags, 0))
	1429	{
	1430	ulTime1 = GetTickCount();
	1431	// Timer has an accuracy of 4 ms so call it al least 4 times
	1432	DrawWaitForVerticalBlank(This, dwFlags, 0);
	1433	DrawWaitForVerticalBlank(This, dwFlags, 0);
	1434	DrawWaitForVerticalBlank(This, dwFlags, 0);
	1435	DrawWaitForVerticalBlank(This, dwFlags, 0);
	1436	ulTime2 = GetTickCount();
	1437	ulTime2 -= ulTime1;
	1438	if(ulTime2) // paranoid check to avoid DIV0
	1439	*lpdwFreq = 4000 / ulTime2;
	1440	else
	1441	*lpdwFreq = 70;
	1442	}
	1443	else
	1444	{
	1445	// Assume 70 Hz maybe better return DDERR_UNSUPPORTED if this function isn't mandatory
	1446	*lpdwFreq = 70;
	1447	}
	1448
	1449
	1450
	1451	return(DD_OK);
	1452	}
	1453	//******************************************************************************
	1454	//******************************************************************************
[5291]	1455	HRESULT WIN32API DrawGetScanLine(THIS, LPDWORD lpdwLine)
[3345]	1456	{
[5291]	1457	// BOOL bVertBlank;
	1458	dprintf(("DDRAW: GetScanLine\n"));
[3345]	1459	// ToDO find a way to get this position, so for now simply return DDERR_UNSUPPORTED
	1460	// as we indicated in DDCAPS we don't support this.
	1461
	1462	return(DDERR_UNSUPPORTED);
	1463
	1464	//the following code could be used if we implement this
	1465	/*
	1466	if(NULL==lpdwLine)
	1467	return(DDERR_INVALIDPARAMS);
	1468	DrawGetVertcalBlackStatus(This,&bVertBlank);
	1469	if(bVertBlank)
	1470	return (DDERR_VERTICALBLANKINPROGRESS);
	1471	*lpdwLine = GetLine(); // GetLine would be the function which gets us the line
	1472	return(DD_OK);
	1473	*/
	1474	}
	1475	//******************************************************************************
	1476	//******************************************************************************
[5291]	1477	HRESULT WIN32API DrawGetVerticalBlankStatus(THIS , LPBOOL lpbIsInVB)
[3345]	1478	{
[5291]	1479	// int rc;
	1480	dprintf(("DDRAW: GetVerticalBlankStatus\n"));
[3345]	1481	if(NULL==lpbIsInVB)
	1482	return(DDERR_INVALIDPARAMS);
	1483
[5291]	1484	#if 0
[3345]	1485	rc = io_init1();
	1486
	1487
	1488	if(0==rc) // try to get IOPL for the thread
	1489	{
	1490	*lpbIsInVB = (c_inb1(0x3da)&0x08)!=0;
	1491
	1492	io_exit1(); // reset IOPL
	1493
	1494	return(DD_OK);
	1495	}
[5291]	1496	#else
	1497	lpbIsInVB = ! (lpbIsInVB);
	1498	#endif
[3345]	1499	return(DDERR_UNSUPPORTED);
	1500	}
	1501	//******************************************************************************
	1502	//******************************************************************************
[5291]	1503	HRESULT WIN32API DrawInitialize(THIS, GUID FAR *)
[3345]	1504	{
[5291]	1505	dprintf(("DDRAW: Initialize\n"));
[3345]	1506
	1507	return(DD_OK);
	1508	}
	1509	//******************************************************************************
	1510	//******************************************************************************
[5291]	1511	HRESULT WIN32API DrawRestoreDisplayMode(THIS This)
[3345]	1512	{
	1513	OS2IDirectDraw me = (OS2IDirectDraw )This;
	1514
[5291]	1515	dprintf(("DDRAW: RestoreDisplayMode"));
	1516
	1517	// FSDDRAW additions
	1518	ULONG ulModeInd;
	1519	/* restore previous screen mode */
[3345]	1520	if ((me->bPMILoaded) && (me->bInFullScreen))
	1521	{
	1522	SetSVGAMode(me->oldwidth, me->oldheight, me->oldbpp, 0xFF, &ulModeInd, NULL);
	1523	RestorePM();
	1524	/* restore DIVE caps entries */
	1525	me->dCaps.ulScanLineBytes = me->oldscanlines;
	1526	me->dCaps.ulHorizontalResolution = me->oldwidth;
	1527	me->dCaps.ulVerticalResolution = me->oldheight;
	1528	me->dCaps.ulDepth = me->oldbpp;
	1529	}
[5291]	1530
[3345]	1531	return(DD_OK);
	1532	}
	1533	//******************************************************************************
	1534	//******************************************************************************
[5291]	1535	HRESULT WIN32API DrawSetCooperativeLevel(THIS This, HWND hwndClient, DWORD dwFlags)
[3345]	1536	{
	1537	OS2IDirectDraw me = (OS2IDirectDraw )This;
	1538
[5291]	1539	dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
[3345]	1540	me->dwCoopMode = dwFlags;
	1541	if(!(DDSCL_NORMAL & dwFlags))
	1542	{
	1543	// client window req. for all none DDSCL_NORMAL modes
	1544	if(NULL==hwndClient)
	1545	return(DDERR_INVALIDPARAMS);
	1546	}
	1547	me->hwndClient = hwndClient;
	1548	#if 0
	1549	OS2DDSubclassWindow(hwndClient);
	1550	#endif
	1551	return(DD_OK);
	1552	}
	1553	//******************************************************************************
	1554	//Backwards compatibility, what's that??
	1555	//******************************************************************************
[5291]	1556	HRESULT WIN32API DrawSetDisplayMode2(THIS This, DWORD dwWidth, DWORD dwHeight,
[3345]	1557	DWORD dwBPP, DWORD dwRefreshRate,
	1558	DWORD dwFlags)
	1559	{
	1560	ULONG rc;
	1561	OS2IDirectDraw me = (OS2IDirectDraw )This;
	1562	SETUP_BLITTER sBlt;
	1563
[5291]	1564	dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
[3345]	1565
	1566	me->screenwidth = dwWidth;
	1567	me->screenheight = dwHeight;
	1568	me->screenbpp = dwBPP;
	1569
	1570	if(me->dwCoopMode & DDSCL_FULLSCREEN)
	1571	{
[5291]	1572	// FSDDRAW additions
	1573	ULONG ulModeInd;
	1574
	1575	SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
	1576	SetCursorPos(dwWidth / 2, dwHeight / 2);
	1577
	1578	if ((me->bPMILoaded) && (ModeInSVGAModeTable(dwWidth,dwHeight,dwBPP)))
	1579	{
	1580	KillPM();
	1581
	1582	rc=SetSVGAMode(dwWidth, dwHeight, dwBPP, 0xFF, &ulModeInd, NULL);
	1583
	1584	if (!rc) // When mode switched successfully
	1585	{
	1586	/* save old screen values */
	1587	me->bInFullScreen=TRUE;
	1588	me->oldwidth = me->dCaps.ulHorizontalResolution;
	1589	me->oldheight = me->dCaps.ulVerticalResolution;
	1590	me->oldscanlines = me->dCaps.ulScanLineBytes;
	1591	me->oldbpp = me->dCaps.ulDepth;
	1592
	1593	/* now 'fix' some DIVE caps entries */
	1594	me->dCaps.ulScanLineBytes = dwWidth * (dwBPP >> 3); /* FIX: use real value */
	1595	me->dCaps.ulHorizontalResolution = dwWidth;
	1596	me->dCaps.ulVerticalResolution = dwHeight;
	1597	me->dCaps.ulDepth = dwBPP;
	1598	}
	1599	else
	1600	// Display must be return to PM Session
	1601	RestorePM();
	1602	}
[3345]	1603	}
	1604
	1605	memset(&sBlt,0,sizeof(sBlt));
	1606	sBlt.ulStructLen = sizeof(sBlt);
	1607	sBlt.fccSrcColorFormat = FOURCC_SCRN;
	1608	sBlt.ulSrcWidth = dwWidth;
	1609	sBlt.ulSrcHeight = dwHeight;
	1610	sBlt.ulSrcPosX = 0;
	1611	sBlt.ulSrcPosY = 0;
	1612	sBlt.fccDstColorFormat = FOURCC_SCRN;
	1613	sBlt.ulDstWidth = dwWidth;
	1614	sBlt.ulDstHeight = dwHeight;
	1615	sBlt.lDstPosX = 0;
	1616	sBlt.lDstPosY = 0;
	1617	sBlt.lScreenPosX = 0;
	1618	sBlt.lScreenPosY = me->dCaps.ulVerticalResolution-dwHeight;
	1619	sBlt.ulNumDstRects = DIVE_FULLY_VISIBLE;
	1620
	1621	rc = DiveSetupBlitter( me->hDive,
	1622	&sBlt);
[5291]	1623	dprintf((" DiveSetupBlitter rc=%d",rc));
[3345]	1624
	1625	return(DD_OK);
	1626	}
	1627	//******************************************************************************
	1628	//******************************************************************************
[5291]	1629	HRESULT WIN32API DrawSetDisplayMode(THIS This, DWORD dwWidth, DWORD dwHeight,
[3345]	1630	DWORD dwBPP)
	1631	{
	1632	ULONG rc;
	1633	OS2IDirectDraw me = (OS2IDirectDraw )This;
	1634	SETUP_BLITTER sBlt;
	1635
	1636	dprintf(("DDRAW: SetDisplayMode to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
[5291]	1637
[3345]	1638	me->screenwidth = dwWidth;
	1639	me->screenheight = dwHeight;
	1640	me->screenbpp = dwBPP;
	1641
	1642	if(me->dwCoopMode & DDSCL_FULLSCREEN)
	1643	{
[5291]	1644	// FSDDRAW additions
	1645	ULONG ulModeInd;
[3345]	1646
[5291]	1647	SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
	1648	SetCursorPos(dwWidth / 2, dwHeight / 2);
	1649
[3345]	1650	if ((me->bPMILoaded) && (ModeInSVGAModeTable(dwWidth,dwHeight,dwBPP)))
	1651	{
	1652	KillPM();
	1653
	1654	rc=SetSVGAMode(dwWidth, dwHeight, dwBPP, 0xFF, &ulModeInd, NULL);
	1655
	1656	if (!rc) // When mode switched successfully
	1657	{
	1658	/* save old screen values */
	1659	me->bInFullScreen=TRUE;
	1660	me->oldwidth = me->dCaps.ulHorizontalResolution;
	1661	me->oldheight = me->dCaps.ulVerticalResolution;
	1662	me->oldscanlines = me->dCaps.ulScanLineBytes;
	1663	me->oldbpp = me->dCaps.ulDepth;
	1664
	1665	/* now 'fix' some DIVE caps entries */
	1666	me->dCaps.ulScanLineBytes = dwWidth * (dwBPP >> 3); /* FIX: use real value */
	1667	me->dCaps.ulHorizontalResolution = dwWidth;
	1668	me->dCaps.ulVerticalResolution = dwHeight;
	1669	me->dCaps.ulDepth = dwBPP;
	1670	}
	1671	else
	1672	// Display must be return to PM Session
	1673	RestorePM();
	1674	}
	1675	}
[5291]	1676
[3345]	1677	memset(&sBlt,0,sizeof(sBlt));
	1678	sBlt.ulStructLen = sizeof(sBlt);
	1679	sBlt.fccSrcColorFormat = FOURCC_SCRN;
	1680	sBlt.ulSrcWidth = dwWidth;
	1681	sBlt.ulSrcHeight = dwHeight;
	1682	sBlt.ulSrcPosX = 0;
	1683	sBlt.ulSrcPosY = 0;
	1684	sBlt.fccDstColorFormat = FOURCC_SCRN;
	1685	sBlt.ulDstWidth = dwWidth;
	1686	sBlt.ulDstHeight = dwHeight;
	1687	sBlt.lDstPosX = 0;
	1688	sBlt.lDstPosY = 0;
	1689	sBlt.lScreenPosX = 0;
	1690	sBlt.lScreenPosY = me->dCaps.ulVerticalResolution-dwHeight;
	1691	sBlt.ulNumDstRects = DIVE_FULLY_VISIBLE;
	1692
	1693	rc = DiveSetupBlitter( me->hDive,
	1694	&sBlt);
[5291]	1695	dprintf((" DiveSetupBlitter rc=%d",rc));
[3345]	1696
	1697	return(DD_OK);
	1698	}
	1699	//******************************************************************************
	1700	//******************************************************************************
[5291]	1701	HRESULT WIN32API DrawWaitForVerticalBlank(THIS, DWORD dwFlags, HANDLE hEvent)
[3345]	1702	{
[5291]	1703	// HRESULT rc;
	1704	// int rci;
	1705	// USHORT sel;
[3345]	1706	dprintf(("DDRAW: WaitForVerticalBlank\n"));
	1707
	1708	if(DDWAITVB_BLOCKBEGINEVENT == dwFlags) // This parameter isn't support in DX
	1709	return (DDERR_UNSUPPORTED);
	1710
	1711	return DD_OK;
	1712
[5291]	1713	#if 0
[3345]	1714	rci = InitIO();
	1715
	1716	if(rci) // try to get IOPL for the thread
	1717	{
	1718	dprintf(("DDRAW: No IOPL\n"));
	1719	return (DDERR_UNSUPPORTED); // we failed so return error that we don't support this
	1720	}
	1721	// AT this point we should have IOPL so lets use it!
	1722	dprintf(("DDRAW: IOPL 3!\n"));
	1723
	1724	rc = DDERR_INVALIDPARAMS; // set returnvalue to fail
	1725
	1726	if(DDWAITVB_BLOCKBEGIN == dwFlags)
	1727	{
	1728	dprintf(("DDRAW: BLOCKBEGIN\n"));
	1729
	1730	while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of vert. retrace if one is running
	1731	while ((c_inb1(0x3da)&0x08)==0); // Wait for new start of retrace
	1732	rc = DD_OK;
	1733	}
	1734
	1735	if(DDWAITVB_BLOCKEND == dwFlags)
	1736	{
	1737	dprintf(("DDRAW: BLOCKEND\n"));
	1738	rc = DD_OK;
	1739	if((c_inb1(0x3da)&0x08)!=0) // Are we in a vert. retrace
	1740	{
	1741	while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of retrace
	1742	}
	1743	else
	1744	{
	1745	while ((c_inb1(0x3da)&0x08)==0); // Wait for new start of retrace
	1746	while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of vert. retrace
	1747	}
	1748
	1749	}
	1750
	1751
	1752	// io_exit1();
	1753
	1754
	1755	return (rc);
[5291]	1756	#endif
	1757	}
[3345]	1758
	1759	//******************************************************************************
	1760	//* Added in the v2 interface *
	1761	//******************************************************************************
[5291]	1762	HRESULT WIN32API DrawGetAvailableVidMem(THIS, LPDDSCAPS lpDDSCaps,
[3345]	1763	LPDWORD lpdwTotal, LPDWORD lpdwFree)
	1764	{
[5291]	1765	dprintf(("DDRAW: GetAvailableVidMem\n"));
[3345]	1766
	1767	// Check parameters
	1768	if(NULL==lpDDSCaps)
	1769	return(DDERR_INVALIDPARAMS);
	1770
	1771	if((NULL==lpdwTotal)&&(NULL==lpdwFree))
	1772	return(DDERR_INVALIDPARAMS);
	1773
	1774	if(NULL!=lpdwTotal)
	1775	lpdwTotal = 2048 1024;
	1776
	1777	if(NULL!=lpdwFree)
	1778	lpdwFree = 2048 1024;
	1779
	1780	return(DD_OK);
	1781	}
	1782	//******************************************************************************
	1783	//
	1784	//******************************************************************************
[5291]	1785	HRESULT WIN32API DrawGetAvailableVidMem4(THIS, LPDDSCAPS2 lpDDSCaps2,
[3345]	1786	LPDWORD lpdwTotal, LPDWORD lpdwFree)
	1787	{
[5291]	1788	dprintf(("DDRAW: GetAvailableVidMem\n"));
[3345]	1789
	1790	// Check parameters
	1791	if(NULL==lpDDSCaps2)
	1792	return(DDERR_INVALIDPARAMS);
	1793
	1794	if((NULL==lpdwTotal)&&(NULL==lpdwFree))
	1795	return(DDERR_INVALIDPARAMS);
	1796
	1797	if(NULL!=lpdwTotal)
	1798	lpdwTotal = 2048 1024;
	1799
	1800	if(NULL!=lpdwFree)
	1801	lpdwFree = 2048 1024;
	1802
	1803	return(DD_OK);
	1804	}
	1805	//******************************************************************************
	1806	//* Added in the v4 interface *
	1807	//******************************************************************************
[5291]	1808	HRESULT WIN32API DrawGetSurfaceFromDC(THIS, HDC hdc, LPDIRECTDRAWSURFACE4 *)
[3345]	1809	{
[5291]	1810	dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
[3345]	1811
	1812	return(DD_OK);
	1813	}
	1814	//******************************************************************************
	1815	//******************************************************************************
[5291]	1816	HRESULT WIN32API DrawRestoreAllSurfaces(THIS)
[3345]	1817	{
[5291]	1818	dprintf(("DDRAW: RestoreAllSurfaces\n"));
[3345]	1819
	1820	return(DD_OK);
	1821	}
	1822	//******************************************************************************
	1823	//******************************************************************************
[5291]	1824	HRESULT WIN32API DrawTestCooperativeLevel(THIS)
[3345]	1825	{
[5291]	1826	dprintf(("DDRAW: TestCooperativeLevel\n"));
[3345]	1827
	1828	return(DD_OK);
	1829	}
	1830	//******************************************************************************
	1831	//******************************************************************************
[5291]	1832	HRESULT WIN32API DrawGetDeviceIdentifier( THIS, LPDDDEVICEIDENTIFIER lpdddi,
[3345]	1833	DWORD dwFlags)
	1834	{
[5291]	1835	dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
[3345]	1836	if(NULL==lpdddi)
	1837	return DDERR_INVALIDPARAMS;
	1838
	1839
	1840
	1841	memset( lpdddi,
	1842	0,
	1843	sizeof(DDDEVICEIDENTIFIER));
	1844	// ToDo: Cretae a GUID and put some better data inside
	1845	strcpy( lpdddi->szDriver,
	1846	"OS/2 DIVE Driver");
	1847	strcpy( lpdddi->szDescription,
	1848	"ODIN DD Emulation Driver");
	1849
	1850
	1851
	1852	return(DD_OK);
	1853	}
	1854	//******************************************************************************
	1855	//******************************************************************************
	1856	VOID OS2IDirectDraw::SwitchDisplay(HWND hwnd)
	1857	{
	1858	DWORD dwVType, dwVSize;
	1859	HKEY hkDirectDraw2;
	1860
	1861
	1862
	1863	if (bScale)
	1864	{
	1865	if (ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,KEY_DIRECT2DRAW,&hkDirectDraw2))
	1866	{
	1867	dwVSize = 4;
	1868	dwVType = REG_DWORD;
	1869	if (ERROR_SUCCESS!=RegQueryValueExA( hkDirectDraw2, "Fullscreen", NULL, &dwVType,
	1870	(LPBYTE)&bScale, &dwVSize))
	1871	bScale = FALSE;
	1872	}
	1873	else
	1874	bScale = FALSE;
	1875	}
	1876
	1877
	1878	}
	1879	//******************************************************************************
	1880	//******************************************************************************
	1881

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/ddraw/new/os2ddraw.cpp

Download in other formats: