ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/video.cpp

Comparing BasiliskII/src/video.cpp (file contents):
Revision 1.10 by cebix, 2001-06-27T20:05:23Z vs.
Revision 1.20 by cebix, 2001-07-03T19:20:38Z

#	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
38	<	#define DEBUG 1
38	>	#define DEBUG 0
39		#include "debug.h"
40
41
#	Line 44 | Line 45 | vector<video_mode> VideoModes;
45		// Description of the main monitor
46		monitor_desc VideoMonitor;
47
48	+	// Depth code -> Apple mode mapping
49	+	uint16 apple_mode_for_depth[6];
50	+
51		// Local variables (per monitor)
52		struct {
53		monitor_desc *desc;                     // Pointer to description of monitor handled by this instance of the driver
54		uint8 palette[256 * 3];         // Color palette, 256 entries, RGB
55		bool luminance_mapping;         // Luminance mapping on/off
56		bool interrupts_enabled;        // VBL interrupts on/off
57	+	bool dm_present;                        // We received a GetVideoParameters call, so the Display Manager seems to be present
58	+	uint32 gamma_table;                     // Mac address of gamma table
59	+	int alloc_gamma_table_size;     // Allocated size of gamma table
60		uint16 current_mode;            // Currently selected depth/resolution
61		uint32 current_id;
62		uint16 preferred_mode;          // Preferred depth/resolution
63		uint32 preferred_id;
64	+	uint32 slot_param;                      // Mac address of Slot Manager parameter block
65		} VidLocal;
66
67
68		/*
69	+	*  Initialize apple_mode_for_depth[] array from VideoModes list
70	+	*/
71	+
72	+	void video_init_depth_list(void)
73	+	{
74	+	uint16 mode = 0x80;
75	+	for (int depth = VDEPTH_1BIT; depth <= VDEPTH_32BIT; depth++) {
76	+	if (video_has_depth(video_depth(depth)))
77	+	apple_mode_for_depth[depth] = mode++;
78	+	else
79	+	apple_mode_for_depth[depth] = 0;
80	+	}
81	+	}
82	+
83	+
84	+	/*
85	+	*  Check whether a mode with the specified depth exists
86	+	*/
87	+
88	+	bool video_has_depth(video_depth depth)
89	+	{
90	+	vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
91	+	while (i != end) {
92	+	if (i->depth == depth)
93	+	return true;
94	+	++i;
95	+	}
96	+	return false;
97	+	}
98	+
99	+
100	+	/*
101		*  Check whether specified resolution ID is one of the supported resolutions
102		*/
103
104		static bool has_resolution(uint32 id)
105		{
106	<	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
107	<	while (i != end) {
106	>	vector<video_mode>::const_iterator i, end = VideoModes.end();
107	>	for (i = VideoModes.begin(); i != end; ++i) {
108		if (i->resolution_id == id)
109		return true;
70	–	++i;
110		}
111		return false;
112		}
#	Line 77 | Line 116 | static bool has_resolution(uint32 id)
116		*  Find specified mode (depth/resolution) (or VideoModes.end() if not found)
117		*/
118
119	<	static std::vector<video_mode>::const_iterator find_mode(uint16 mode, uint32 id)
119	>	static vector<video_mode>::const_iterator find_mode(uint16 mode, uint32 id)
120		{
121	<	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
122	<	while (i != end) {
121	>	vector<video_mode>::const_iterator i, end = VideoModes.end();
122	>	for (i = VideoModes.begin(); i != end; ++i) {
123		if (i->resolution_id == id && DepthToAppleMode(i->depth) == mode)
124		return i;
86	–	++i;
125		}
126		return i;
127		}
#	Line 96 | Line 134 | static std::vector<video_mode>::const_it
134		static video_depth max_depth_of_resolution(uint32 id)
135		{
136		video_depth m = VDEPTH_1BIT;
137	<	vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
138	<	while (i != end) {
137	>	vector<video_mode>::const_iterator i, end = VideoModes.end();
138	>	for (i = VideoModes.begin(); i != end; ++i) {
139		if (i->depth > m)
140		m = i->depth;
103	–	++i;
141		}
142		return m;
143		}
#	Line 112 | Line 149 | static video_depth max_depth_of_resoluti
149
150		static void get_size_of_resolution(uint32 id, uint32 &x, uint32 &y)
151		{
152	<	vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
153	<	while (i != end) {
152	>	vector<video_mode>::const_iterator i, end = VideoModes.end();
153	>	for (i = VideoModes.begin(); i != end; ++i) {
154		if (i->resolution_id == id) {
155		x = i->x;
156		y = i->y;
157		return;
158		}
159	<	++i;
159	>	}
160	>	x = y = 0;
161	>	}
162	>
163	>
164	>	/*
165	>	*  Get bytes-per-row value for specified resolution/depth
166	>	*/
167	>
168	>	uint32 video_bytes_per_row(video_depth depth, uint32 id)
169	>	{
170	>	vector<video_mode>::const_iterator i, end = VideoModes.end();
171	>	for (i = VideoModes.begin(); i != end; ++i) {
172	>	if (i->depth == depth && i->resolution_id == id)
173	>	return i->bytes_per_row;
174	>	}
175	>	uint32 x, y;
176	>	get_size_of_resolution(id, x, y);
177	>	return TrivialBytesPerRow(x, depth);
178	>	}
179	>
180	>
181	>	/*
182	>	*  Find palette size for given color depth
183	>	*/
184	>
185	>	static int palette_size(video_depth depth)
186	>	{
187	>	switch (depth) {
188	>	case VDEPTH_1BIT: return 2;
189	>	case VDEPTH_2BIT: return 4;
190	>	case VDEPTH_4BIT: return 16;
191	>	case VDEPTH_8BIT: return 256;
192	>	case VDEPTH_16BIT: return 32;
193	>	case VDEPTH_32BIT: return 256;
194	>	default: return 0;
195	>	}
196	>	}
197	>
198	>
199	>	/*
200	>	*  Set palette to 50% gray
201	>	*/
202	>
203	>	static void set_gray_palette(void)
204	>	{
205	>	for (int i=0; i<256; i++) {
206	>	VidLocal.palette[i * 3 + 0] = 127;
207	>	VidLocal.palette[i * 3 + 1] = 127;
208	>	VidLocal.palette[i * 3 + 2] = 127;
209	>	}
210	>	video_set_palette(VidLocal.palette, 256);
211	>	}
212	>
213	>
214	>	/*
215	>	*  Load gamma-corrected black-to-white ramp to palette for direct-color mode
216	>	*/
217	>
218	>	static void load_ramp_palette(void)
219	>	{
220	>	// Find tables for gamma correction
221	>	uint8 *red_gamma, *green_gamma, *blue_gamma;
222	>	bool have_gamma = false;
223	>	int data_width = 0;
224	>	if (VidLocal.gamma_table) {
225	>	uint32 table = VidLocal.gamma_table;
226	>	red_gamma = Mac2HostAddr(table + gFormulaData + ReadMacInt16(table + gFormulaSize));
227	>	int chan_cnt = ReadMacInt16(table + gChanCnt);
228	>	if (chan_cnt == 1)
229	>	green_gamma = blue_gamma = red_gamma;
230	>	else {
231	>	int ofs = ReadMacInt16(table + gDataCnt);
232	>	green_gamma = red_gamma + ofs;
233	>	blue_gamma = green_gamma + ofs;
234	>	}
235	>	data_width = ReadMacInt16(table + gDataWidth);
236	>	have_gamma = true;
237	>	}
238	>
239	>	int num = (VidLocal.desc->mode.depth == VDEPTH_16BIT ? 32 : 256);
240	>	uint8 *p = VidLocal.palette;
241	>	for (int i=0; i<num; i++) {
242	>	uint8 red = (i * 256 / num), green = red, blue = red;
243	>	if (have_gamma) {
244	>	red = red_gamma[red >> (8 - data_width)];
245	>	green = green_gamma[green >> (8 - data_width)];
246	>	blue = blue_gamma[blue >> (8 - data_width)];
247	>	}
248	>	*p++ = red;
249	>	*p++ = green;
250	>	*p++ = blue;
251	>	}
252	>
253	>	video_set_palette(VidLocal.palette, num);
254	>	}
255	>
256	>
257	>	/*
258	>	*  Allocate gamma table of specified size
259	>	*/
260	>
261	>	static bool allocate_gamma_table(int size)
262	>	{
263	>	M68kRegisters r;
264	>
265	>	if (size > VidLocal.alloc_gamma_table_size) {
266	>	if (VidLocal.gamma_table) {
267	>	r.a[0] = VidLocal.gamma_table;
268	>	Execute68kTrap(0xa01f, &r);     // DisposePtr()
269	>	VidLocal.gamma_table = 0;
270	>	VidLocal.alloc_gamma_table_size = 0;
271	>	}
272	>	r.d[0] = size;
273	>	Execute68kTrap(0xa71e, &r);     // NewPtrSysClear()
274	>	if (r.a[0] == 0)
275	>	return false;
276	>	VidLocal.gamma_table = r.a[0];
277	>	VidLocal.alloc_gamma_table_size = size;
278	>	}
279	>	return true;
280	>	}
281	>
282	>
283	>	/*
284	>	*  Set gamma table (0 = build linear ramp)
285	>	*/
286	>
287	>	static bool set_gamma_table(uint32 user_table)
288	>	{
289	>	if (user_table == 0) { // Build linear ramp, 256 entries
290	>
291	>	// Allocate new table, if necessary
292	>	if (!allocate_gamma_table(SIZEOF_GammaTbl + 256))
293	>	return memFullErr;
294	>	uint32 table = VidLocal.gamma_table;
295	>
296	>	// Initialize header
297	>	WriteMacInt16(table + gVersion, 0);
298	>	WriteMacInt16(table + gType, 0);
299	>	WriteMacInt16(table + gFormulaSize, 0);
300	>	WriteMacInt16(table + gChanCnt, 1);
301	>	WriteMacInt16(table + gDataCnt, 256);
302	>	WriteMacInt16(table + gDataWidth, 8);
303	>
304	>	// Build ramp
305	>	uint32 p = table + gFormulaData;
306	>	for (int i=0; i<256; i++)
307	>	WriteMacInt8(p + i, i);
308	>
309	>	} else { // User-supplied gamma table
310	>
311	>	// Validate header
312	>	if (ReadMacInt16(user_table + gVersion))
313	>	return paramErr;
314	>	if (ReadMacInt16(user_table + gType))
315	>	return paramErr;
316	>	int chan_cnt = ReadMacInt16(user_table + gChanCnt);
317	>	if (chan_cnt != 1 && chan_cnt != 3)
318	>	return paramErr;
319	>	int data_width = ReadMacInt16(user_table + gDataWidth);
320	>	if (data_width > 8)
321	>	return paramErr;
322	>	int data_cnt = ReadMacInt16(user_table + gDataCnt);
323	>	if (data_cnt != (1 << data_width))
324	>	return paramErr;
325	>
326	>	// Allocate new table, if necessary
327	>	int size = SIZEOF_GammaTbl + ReadMacInt16(user_table + gFormulaSize) + chan_cnt * data_cnt;
328	>	if (!allocate_gamma_table(size))
329	>	return memFullErr;
330	>	uint32 table = VidLocal.gamma_table;
331	>
332	>	// Copy table
333	>	Mac2Mac_memcpy(table, user_table, size);
334	>	}
335	>
336	>	if (IsDirectMode(VidLocal.desc->mode))
337	>	load_ramp_palette();
338	>
339	>	return true;
340	>	}
341	>
342	>
343	>	/*
344	>	*  Switch video mode
345	>	*/
346	>
347	>	static void switch_mode(const video_mode &mode, uint32 param, uint32 dce)
348	>	{
349	>	// Switch mode
350	>	set_gray_palette();
351	>	video_switch_to_mode(mode);
352	>
353	>	// Update VidLocal
354	>	VidLocal.current_mode = DepthToAppleMode(mode.depth);
355	>	VidLocal.current_id = mode.resolution_id;
356	>
357	>	uint32 frame_base = VidLocal.desc->mac_frame_base;
358	>
359	>	M68kRegisters r;
360	>	uint32 sp = VidLocal.slot_param;
361	>	r.a[0] = sp;
362	>
363	>	// Find functional sResource for this display
364	>	WriteMacInt8(sp + spSlot, ReadMacInt8(dce + dCtlSlot));
365	>	WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId));
366	>	WriteMacInt8(sp + spExtDev, 0);
367	>	r.d[0] = 0x0016;
368	>	Execute68kTrap(0xa06e, &r);     // SRsrcInfo()
369	>	uint32 rsrc = ReadMacInt32(sp + spPointer);
370	>
371	>	// Patch minorBase (otherwise rebooting won't work)
372	>	WriteMacInt8(sp + spID, 0x0a); // minorBase
373	>	r.d[0] = 0x0006;
374	>	Execute68kTrap(0xa06e, &r); // SFindStruct()
375	>	uint32 minor_base = ReadMacInt32(sp + spPointer) - ROMBaseMac;
376	>	ROMBaseHost[minor_base + 0] = frame_base >> 24;
377	>	ROMBaseHost[minor_base + 1] = frame_base >> 16;
378	>	ROMBaseHost[minor_base + 2] = frame_base >> 8;
379	>	ROMBaseHost[minor_base + 3] = frame_base;
380	>
381	>	// Patch video mode parameter table
382	>	WriteMacInt32(sp + spPointer, rsrc);
383	>	WriteMacInt8(sp + spID, DepthToAppleMode(mode.depth));
384	>	r.d[0] = 0x0006;
385	>	Execute68kTrap(0xa06e, &r); // SFindStruct()
386	>	WriteMacInt8(sp + spID, 0x01);
387	>	r.d[0] = 0x0006;
388	>	Execute68kTrap(0xa06e, &r); // SFindStruct()
389	>	uint32 p = ReadMacInt32(sp + spPointer) - ROMBaseMac;
390	>	ROMBaseHost[p +  8] = mode.bytes_per_row >> 8;
391	>	ROMBaseHost[p +  9] = mode.bytes_per_row;
392	>	ROMBaseHost[p + 14] = mode.y >> 8;
393	>	ROMBaseHost[p + 15] = mode.y;
394	>	ROMBaseHost[p + 16] = mode.x >> 8;
395	>	ROMBaseHost[p + 17] = mode.x;
396	>
397	>	// Recalculate slot ROM checksum
398	>	ChecksumSlotROM();
399	>
400	>	// Update sResource
401	>	WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId));
402	>	r.d[0] = 0x002b;
403	>	Execute68kTrap(0xa06e, &r); // SUpdateSRT()
404	>
405	>	// Update frame buffer base in DCE and param block
406	>	WriteMacInt32(dce + dCtlDevBase, frame_base);
407	>	WriteMacInt32(param + csBaseAddr, frame_base);
408	>
409	>	// Patch frame buffer base address for MacOS versions <7.6
410	>	if (!VidLocal.dm_present) { // Only do this when no Display Manager seems to be present; otherwise, the screen will not get redrawn
411	>	WriteMacInt32(0x824, frame_base);                       // ScrnBase
412	>	uint32 gdev = ReadMacInt32(0x8a4);                      // MainDevice
413	>	gdev = ReadMacInt32(gdev);
414	>	uint32 pmap = ReadMacInt32(gdev + 0x16);        // gdPMap
415	>	pmap = ReadMacInt32(pmap);
416	>	WriteMacInt32(pmap, frame_base);                        // baseAddr
417		}
418		}
419
#	Line 144 | Line 438 | int16 VideoDriverOpen(uint32 pb, uint32
438		VidLocal.current_id = VidLocal.desc->mode.resolution_id;
439		VidLocal.preferred_mode = VidLocal.current_mode;
440		VidLocal.preferred_id = VidLocal.current_id;
441	+	VidLocal.dm_present = false;
442	+
443	+	// Allocate Slot Manager parameter block in Mac RAM
444	+	M68kRegisters r;
445	+	r.d[0] = SIZEOF_SPBlock;
446	+	Execute68kTrap(0xa71e, &r);     // NewPtrSysClear()
447	+	if (r.a[0] == 0)
448	+	return memFullErr;
449	+	VidLocal.slot_param = r.a[0];
450	+	D(bug("SPBlock at %08x\n", VidLocal.slot_param));
451	+
452	+	// Find and set default gamma table
453	+	VidLocal.gamma_table = 0;
454	+	VidLocal.alloc_gamma_table_size = 0;
455	+	set_gamma_table(0);
456
457		// Init color palette (solid gray)
458	<	if (!IsDirectMode(VidLocal.desc->mode)) {
150	<	for (int i=0; i<256; i++) {
151	<	VidLocal.palette[i * 3 + 0] = 127;
152	<	VidLocal.palette[i * 3 + 1] = 127;
153	<	VidLocal.palette[i * 3 + 2] = 127;
154	<	}
155	<	video_set_palette(VidLocal.palette);
156	<	}
458	>	set_gray_palette();
459		return noErr;
460		}
461
#	Line 173 | Line 475 | int16 VideoDriverControl(uint32 pb, uint
475		uint16 mode = ReadMacInt16(param + csMode);
476		D(bug(" SetMode %04x\n", mode));
477
478	+	// Set old base address in case the switch fails
479	+	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
480	+
481	+	if (ReadMacInt16(param + csPage))
482	+	return paramErr;
483	+
484		if (mode != VidLocal.current_mode) {
485	<	std::vector<video_mode>::const_iterator i = find_mode(mode, VidLocal.current_id);
486	<	if (i == VideoModes.end()) {
179	<	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
485	>	vector<video_mode>::const_iterator i = find_mode(mode, VidLocal.current_id);
486	>	if (i == VideoModes.end())
487		return paramErr;
488	<	}
182	<	video_switch_to_mode(*i);
183	<	VidLocal.current_mode = mode;
488	>	switch_mode(*i, param, dce);
489		}
490	<	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
490	>	D(bug("  base %08x\n", VidLocal.desc->mac_frame_base));
491		return noErr;
492		}
493
494	<	case cscSetEntries: {   // Set palette
495	<	D(bug(" SetEntries table %08lx, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart)));
496	<	if (IsDirectMode(VidLocal.desc->mode))
494	>	case cscSetEntries:             // Set palette
495	>	case cscDirectSetEntries: {
496	>	D(bug(" (Direct)SetEntries table %08x, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart)));
497	>	bool is_direct = IsDirectMode(VidLocal.desc->mode);
498	>	if (code == cscSetEntries && is_direct)
499	>	return controlErr;
500	>	if (code == cscDirectSetEntries && !is_direct)
501		return controlErr;
502
503		uint32 s_pal = ReadMacInt32(param + csTable);   // Source palette
504		uint8 *d_pal;                                                                   // Destination palette
505	+	uint16 start = ReadMacInt16(param + csStart);
506		uint16 count = ReadMacInt16(param + csCount);
507	<	if (!s_pal || count > 255)
507	>	if (s_pal == 0 || count > 255)
508		return paramErr;
509
510	<	if (ReadMacInt16(param + csStart) == 0xffff) {  // Indexed
510	>	// Find tables for gamma correction
511	>	uint8 *red_gamma, *green_gamma, *blue_gamma;
512	>	bool have_gamma = false;
513	>	int data_width = 0;
514	>	if (VidLocal.gamma_table) {
515	>	uint32 table = VidLocal.gamma_table;
516	>	red_gamma = Mac2HostAddr(table + gFormulaData + ReadMacInt16(table + gFormulaSize));
517	>	int chan_cnt = ReadMacInt16(table + gChanCnt);
518	>	if (chan_cnt == 1)
519	>	green_gamma = blue_gamma = red_gamma;
520	>	else {
521	>	int ofs = ReadMacInt16(table + gDataCnt);
522	>	green_gamma = red_gamma + ofs;
523	>	blue_gamma = green_gamma + ofs;
524	>	}
525	>	data_width = ReadMacInt16(table + gDataWidth);
526	>	have_gamma = true;
527	>	}
528	>
529	>	// Convert palette
530	>	if (start == 0xffff) {  // Indexed
531		for (uint32 i=0; i<=count; i++) {
532	<	d_pal = VidLocal.palette + ReadMacInt16(s_pal) * 3;
532	>	d_pal = VidLocal.palette + (ReadMacInt16(s_pal) & 0xff) * 3;
533		uint8 red = (uint16)ReadMacInt16(s_pal + 2) >> 8;
534		uint8 green = (uint16)ReadMacInt16(s_pal + 4) >> 8;
535		uint8 blue = (uint16)ReadMacInt16(s_pal + 6) >> 8;
536	<	if (VidLocal.luminance_mapping)
536	>	if (VidLocal.luminance_mapping && !is_direct)
537		red = green = blue = (red * 0x4ccc + green * 0x970a + blue * 0x1c29) >> 16;
538	+	if (have_gamma) {
539	+	red = red_gamma[red >> (8 - data_width)];
540	+	green = green_gamma[green >> (8 - data_width)];
541	+	blue = blue_gamma[blue >> (8 - data_width)];
542	+	}
543		*d_pal++ = red;
544		*d_pal++ = green;
545		*d_pal++ = blue;
546		s_pal += 8;
547		}
548	<	} else {                                                                                // Sequential
549	<	d_pal = VidLocal.palette + ReadMacInt16(param + csStart) * 3;
548	>	} else {                                // Sequential
549	>	if (start + count > 255)
550	>	return paramErr;
551	>	d_pal = VidLocal.palette + start * 3;
552		for (uint32 i=0; i<=count; i++) {
553		uint8 red = (uint16)ReadMacInt16(s_pal + 2) >> 8;
554		uint8 green = (uint16)ReadMacInt16(s_pal + 4) >> 8;
555		uint8 blue = (uint16)ReadMacInt16(s_pal + 6) >> 8;
556	<	if (VidLocal.luminance_mapping)
556	>	if (VidLocal.luminance_mapping && !is_direct)
557		red = green = blue = (red * 0x4ccc + green * 0x970a + blue * 0x1c29) >> 16;
558	+	if (have_gamma) {
559	+	red = red_gamma[red >> (8 - data_width)];
560	+	green = green_gamma[green >> (8 - data_width)];
561	+	blue = blue_gamma[blue >> (8 - data_width)];
562	+	}
563		*d_pal++ = red;
564		*d_pal++ = green;
565		*d_pal++ = blue;
566		s_pal += 8;
567		}
568		}
569	<	video_set_palette(VidLocal.palette);
569	>	video_set_palette(VidLocal.palette, palette_size(VidLocal.desc->mode.depth));
570		return noErr;
571		}
572
573	<	case cscSetGamma:               // Set gamma table
574	<	D(bug(" SetGamma\n"));
575	<	//!!
576	<	return noErr;
573	>	case cscSetGamma: {             // Set gamma table
574	>	uint32 user_table = ReadMacInt32(param + csGTable);
575	>	D(bug(" SetGamma %08x\n", user_table));
576	>	return set_gamma_table(user_table) ? noErr : memFullErr;
577	>	}
578
579		case cscGrayPage: {             // Fill page with dithered gray pattern
580		D(bug(" GrayPage %d\n", ReadMacInt16(param + csPage)));
#	Line 246 | Line 589 | int16 VideoDriverControl(uint32 pb, uint
589		0xffff0000,             // 16 bpp
590		0xffffffff              // 32 bpp
591		};
592	<	uint32 p = VidLocal.desc->mac_frame_base;
592	>	uint32 frame_base = VidLocal.desc->mac_frame_base;
593		uint32 pat = pattern[VidLocal.desc->mode.depth];
594	+	bool invert = (VidLocal.desc->mode.depth == VDEPTH_32BIT);
595		for (uint32 y=0; y<VidLocal.desc->mode.y; y++) {
596		for (uint32 x=0; x<VidLocal.desc->mode.bytes_per_row; x+=4) {
597	<	WriteMacInt32(p + x, pat);
598	<	if (VidLocal.desc->mode.depth == VDEPTH_32BIT)
597	>	WriteMacInt32(frame_base + x, pat);
598	>	if (invert)
599		pat = ~pat;
600		}
601	<	p += VidLocal.desc->mode.bytes_per_row;
601	>	frame_base += VidLocal.desc->mode.bytes_per_row;
602		pat = ~pat;
603		}
604	+
605	+	if (IsDirectMode(VidLocal.desc->mode))
606	+	load_ramp_palette();
607	+
608		return noErr;
609		}
610
#	Line 270 | Line 618 | int16 VideoDriverControl(uint32 pb, uint
618		VidLocal.interrupts_enabled = (ReadMacInt8(param + csMode) == 0);
619		return noErr;
620
273	–	// case cscDirectSetEntries:
274	–
621		case cscSetDefaultMode: { // Set default color depth
622		uint16 mode = ReadMacInt16(param + csMode);
623		D(bug(" SetDefaultMode %04x\n", mode));
#	Line 284 | Line 630 | int16 VideoDriverControl(uint32 pb, uint
630		uint32 id = ReadMacInt32(param + csData);
631		D(bug(" SwitchMode %04x, %08x\n", mode, id));
632
633	+	// Set old base address in case the switch fails
634	+	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
635	+
636	+	if (ReadMacInt16(param + csPage))
637	+	return paramErr;
638	+
639		if (mode != VidLocal.current_mode || id != VidLocal.current_id) {
640	<	std::vector<video_mode>::const_iterator i = find_mode(mode, id);
641	<	if (i == VideoModes.end()) {
290	<	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
640	>	vector<video_mode>::const_iterator i = find_mode(mode, id);
641	>	if (i == VideoModes.end())
642		return paramErr;
643	<	}
293	<	video_switch_to_mode(*i);
294	<	VidLocal.current_mode = mode;
295	<	VidLocal.current_id = id;
643	>	switch_mode(*i, param, dce);
644		}
645	<	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
645	>	D(bug("  base %08x\n", VidLocal.desc->mac_frame_base));
646		return noErr;
647		}
648
#	Line 332 | Line 680 | int16 VideoDriverStatus(uint32 pb, uint3
680		WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
681		return noErr;
682
683	<	// case cscGetEntries:
683	>	case cscGetEntries: {           // Read palette
684	>	D(bug(" GetEntries table %08x, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart)));
685
686	<	case cscGetPageCnt:                     // Get number of pages
687	<	D(bug(" GetPageCnt -> 1\n"));
686	>	uint8 *s_pal;                                                                   // Source palette
687	>	uint32 d_pal = ReadMacInt32(param + csTable);   // Destination palette
688	>	uint16 start = ReadMacInt16(param + csStart);
689	>	uint16 count = ReadMacInt16(param + csCount);
690	>	if (d_pal == 0 || count > 255)
691	>	return paramErr;
692	>
693	>	if (start == 0xffff) {  // Indexed
694	>	for (uint32 i=0; i<=count; i++) {
695	>	s_pal = VidLocal.palette + (ReadMacInt16(d_pal) & 0xff) * 3;
696	>	uint8 red = *s_pal++;
697	>	uint8 green = *s_pal++;
698	>	uint8 blue = *s_pal++;
699	>	WriteMacInt16(d_pal + 2, red * 0x0101);
700	>	WriteMacInt16(d_pal + 4, green * 0x0101);
701	>	WriteMacInt16(d_pal + 6, blue * 0x0101);
702	>	d_pal += 8;
703	>	}
704	>	} else {                                // Sequential
705	>	if (start + count > 255)
706	>	return paramErr;
707	>	s_pal = VidLocal.palette + start * 3;
708	>	for (uint32 i=0; i<=count; i++) {
709	>	uint8 red = *s_pal++;
710	>	uint8 green = *s_pal++;
711	>	uint8 blue = *s_pal++;
712	>	WriteMacInt16(d_pal + 2, red * 0x0101);
713	>	WriteMacInt16(d_pal + 4, green * 0x0101);
714	>	WriteMacInt16(d_pal + 6, blue * 0x0101);
715	>	d_pal += 8;
716	>	}
717	>	}
718	>	return noErr;
719	>	}
720	>
721	>	case cscGetPages:                       // Get number of pages
722	>	D(bug(" GetPages -> 1\n"));
723		WriteMacInt16(param + csPage, 1);
724		return noErr;
725
726	<	case cscGetPageBase:            // Get page base address
727	<	D(bug(" GetPageBase -> %08x\n", VidLocal.desc->mac_frame_base));
726	>	case cscGetBaseAddress:         // Get page base address
727	>	D(bug(" GetBaseAddress -> %08x\n", VidLocal.desc->mac_frame_base));
728		WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
729	<	return noErr;
729	>	if (ReadMacInt16(param + csPage))
730	>	return paramErr;
731	>	else
732	>	return noErr;
733
734		case cscGetGray:                        // Get luminance mapping flag
735		D(bug(" GetGray -> %d\n", VidLocal.luminance_mapping));
736	<	WriteMacInt8(param, VidLocal.luminance_mapping ? 1 : 0);
736	>	WriteMacInt16(param, VidLocal.luminance_mapping ? 0x0100 : 0);
737		return noErr;
738
739		case cscGetInterrupt:           // Get interrupt disable flag
740		D(bug(" GetInterrupt -> %d\n", VidLocal.interrupts_enabled));
741	<	WriteMacInt8(param, VidLocal.interrupts_enabled ? 0 : 1);
741	>	WriteMacInt16(param, VidLocal.interrupts_enabled ? 0 : 0x0100);
742		return noErr;
743
744	<	// case cscGetGamma:
744	>	case cscGetGamma:
745	>	D(bug(" GetGamma -> %08x\n", VidLocal.gamma_table));
746	>	WriteMacInt32(param + csGTable, VidLocal.gamma_table);
747	>	return noErr;
748
749		case cscGetDefaultMode:         // Get default color depth
750		D(bug(" GetDefaultMode -> %04x\n", VidLocal.preferred_mode));
751		WriteMacInt16(param + csMode, VidLocal.preferred_mode);
752		return noErr;
753
754	<	case cscGetCurMode:                     // Get current video mode (depth and resolution)
755	<	D(bug(" GetCurMode -> %04x/%08x\n", VidLocal.current_mode, VidLocal.current_id));
754	>	case cscGetCurrentMode:         // Get current video mode (depth and resolution)
755	>	D(bug(" GetCurMode -> %04x/%08x, base %08x\n", VidLocal.current_mode, VidLocal.current_id, VidLocal.desc->mac_frame_base));
756		WriteMacInt16(param + csMode, VidLocal.current_mode);
757		WriteMacInt32(param + csData, VidLocal.current_id);
758		WriteMacInt16(param + csPage, 0);
#	Line 371 | Line 761 | int16 VideoDriverStatus(uint32 pb, uint3
761
762		case cscGetConnection:          // Get monitor information
763		D(bug(" GetConnection\n"));
764	<	WriteMacInt16(param + csDisplayType, 6);                // 21" Multiscan
765	<	WriteMacInt8(param + csConnectTaggedType, 6);
766	<	WriteMacInt8(param + csConnectTaggedData, 0x23);
767	<	WriteMacInt32(param + csConnectFlags, 0x03);    // All modes valid and safe
764	>	WriteMacInt16(param + csDisplayType, 8);                // Modeless connection
765	>	WriteMacInt8(param + csConnectTaggedType, 0);
766	>	WriteMacInt8(param + csConnectTaggedData, 0);
767	>	WriteMacInt32(param + csConnectFlags, 0x43);    // All modes valid and safe, non-standard tagging
768		WriteMacInt32(param + csDisplayComponent, 0);
769		return noErr;
770
771	+	case cscGetModeTiming: {        // Get video timing for specified resolution
772	+	uint32 id = ReadMacInt32(param + csTimingMode);
773	+	D(bug(" GetModeTiming %08x\n", id));
774	+	if (!has_resolution(id))
775	+	return paramErr;
776	+
777	+	WriteMacInt32(param + csTimingFormat, FOURCC('d', 'e', 'c', 'l'));
778	+	WriteMacInt32(param + csTimingData, 0); // unknown
779	+	uint32 flags = 0xb; // mode valid, safe and shown in Monitors panel
780	+	if (id == VidLocal.preferred_id)
781	+	flags |= 4; // default mode
782	+	WriteMacInt32(param + csTimingFlags, flags);
783	+	return noErr;
784	+	}
785	+
786		case cscGetModeBaseAddress:     // Get frame buffer base address
787	<	D(bug(" GetModeBaseAddress -> %08x\n", VidLocal.desc->mac_frame_base));
788	<	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);       // Base address of video RAM for the current DisplayModeID and relative bit depth
787	>	D(bug(" GetModeBaseAddress -> base %08x\n", VidLocal.desc->mac_frame_base));
788	>	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
789		return noErr;
790
791		case cscGetPreferredConfiguration: // Get default video mode (depth and resolution)
#	Line 427 | Line 832 | int16 VideoDriverStatus(uint32 pb, uint3
832		WriteMacInt32(param + csVerticalLines, y);
833		WriteMacInt32(param + csRefreshRate, 75 << 16);
834		WriteMacInt16(param + csMaxDepthMode, DepthToAppleMode(max_depth_of_resolution(id)));
430	–	uint32 flags = 0xb; // mode valid, safe and shown in Monitors panel
431	–	if (id == VidLocal.preferred_id)
432	–	flags |= 4; // default mode
433	–	WriteMacInt32(param + csResolutionFlags, flags);
835		return noErr;
836		}
837
#	Line 438 | Line 839 | int16 VideoDriverStatus(uint32 pb, uint3
839		uint32 id = ReadMacInt32(param + csDisplayModeID);
840		uint16 mode = ReadMacInt16(param + csDepthMode);
841		D(bug(" GetVideoParameters %04x/%08x\n", mode, id));
842	+	VidLocal.dm_present = true;     // Display Manager seems to be present
843
844	<	vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
845	<	while (i != end) {
844	>	vector<video_mode>::const_iterator i, end = VideoModes.end();
845	>	for (i = VideoModes.begin(); i != end; ++i) {
846		if (DepthToAppleMode(i->depth) == mode && i->resolution_id == id) {
847		uint32 vp = ReadMacInt32(param + csVPBlockPtr);
848		WriteMacInt32(vp + vpBaseOffset, 0);
#	Line 452 | Line 854 | int16 VideoDriverStatus(uint32 pb, uint3
854		WriteMacInt16(vp + vpVersion, 0);
855		WriteMacInt16(vp + vpPackType, 0);
856		WriteMacInt32(vp + vpPackSize, 0);
857	<	WriteMacInt32(vp + vpHRes, 0x00480000);
857	>	WriteMacInt32(vp + vpHRes, 0x00480000); // 72 dpi
858		WriteMacInt32(vp + vpVRes, 0x00480000);
859		uint32 pix_type, pix_size, cmp_count, cmp_size, dev_type;
860		switch (i->depth) {
#	Line 495 | Line 897 | int16 VideoDriverStatus(uint32 pb, uint3
897		WriteMacInt32(param + csDeviceType, dev_type);
898		return noErr;
899		}
498	–	++i;
900		}
901		return paramErr; // specified resolution/depth not supported
902		}
903
503	–	case cscGetModeTiming: {        // Get video timing for specified resolution
504	–	uint32 id = ReadMacInt32(param + csTimingMode);
505	–	D(bug(" GetModeTiming %08x\n", id));
506	–	if (!has_resolution(id))
507	–	return paramErr;
508	–
509	–	WriteMacInt32(param + csTimingFormat, FOURCC('d', 'e', 'c', 'l'));
510	–	WriteMacInt32(param + csTimingData, 0); // unknown
511	–	uint32 flags = 0xb; // mode valid, safe and shown in Monitors panel
512	–	if (id == VidLocal.preferred_id)
513	–	flags |= 4; // default mode
514	–	WriteMacInt32(param + csTimingFlags, flags);
515	–	return noErr;
516	–	}
517	–
904		default:
905		printf("WARNING: Unknown VideoDriverStatus(%d)\n", code);
906		return statusErr;

Diff Legend

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