Context Navigation

OS2DDRAW.CPP@ 8902

Visit:

Last change on this file since 8902 was 8604, checked in by sandervl, 23 years ago
Print FOURCCs supported by Dive
File size: 77.4 KB

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

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

Download in other formats:

Original Format