Context Navigation

OS2DDRAW.CPP@ 5413

Visit:

Last change on this file since 5413 was 5392, checked in by sandervl, 25 years ago
FOURCC checking during surface creation
File size: 66.5 KB

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

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

Download in other formats:

Original Format