Context Navigation

OS2DDRAW.CPP@ 8989

Visit:

Last change on this file since 8989 was 8989, checked in by sandervl, 23 years ago
SetCustomFullScreenMode added + many fixes/changes
File size: 77.0 KB

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

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

Download in other formats:

Original Format