[ViewVC] Diff of: cebix/BasiliskII/src/video.cpp

Comparing BasiliskII/src/video.cpp (file contents):
Revision 1.5 by jlachmann, 2000-08-20T14:08:40Z vs.
Revision 1.13 by cebix, 2001-06-29T12:51:20Z

#	Line 1 \| Line 1
1		/*
2		* video.cpp - Video/graphics emulation
3		*
4	<	* Basilisk II (C) 1997-2000 Christian Bauer
4	>	* Basilisk II (C) 1997-2001 Christian Bauer
5		* Portions (C) 1997-1999 Marc Hellwig
6		*
7		* This program is free software; you can redistribute it and/or modify
#	Line 31 \| Line 31
31		#include "cpu_emulation.h"
32		#include "main.h"
33		#include "macos_util.h"
34	+	#include "slot_rom.h"
35		#include "video.h"
36		#include "video_defs.h"
37
#	Line 38 \| Line 39
39		#include "debug.h"
40
41
42	+	// List of supported video modes
43	+	std::vector<video_mode> VideoModes;
44	+
45		// Description of the main monitor
46	<	video_desc VideoMonitor;
46	>	monitor_desc VideoMonitor;
47
48		// Local variables (per monitor)
49		struct {
50	<	video_desc *desc; // Pointer to monitor description
50	>	monitor_desc *desc; // Pointer to description of monitor handled by this instance of the driver
51		uint8 palette[256 * 3]; // Color palette, 256 entries, RGB
52		bool luminance_mapping; // Luminance mapping on/off
53		bool interrupts_enabled; // VBL interrupts on/off
54	+	uint32 gamma_table; // Mac address of gamma table
55	+	uint16 current_mode; // Currently selected depth/resolution
56	+	uint32 current_id;
57	+	uint16 preferred_mode; // Preferred depth/resolution
58	+	uint32 preferred_id;
59	+	uint32 sp; // Mac address of Slot Manager parameter block
60		} VidLocal;
61
62
63		/*
64	+	* Check whether specified resolution ID is one of the supported resolutions
65	+	*/
66	+
67	+	static bool has_resolution(uint32 id)
68	+	{
69	+	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
70	+	while (i != end) {
71	+	if (i->resolution_id == id)
72	+	return true;
73	+	++i;
74	+	}
75	+	return false;
76	+	}
77	+
78	+
79	+	/*
80	+	* Find specified mode (depth/resolution) (or VideoModes.end() if not found)
81	+	*/
82	+
83	+	static std::vector<video_mode>::const_iterator find_mode(uint16 mode, uint32 id)
84	+	{
85	+	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
86	+	while (i != end) {
87	+	if (i->resolution_id == id && DepthToAppleMode(i->depth) == mode)
88	+	return i;
89	+	++i;
90	+	}
91	+	return i;
92	+	}
93	+
94	+
95	+	/*
96	+	* Find maximum supported depth for given resolution ID
97	+	*/
98	+
99	+	static video_depth max_depth_of_resolution(uint32 id)
100	+	{
101	+	video_depth m = VDEPTH_1BIT;
102	+	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
103	+	while (i != end) {
104	+	if (i->depth > m)
105	+	m = i->depth;
106	+	++i;
107	+	}
108	+	return m;
109	+	}
110	+
111	+
112	+	/*
113	+	* Get X/Y size of specified resolution
114	+	*/
115	+
116	+	static void get_size_of_resolution(uint32 id, uint32 &x, uint32 &y)
117	+	{
118	+	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
119	+	while (i != end) {
120	+	if (i->resolution_id == id) {
121	+	x = i->x;
122	+	y = i->y;
123	+	return;
124	+	}
125	+	++i;
126	+	}
127	+	}
128	+
129	+
130	+	/*
131	+	* Set palette to 50% gray
132	+	*/
133	+
134	+	static void set_gray_palette(void)
135	+	{
136	+	if (!IsDirectMode(VidLocal.current_mode)) {
137	+	for (int i=0; i<256; i++) {
138	+	VidLocal.palette[i * 3 + 0] = 127;
139	+	VidLocal.palette[i * 3 + 1] = 127;
140	+	VidLocal.palette[i * 3 + 2] = 127;
141	+	}
142	+	video_set_palette(VidLocal.palette);
143	+	}
144	+	}
145	+
146	+
147	+	/*
148		* Driver Open() routine
149		*/
150
#	Line 58 \| Line 152 \| int16 VideoDriverOpen(uint32 pb, uint32
152		{
153		D(bug("VideoDriverOpen\n"));
154
155	+	// This shouldn't happen unless the platform-specific video code is broken
156	+	if (VideoModes.empty())
157	+	fprintf(stderr, "No valid video modes found (broken video driver?)\n");
158	+
159		// Init local variables
160		VidLocal.desc = &VideoMonitor;
161		VidLocal.luminance_mapping = false;
162		VidLocal.interrupts_enabled = false;
163	+	VidLocal.current_mode = DepthToAppleMode(VidLocal.desc->mode.depth);
164	+	VidLocal.current_id = VidLocal.desc->mode.resolution_id;
165	+	VidLocal.preferred_mode = VidLocal.current_mode;
166	+	VidLocal.preferred_id = VidLocal.current_id;
167	+
168	+	// Allocate Slot Manager parameter block in Mac RAM
169	+	M68kRegisters r;
170	+	r.d[0] = SIZEOF_SPBlock;
171	+	Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
172	+	if (r.a[0] == 0)
173	+	return memFullErr;
174	+	VidLocal.sp = r.a[0];
175	+	D(bug("SPBlock at %08x\n", VidLocal.sp));
176	+
177	+	// Find and set default gamma table
178	+	VidLocal.gamma_table = 0; //!!
179
180		// Init color palette (solid gray)
181	<	if (!IsDirectMode(VidLocal.desc->mode)) {
68	<	for (int i=0; i<256; i++) {
69	<	VidLocal.palette[i * 3 + 0] = 127;
70	<	VidLocal.palette[i * 3 + 1] = 127;
71	<	VidLocal.palette[i * 3 + 2] = 127;
72	<	}
73	<	video_set_palette(VidLocal.palette);
74	<	}
181	>	set_gray_palette();
182		return noErr;
183		}
184
#	Line 87 \| Line 194 \| int16 VideoDriverControl(uint32 pb, uint
194		D(bug("VideoDriverControl %d\n", code));
195		switch (code) {
196
197	<	case cscSetMode: // Set color depth
198	<	D(bug(" SetMode %04x\n", ReadMacInt16(param + csMode)));
197	>	case cscSetMode: { // Set color depth
198	>	uint16 mode = ReadMacInt16(param + csMode);
199	>	D(bug(" SetMode %04x\n", mode));
200	>
201	>	// Set old base address in case the switch fails
202		WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
203	+
204	+	if (ReadMacInt16(param + csPage))
205	+	return paramErr;
206	+
207	+	if (mode != VidLocal.current_mode) {
208	+	std::vector<video_mode>::const_iterator i = find_mode(mode, VidLocal.current_id);
209	+	if (i == VideoModes.end())
210	+	return paramErr;
211	+	set_gray_palette();
212	+	video_switch_to_mode(*i);
213	+	VidLocal.current_mode = mode;
214	+	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
215	+	WriteMacInt32(dce + dCtlDevBase, VidLocal.desc->mac_frame_base);
216	+	}
217	+	D(bug(" base %08x\n", VidLocal.desc->mac_frame_base));
218		return noErr;
219	+	}
220
221		case cscSetEntries: { // Set palette
222	<	D(bug(" SetEntries table %08lx, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart)));
223	<	if (IsDirectMode(VidLocal.desc->mode))
222	>	D(bug(" SetEntries table %08x, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart)));
223	>	if (IsDirectMode(VidLocal.current_mode))
224		return controlErr;
225
226		uint32 s_pal = ReadMacInt32(param + csTable); // Source palette
227		uint8 *d_pal; // Destination palette
228	+	uint16 start = ReadMacInt16(param + csStart);
229		uint16 count = ReadMacInt16(param + csCount);
230	<	if (!s_pal \|\| count > 255)
230	>	if (s_pal == 0 \|\| count > 255)
231		return paramErr;
232
233	<	if (ReadMacInt16(param + csStart) == 0xffff) { // Indexed
233	>	if (start == 0xffff) { // Indexed
234		for (uint32 i=0; i<=count; i++) {
235	<	d_pal = VidLocal.palette + ReadMacInt16(s_pal) * 3;
235	>	d_pal = VidLocal.palette + (ReadMacInt16(s_pal) & 0xff) * 3;
236		uint8 red = (uint16)ReadMacInt16(s_pal + 2) >> 8;
237		uint8 green = (uint16)ReadMacInt16(s_pal + 4) >> 8;
238		uint8 blue = (uint16)ReadMacInt16(s_pal + 6) >> 8;
239		if (VidLocal.luminance_mapping)
240		red = green = blue = (red * 0x4ccc + green * 0x970a + blue * 0x1c29) >> 16;
241	+	//!! gamma correction
242		*d_pal++ = red;
243		*d_pal++ = green;
244		*d_pal++ = blue;
245		s_pal += 8;
246		}
247	<	} else { // Sequential
248	<	d_pal = VidLocal.palette + ReadMacInt16(param + csStart) * 3;
247	>	} else { // Sequential
248	>	if (start + count > 255)
249	>	return paramErr;
250	>	d_pal = VidLocal.palette + start * 3;
251		for (uint32 i=0; i<=count; i++) {
252		uint8 red = (uint16)ReadMacInt16(s_pal + 2) >> 8;
253		uint8 green = (uint16)ReadMacInt16(s_pal + 4) >> 8;
254		uint8 blue = (uint16)ReadMacInt16(s_pal + 6) >> 8;
255		if (VidLocal.luminance_mapping)
256		red = green = blue = (red * 0x4ccc + green * 0x970a + blue * 0x1c29) >> 16;
257	+	//!! gamma correction
258		*d_pal++ = red;
259		*d_pal++ = green;
260		*d_pal++ = blue;
#	Line 136 \| Line 267 \| int16 VideoDriverControl(uint32 pb, uint
267
268		case cscSetGamma: // Set gamma table
269		D(bug(" SetGamma\n"));
270	<	return noErr;
270	>	//!!
271	>	return controlErr;
272
273		case cscGrayPage: { // Fill page with dithered gray pattern
274		D(bug(" GrayPage %d\n", ReadMacInt16(param + csPage)));
#	Line 152 \| Line 284 \| int16 VideoDriverControl(uint32 pb, uint
284		0xffffffff // 32 bpp
285		};
286		uint32 p = VidLocal.desc->mac_frame_base;
287	<	uint32 pat = pattern[VidLocal.desc->mode];
288	<	for (uint32 y=0; y<VidLocal.desc->y; y++) {
289	<	uint32 p2 = p;
290	<	for (uint32 x=0; x<VidLocal.desc->bytes_per_row / 4; x++) {
291	<	WriteMacInt32(p2, pat);
292	<	p2 += 4;
161	<	if (VidLocal.desc->mode == VMODE_32BIT)
287	>	uint32 pat = pattern[VidLocal.desc->mode.depth];
288	>	bool invert = (VidLocal.desc->mode.depth == VDEPTH_32BIT);
289	>	for (uint32 y=0; y<VidLocal.desc->mode.y; y++) {
290	>	for (uint32 x=0; x<VidLocal.desc->mode.bytes_per_row; x+=4) {
291	>	WriteMacInt32(p + x, pat);
292	>	if (invert)
293		pat = ~pat;
294		}
295	<	p += VidLocal.desc->bytes_per_row;
295	>	p += VidLocal.desc->mode.bytes_per_row;
296		pat = ~pat;
297		}
298	+	//!! if direct mode, load gamma table to CLUT
299		return noErr;
300		}
301
#	Line 172 \| Line 304 \| int16 VideoDriverControl(uint32 pb, uint
304		VidLocal.luminance_mapping = ReadMacInt8(param + csMode);
305		return noErr;
306
175	–	case cscSwitchMode: // Switch video mode
176	–	D(bug(" SwitchMode %04x, %08lx\n", ReadMacInt16(param + csMode), ReadMacInt32(param + csData)));
177	–	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
178	–	return noErr;
179	–
307		case cscSetInterrupt: // Enable/disable VBL
308		D(bug(" SetInterrupt %02x\n", ReadMacInt8(param + csMode)));
309		VidLocal.interrupts_enabled = (ReadMacInt8(param + csMode) == 0);
310		return noErr;
311
312	+	case cscSetDefaultMode: { // Set default color depth
313	+	uint16 mode = ReadMacInt16(param + csMode);
314	+	D(bug(" SetDefaultMode %04x\n", mode));
315	+	VidLocal.preferred_mode = mode;
316	+	return noErr;
317	+	}
318	+
319	+	case cscSwitchMode: { // Switch video mode (depth and resolution)
320	+	uint16 mode = ReadMacInt16(param + csMode);
321	+	uint32 id = ReadMacInt32(param + csData);
322	+	D(bug(" SwitchMode %04x, %08x\n", mode, id));
323	+
324	+	// Set old base address in case the switch fails
325	+	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
326	+
327	+	if (ReadMacInt16(param + csPage))
328	+	return paramErr;
329	+
330	+	if (mode != VidLocal.current_mode \|\| id != VidLocal.current_id) {
331	+	std::vector<video_mode>::const_iterator i = find_mode(mode, id);
332	+	if (i == VideoModes.end())
333	+	return paramErr;
334	+	set_gray_palette();
335	+	video_switch_to_mode(*i);
336	+	VidLocal.current_mode = mode;
337	+	VidLocal.current_id = id;
338	+	uint32 frame_base = VidLocal.desc->mac_frame_base;
339	+	WriteMacInt32(param + csBaseAddr, frame_base);
340	+
341	+	M68kRegisters r;
342	+	uint32 sp = VidLocal.sp;
343	+	r.a[0] = sp;
344	+
345	+	// Find functional sResource for this display
346	+	WriteMacInt8(sp + spSlot, ReadMacInt8(dce + dCtlSlot));
347	+	WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId));
348	+	WriteMacInt8(sp + spExtDev, 0);
349	+	r.d[0] = 0x0016;
350	+	Execute68kTrap(0xa06e, &r); // SRsrcInfo()
351	+	uint32 rsrc = ReadMacInt32(sp + spPointer);
352	+
353	+	// Patch minorBase (otherwise rebooting won't work)
354	+	WriteMacInt8(sp + spID, 0x0a); // minorBase
355	+	r.d[0] = 0x0006;
356	+	Execute68kTrap(0xa06e, &r); // SFindStruct()
357	+	uint32 minor_base = ReadMacInt32(sp + spPointer) - ROMBaseMac;
358	+	ROMBaseHost[minor_base + 0] = frame_base >> 24;
359	+	ROMBaseHost[minor_base + 1] = frame_base >> 16;
360	+	ROMBaseHost[minor_base + 2] = frame_base >> 8;
361	+	ROMBaseHost[minor_base + 3] = frame_base;
362	+
363	+	// Patch video mode parameter table
364	+	WriteMacInt32(sp + spPointer, rsrc);
365	+	WriteMacInt8(sp + spID, mode);
366	+	r.d[0] = 0x0006;
367	+	Execute68kTrap(0xa06e, &r); // SFindStruct()
368	+	WriteMacInt8(sp + spID, 0x01);
369	+	r.d[0] = 0x0006;
370	+	Execute68kTrap(0xa06e, &r); // SFindStruct()
371	+	uint32 p = ReadMacInt32(sp + spPointer) - ROMBaseMac;
372	+	ROMBaseHost[p + 8] = i->bytes_per_row >> 8;
373	+	ROMBaseHost[p + 9] = i->bytes_per_row;
374	+	ROMBaseHost[p + 14] = i->y >> 8;
375	+	ROMBaseHost[p + 15] = i->y;
376	+	ROMBaseHost[p + 16] = i->x >> 8;
377	+	ROMBaseHost[p + 17] = i->x;
378	+
379	+	// Recalculate slot ROM checksum
380	+	ChecksumSlotROM();
381	+
382	+	// Update sResource
383	+	WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId));
384	+	r.d[0] = 0x002b;
385	+	Execute68kTrap(0xa06e, &r); // SUpdateSRT()
386	+
387	+	// Update frame buffer base in DCE
388	+	WriteMacInt32(dce + dCtlDevBase, frame_base);
389	+	}
390	+	D(bug(" base %08x\n", VidLocal.desc->mac_frame_base));
391	+	return noErr;
392	+	}
393	+
394	+	case cscSavePreferredConfiguration: {
395	+	uint16 mode = ReadMacInt16(param + csMode);
396	+	uint32 id = ReadMacInt32(param + csData);
397	+	D(bug(" SavePreferredConfiguration %04x, %08x\n", mode, id));
398	+	VidLocal.preferred_mode = mode;
399	+	VidLocal.preferred_id = id;
400	+	return noErr;
401	+	}
402	+
403		default:
404		printf("WARNING: Unknown VideoDriverControl(%d)\n", code);
405		return controlErr;
#	Line 200 \| Line 418 \| int16 VideoDriverStatus(uint32 pb, uint3
418		D(bug("VideoDriverStatus %d\n", code));
419		switch (code) {
420
421	<	case cscGetPageCnt: // Get number of pages
422	<	D(bug(" GetPageCnt\n"));
421	>	case cscGetMode: // Get current color depth
422	>	D(bug(" GetMode -> %04x, base %08x\n", VidLocal.current_mode, VidLocal.desc->mac_frame_base));
423	>	WriteMacInt16(param + csMode, VidLocal.current_mode);
424	>	WriteMacInt16(param + csPage, 0);
425	>	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
426	>	return noErr;
427	>
428	>	case cscGetEntries: { // Read palette
429	>	D(bug(" GetEntries table %08x, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart)));
430	>
431	>	uint8 *s_pal; // Source palette
432	>	uint32 d_pal = ReadMacInt32(param + csTable); // Destination palette
433	>	uint16 start = ReadMacInt16(param + csStart);
434	>	uint16 count = ReadMacInt16(param + csCount);
435	>	if (d_pal == 0 \|\| count > 255)
436	>	return paramErr;
437	>
438	>	if (start == 0xffff) { // Indexed
439	>	for (uint32 i=0; i<=count; i++) {
440	>	s_pal = VidLocal.palette + (ReadMacInt16(d_pal) & 0xff) * 3;
441	>	uint8 red = *s_pal++;
442	>	uint8 green = *s_pal++;
443	>	uint8 blue = *s_pal++;
444	>	WriteMacInt16(d_pal + 2, red * 0x0101);
445	>	WriteMacInt16(d_pal + 4, green * 0x0101);
446	>	WriteMacInt16(d_pal + 6, blue * 0x0101);
447	>	d_pal += 8;
448	>	}
449	>	} else { // Sequential
450	>	if (start + count > 255)
451	>	return paramErr;
452	>	s_pal = VidLocal.palette + start * 3;
453	>	for (uint32 i=0; i<=count; i++) {
454	>	uint8 red = *s_pal++;
455	>	uint8 green = *s_pal++;
456	>	uint8 blue = *s_pal++;
457	>	WriteMacInt16(d_pal + 2, red * 0x0101);
458	>	WriteMacInt16(d_pal + 4, green * 0x0101);
459	>	WriteMacInt16(d_pal + 6, blue * 0x0101);
460	>	d_pal += 8;
461	>	}
462	>	}
463	>	return noErr;
464	>	}
465	>
466	>	case cscGetPages: // Get number of pages
467	>	D(bug(" GetPages -> 1\n"));
468		WriteMacInt16(param + csPage, 1);
469		return noErr;
470
471	<	case cscGetPageBase: // Get page base address
472	<	D(bug(" GetPageBase\n"));
471	>	case cscGetBaseAddress: // Get page base address
472	>	D(bug(" GetBaseAddress -> %08x\n", VidLocal.desc->mac_frame_base));
473		WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
474	<	return noErr;
474	>	if (ReadMacInt16(param + csPage))
475	>	return paramErr;
476	>	else
477	>	return noErr;
478
479		case cscGetGray: // Get luminance mapping flag
480	<	D(bug(" GetGray\n"));
481	<	WriteMacInt8(param + csMode, VidLocal.luminance_mapping ? 1 : 0);
480	>	D(bug(" GetGray -> %d\n", VidLocal.luminance_mapping));
481	>	WriteMacInt16(param, VidLocal.luminance_mapping ? 0x0100 : 0);
482		return noErr;
483
484		case cscGetInterrupt: // Get interrupt disable flag
485	<	D(bug(" GetInterrupt\n"));
486	<	WriteMacInt8(param + csMode, VidLocal.interrupts_enabled ? 0 : 1);
485	>	D(bug(" GetInterrupt -> %d\n", VidLocal.interrupts_enabled));
486	>	WriteMacInt16(param, VidLocal.interrupts_enabled ? 0 : 0x0100);
487		return noErr;
488
489	<	case cscGetDefaultMode: // Get default video mode
490	<	D(bug(" GetDefaultMode\n"));
491	<	WriteMacInt8(param + csMode, 0x80);
489	>	case cscGetGamma:
490	>	D(bug(" GetGamma -> \n"));
491	>	//!!
492	>	return statusErr;
493	>
494	>	case cscGetDefaultMode: // Get default color depth
495	>	D(bug(" GetDefaultMode -> %04x\n", VidLocal.preferred_mode));
496	>	WriteMacInt16(param + csMode, VidLocal.preferred_mode);
497		return noErr;
498
499	<	case cscGetCurMode: // Get current video mode
500	<	D(bug(" GetCurMode\n"));
501	<	WriteMacInt16(param + csMode, 0x80);
502	<	WriteMacInt32(param + csData, 0x80);
499	>	case cscGetCurrentMode: // Get current video mode (depth and resolution)
500	>	D(bug(" GetCurMode -> %04x/%08x, base %08x\n", VidLocal.current_mode, VidLocal.current_id, VidLocal.desc->mac_frame_base));
501	>	WriteMacInt16(param + csMode, VidLocal.current_mode);
502	>	WriteMacInt32(param + csData, VidLocal.current_id);
503		WriteMacInt16(param + csPage, 0);
504		WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
505		return noErr;
506
507		case cscGetConnection: // Get monitor information
508		D(bug(" GetConnection\n"));
509	<	WriteMacInt16(param + csDisplayType, 6); // 21" Multiscan
510	<	WriteMacInt8(param + csConnectTaggedType, 6);
511	<	WriteMacInt8(param + csConnectTaggedData, 0x23);
512	<	WriteMacInt32(param + csConnectFlags, 0x03); // All modes valid and safe
509	>	WriteMacInt16(param + csDisplayType, 8); // Modeless connection
510	>	WriteMacInt8(param + csConnectTaggedType, 0);
511	>	WriteMacInt8(param + csConnectTaggedData, 0);
512	>	WriteMacInt32(param + csConnectFlags, 0x43); // All modes valid and safe, non-standard tagging
513		WriteMacInt32(param + csDisplayComponent, 0);
514		return noErr;
515
516	<	case cscGetModeTiming: // Get video timing for mode
517	<	D(bug(" GetModeTiming mode %08lx\n", ReadMacInt32(param + csTimingMode)));
518	<	WriteMacInt32(param + csTimingFormat, 'decl');
519	<	WriteMacInt32(param + csTimingData, 220); // 21" Multiscan
520	<	WriteMacInt32(param + csTimingFlags, 0x0f); // Mode valid, safe, default and shown in Monitors panel
516	>	case cscGetModeTiming: { // Get video timing for specified resolution
517	>	uint32 id = ReadMacInt32(param + csTimingMode);
518	>	D(bug(" GetModeTiming %08x\n", id));
519	>	if (!has_resolution(id))
520	>	return paramErr;
521	>
522	>	WriteMacInt32(param + csTimingFormat, FOURCC('d', 'e', 'c', 'l'));
523	>	WriteMacInt32(param + csTimingData, 0); // unknown
524	>	uint32 flags = 0xb; // mode valid, safe and shown in Monitors panel
525	>	if (id == VidLocal.preferred_id)
526	>	flags \|= 4; // default mode
527	>	WriteMacInt32(param + csTimingFlags, flags);
528		return noErr;
529	+	}
530
531		case cscGetModeBaseAddress: // Get frame buffer base address
532	<	D(bug(" GetModeBaseAddress\n"));
533	<	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); // Base address of video RAM for the current DisplayModeID and relative bit depth
532	>	D(bug(" GetModeBaseAddress -> base %08x\n", VidLocal.desc->mac_frame_base));
533	>	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
534		return noErr;
535
536	<	case cscGetMode: // REQUIRED for MacsBug
537	<	D(bug(" GetMode\n"));
538	<	WriteMacInt16(param + csPageMode, 0x80);
539	<	WriteMacInt32(param + csPageData, 0x80); // Unused
540	<	WriteMacInt16(param + csPagePage, 0); // Current display page
541	<	WriteMacInt32(param + csPageBaseAddr, VidLocal.desc->mac_frame_base);
536	>	case cscGetPreferredConfiguration: // Get default video mode (depth and resolution)
537	>	D(bug(" GetPreferredConfiguration -> %04x/%08x\n", VidLocal.preferred_mode, VidLocal.preferred_id));
538	>	WriteMacInt16(param + csMode, VidLocal.preferred_mode);
539	>	WriteMacInt32(param + csData, VidLocal.preferred_id);
540	>	return noErr;
541	>
542	>	case cscGetNextResolution: { // Called iteratively to obtain a list of all supported resolutions
543	>	uint32 id = ReadMacInt32(param + csPreviousDisplayModeID);
544	>	D(bug(" GetNextResolution %08x\n", id));
545	>
546	>	switch (id) {
547	>	case 0:
548	>	// Return current resolution
549	>	id = VidLocal.current_id;
550	>	break;
551	>
552	>	case 0xfffffffe:
553	>	// Return first supported resolution
554	>	id = 0x80;
555	>	while (!has_resolution(id))
556	>	id++;
557	>	break;
558	>
559	>	default:
560	>	// Get next resolution
561	>	if (!has_resolution(id))
562	>	return paramErr;
563	>	id++;
564	>	while (!has_resolution(id) && id < 0x100)
565	>	id++;
566	>	if (id == 0x100) { // No more resolutions
567	>	WriteMacInt32(param + csRIDisplayModeID, 0xfffffffd);
568	>	return noErr;
569	>	}
570	>	break;
571	>	}
572	>
573	>	WriteMacInt32(param + csRIDisplayModeID, id);
574	>	uint32 x, y;
575	>	get_size_of_resolution(id, x, y);
576	>	WriteMacInt32(param + csHorizontalPixels, x);
577	>	WriteMacInt32(param + csVerticalLines, y);
578	>	WriteMacInt32(param + csRefreshRate, 75 << 16);
579	>	WriteMacInt16(param + csMaxDepthMode, DepthToAppleMode(max_depth_of_resolution(id)));
580		return noErr;
581	+	}
582	+
583	+	case cscGetVideoParameters: { // Get information about specified resolution/depth
584	+	uint32 id = ReadMacInt32(param + csDisplayModeID);
585	+	uint16 mode = ReadMacInt16(param + csDepthMode);
586	+	D(bug(" GetVideoParameters %04x/%08x\n", mode, id));
587	+
588	+	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
589	+	while (i != end) {
590	+	if (DepthToAppleMode(i->depth) == mode && i->resolution_id == id) {
591	+	uint32 vp = ReadMacInt32(param + csVPBlockPtr);
592	+	WriteMacInt32(vp + vpBaseOffset, 0);
593	+	WriteMacInt16(vp + vpRowBytes, i->bytes_per_row);
594	+	WriteMacInt16(vp + vpBounds, 0);
595	+	WriteMacInt16(vp + vpBounds + 2, 0);
596	+	WriteMacInt16(vp + vpBounds + 4, i->y);
597	+	WriteMacInt16(vp + vpBounds + 6, i->x);
598	+	WriteMacInt16(vp + vpVersion, 0);
599	+	WriteMacInt16(vp + vpPackType, 0);
600	+	WriteMacInt32(vp + vpPackSize, 0);
601	+	WriteMacInt32(vp + vpHRes, 0x00480000); // 72 dpi
602	+	WriteMacInt32(vp + vpVRes, 0x00480000);
603	+	uint32 pix_type, pix_size, cmp_count, cmp_size, dev_type;
604	+	switch (i->depth) {
605	+	case VDEPTH_1BIT:
606	+	pix_type = 0; pix_size = 1;
607	+	cmp_count = 1; cmp_size = 1;
608	+	dev_type = 0; // CLUT
609	+	break;
610	+	case VDEPTH_2BIT:
611	+	pix_type = 0; pix_size = 2;
612	+	cmp_count = 1; cmp_size = 2;
613	+	dev_type = 0; // CLUT
614	+	break;
615	+	case VDEPTH_4BIT:
616	+	pix_type = 0; pix_size = 4;
617	+	cmp_count = 1; cmp_size = 4;
618	+	dev_type = 0; // CLUT
619	+	break;
620	+	case VDEPTH_8BIT:
621	+	pix_type = 0; pix_size = 8;
622	+	cmp_count = 1; cmp_size = 8;
623	+	dev_type = 0; // CLUT
624	+	break;
625	+	case VDEPTH_16BIT:
626	+	pix_type = 0x10; pix_size = 16;
627	+	cmp_count = 3; cmp_size = 5;
628	+	dev_type = 2; // direct
629	+	break;
630	+	case VDEPTH_32BIT:
631	+	pix_type = 0x10; pix_size = 32;
632	+	cmp_count = 3; cmp_size = 8;
633	+	dev_type = 2; // direct
634	+	break;
635	+	}
636	+	WriteMacInt16(vp + vpPixelType, pix_type);
637	+	WriteMacInt16(vp + vpPixelSize, pix_size);
638	+	WriteMacInt16(vp + vpCmpCount, cmp_count);
639	+	WriteMacInt16(vp + vpCmpSize, cmp_size);
640	+	WriteMacInt32(param + csPageCount, 1);
641	+	WriteMacInt32(param + csDeviceType, dev_type);
642	+	return noErr;
643	+	}
644	+	++i;
645	+	}
646	+	return paramErr; // specified resolution/depth not supported
647	+	}
648
649		default:
650		printf("WARNING: Unknown VideoDriverStatus(%d)\n", code);

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing BasiliskII/src/video.cpp (file contents): Revision 1.5 by jlachmann, 2000-08-20T14:08:40Z vs. Revision 1.13 by cebix, 2001-06-29T12:51:20Z

Diff Legend

Comparing BasiliskII/src/video.cpp (file contents):
Revision 1.5 by jlachmann, 2000-08-20T14:08:40Z vs.
Revision 1.13 by cebix, 2001-06-29T12:51:20Z