Context Navigation

OS2DDRAW.CPP@ 5499

Visit:

Last change on this file since 5499 was 5472, checked in by sandervl, 25 years ago
compile fix
File size: 66.6 KB

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

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

Download in other formats:

Original Format