Context Navigation

OS2DDRAW.CPP@ 10067

Visit:

Last change on this file since 10067 was 5291, checked in by mike, 25 years ago
Updates/cleanup for Watcom (not complete)
File size: 66.4 KB

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

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

Download in other formats:

Original Format