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

Comparing BasiliskII/src/video.cpp (file contents):
Revision 1.15 by cebix, 2001-06-30T22:23:43Z vs.
Revision 1.21 by cebix, 2001-07-04T11:12:19Z

#	Line 40 \| Line 40
40
41
42		// List of supported video modes
43	<	std::vector<video_mode> VideoModes;
43	>	vector<video_mode> VideoModes;
44
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 sp; // Mac address of Slot Manager parameter block
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;
74	–	++i;
110		}
111		return false;
112		}
#	Line 81 \| 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;
90	–	++i;
125		}
126		return i;
127		}
#	Line 100 \| 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	<	std::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;
107	–	++i;
141		}
142		return m;
143		}
#	Line 116 \| 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	<	std::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
#	Line 139 \| Line 207 \| static void set_gray_palette(void)
207		VidLocal.palette[i * 3 + 1] = 127;
208		VidLocal.palette[i * 3 + 2] = 127;
209		}
210	<	video_set_palette(VidLocal.palette);
210	>	video_set_palette(VidLocal.palette, 256);
211		}
212
213
#	Line 182 \| Line 250 \| static void load_ramp_palette(void)
250		*p++ = blue;
251		}
252
253	<	video_set_palette(VidLocal.palette);
253	>	video_set_palette(VidLocal.palette, num);
254		}
255
256
#	Line 265 \| Line 333 \| static bool set_gamma_table(uint32 user_
333		Mac2Mac_memcpy(table, user_table, size);
334		}
335
336	<	if (IsDirectMode(VidLocal.current_mode))
336	>	if (IsDirectMode(VidLocal.desc->mode))
337		load_ramp_palette();
338
339		return true;
#	Line 273 \| Line 341 \| static bool set_gamma_table(uint32 user_
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	+	WriteMacInt32(0x898, frame_base); // CrsrBase
413	+	uint32 gdev = ReadMacInt32(0x8a4); // MainDevice
414	+	gdev = ReadMacInt32(gdev);
415	+	uint32 pmap = ReadMacInt32(gdev + 0x16); // gdPMap
416	+	pmap = ReadMacInt32(pmap);
417	+	WriteMacInt32(pmap, frame_base); // baseAddr
418	+	}
419	+	}
420	+
421	+
422	+	/*
423		* Driver Open() routine
424		*/
425
#	Line 292 \| Line 439 \| int16 VideoDriverOpen(uint32 pb, uint32
439		VidLocal.current_id = VidLocal.desc->mode.resolution_id;
440		VidLocal.preferred_mode = VidLocal.current_mode;
441		VidLocal.preferred_id = VidLocal.current_id;
442	+	VidLocal.dm_present = false;
443
444		// Allocate Slot Manager parameter block in Mac RAM
445		M68kRegisters r;
#	Line 299 \| Line 447 \| int16 VideoDriverOpen(uint32 pb, uint32
447		Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
448		if (r.a[0] == 0)
449		return memFullErr;
450	<	VidLocal.sp = r.a[0];
451	<	D(bug("SPBlock at %08x\n", VidLocal.sp));
450	>	VidLocal.slot_param = r.a[0];
451	>	D(bug("SPBlock at %08x\n", VidLocal.slot_param));
452
453		// Find and set default gamma table
454		VidLocal.gamma_table = 0;
#	Line 335 \| Line 483 \| int16 VideoDriverControl(uint32 pb, uint
483		return paramErr;
484
485		if (mode != VidLocal.current_mode) {
486	<	std::vector<video_mode>::const_iterator i = find_mode(mode, VidLocal.current_id);
486	>	vector<video_mode>::const_iterator i = find_mode(mode, VidLocal.current_id);
487		if (i == VideoModes.end())
488		return paramErr;
489	<	set_gray_palette();
342	<	video_switch_to_mode(*i);
343	<	VidLocal.current_mode = mode;
344	<	WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base);
345	<	WriteMacInt32(dce + dCtlDevBase, VidLocal.desc->mac_frame_base);
489	>	switch_mode(*i, param, dce);
490		}
491		D(bug(" base %08x\n", VidLocal.desc->mac_frame_base));
492		return noErr;
#	Line 351 \| Line 495 \| int16 VideoDriverControl(uint32 pb, uint
495		case cscSetEntries: // Set palette
496		case cscDirectSetEntries: {
497		D(bug(" (Direct)SetEntries table %08x, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart)));
498	<	bool is_direct = IsDirectMode(VidLocal.current_mode);
498	>	bool is_direct = IsDirectMode(VidLocal.desc->mode);
499		if (code == cscSetEntries && is_direct)
500		return controlErr;
501		if (code == cscDirectSetEntries && !is_direct)
#	Line 423 \| Line 567 \| int16 VideoDriverControl(uint32 pb, uint
567		s_pal += 8;
568		}
569		}
570	<	video_set_palette(VidLocal.palette);
570	>	video_set_palette(VidLocal.palette, palette_size(VidLocal.desc->mode.depth));
571		return noErr;
572		}
573
#	Line 446 \| Line 590 \| int16 VideoDriverControl(uint32 pb, uint
590		0xffff0000, // 16 bpp
591		0xffffffff // 32 bpp
592		};
593	<	uint32 p = VidLocal.desc->mac_frame_base;
593	>	uint32 frame_base = VidLocal.desc->mac_frame_base;
594		uint32 pat = pattern[VidLocal.desc->mode.depth];
595		bool invert = (VidLocal.desc->mode.depth == VDEPTH_32BIT);
596		for (uint32 y=0; y<VidLocal.desc->mode.y; y++) {
597		for (uint32 x=0; x<VidLocal.desc->mode.bytes_per_row; x+=4) {
598	<	WriteMacInt32(p + x, pat);
598	>	WriteMacInt32(frame_base + x, pat);
599		if (invert)
600		pat = ~pat;
601		}
602	<	p += VidLocal.desc->mode.bytes_per_row;
602	>	frame_base += VidLocal.desc->mode.bytes_per_row;
603		pat = ~pat;
604		}
605
606	<	if (IsDirectMode(VidLocal.current_mode))
606	>	if (IsDirectMode(VidLocal.desc->mode))
607		load_ramp_palette();
608
609		return noErr;
#	Line 476 \| Line 620 \| int16 VideoDriverControl(uint32 pb, uint
620		return noErr;
621
622		case cscSetDefaultMode: { // Set default color depth
623	<	uint16 mode = ReadMacInt16(param + csMode);
624	<	D(bug(" SetDefaultMode %04x\n", mode));
623	>	uint16 mode = ReadMacInt8(param + csMode);
624	>	D(bug(" SetDefaultMode %02x\n", mode));
625		VidLocal.preferred_mode = mode;
626		return noErr;
627		}
#	Line 494 \| Line 638 \| int16 VideoDriverControl(uint32 pb, uint
638		return paramErr;
639
640		if (mode != VidLocal.current_mode \|\| id != VidLocal.current_id) {
641	<	std::vector<video_mode>::const_iterator i = find_mode(mode, id);
641	>	vector<video_mode>::const_iterator i = find_mode(mode, id);
642		if (i == VideoModes.end())
643		return paramErr;
644	<	set_gray_palette();
501	<	video_switch_to_mode(*i);
502	<	VidLocal.current_mode = mode;
503	<	VidLocal.current_id = id;
504	<	uint32 frame_base = VidLocal.desc->mac_frame_base;
505	<	WriteMacInt32(param + csBaseAddr, frame_base);
506	<
507	<	M68kRegisters r;
508	<	uint32 sp = VidLocal.sp;
509	<	r.a[0] = sp;
510	<
511	<	// Find functional sResource for this display
512	<	WriteMacInt8(sp + spSlot, ReadMacInt8(dce + dCtlSlot));
513	<	WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId));
514	<	WriteMacInt8(sp + spExtDev, 0);
515	<	r.d[0] = 0x0016;
516	<	Execute68kTrap(0xa06e, &r); // SRsrcInfo()
517	<	uint32 rsrc = ReadMacInt32(sp + spPointer);
518	<
519	<	// Patch minorBase (otherwise rebooting won't work)
520	<	WriteMacInt8(sp + spID, 0x0a); // minorBase
521	<	r.d[0] = 0x0006;
522	<	Execute68kTrap(0xa06e, &r); // SFindStruct()
523	<	uint32 minor_base = ReadMacInt32(sp + spPointer) - ROMBaseMac;
524	<	ROMBaseHost[minor_base + 0] = frame_base >> 24;
525	<	ROMBaseHost[minor_base + 1] = frame_base >> 16;
526	<	ROMBaseHost[minor_base + 2] = frame_base >> 8;
527	<	ROMBaseHost[minor_base + 3] = frame_base;
528	<
529	<	// Patch video mode parameter table
530	<	WriteMacInt32(sp + spPointer, rsrc);
531	<	WriteMacInt8(sp + spID, mode);
532	<	r.d[0] = 0x0006;
533	<	Execute68kTrap(0xa06e, &r); // SFindStruct()
534	<	WriteMacInt8(sp + spID, 0x01);
535	<	r.d[0] = 0x0006;
536	<	Execute68kTrap(0xa06e, &r); // SFindStruct()
537	<	uint32 p = ReadMacInt32(sp + spPointer) - ROMBaseMac;
538	<	ROMBaseHost[p + 8] = i->bytes_per_row >> 8;
539	<	ROMBaseHost[p + 9] = i->bytes_per_row;
540	<	ROMBaseHost[p + 14] = i->y >> 8;
541	<	ROMBaseHost[p + 15] = i->y;
542	<	ROMBaseHost[p + 16] = i->x >> 8;
543	<	ROMBaseHost[p + 17] = i->x;
544	<
545	<	// Recalculate slot ROM checksum
546	<	ChecksumSlotROM();
547	<
548	<	// Update sResource
549	<	WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId));
550	<	r.d[0] = 0x002b;
551	<	Execute68kTrap(0xa06e, &r); // SUpdateSRT()
552	<
553	<	// Update frame buffer base in DCE
554	<	WriteMacInt32(dce + dCtlDevBase, frame_base);
644	>	switch_mode(*i, param, dce);
645		}
646		D(bug(" base %08x\n", VidLocal.desc->mac_frame_base));
647		return noErr;
#	Line 644 \| Line 734 \| int16 VideoDriverStatus(uint32 pb, uint3
734
735		case cscGetGray: // Get luminance mapping flag
736		D(bug(" GetGray -> %d\n", VidLocal.luminance_mapping));
737	<	WriteMacInt16(param, VidLocal.luminance_mapping ? 0x0100 : 0);
737	>	WriteMacInt8(param, VidLocal.luminance_mapping ? 1 : 0);
738		return noErr;
739
740		case cscGetInterrupt: // Get interrupt disable flag
741		D(bug(" GetInterrupt -> %d\n", VidLocal.interrupts_enabled));
742	<	WriteMacInt16(param, VidLocal.interrupts_enabled ? 0 : 0x0100);
742	>	WriteMacInt8(param, VidLocal.interrupts_enabled ? 0 : 1);
743		return noErr;
744
745		case cscGetGamma:
#	Line 658 \| Line 748 \| int16 VideoDriverStatus(uint32 pb, uint3
748		return noErr;
749
750		case cscGetDefaultMode: // Get default color depth
751	<	D(bug(" GetDefaultMode -> %04x\n", VidLocal.preferred_mode));
752	<	WriteMacInt16(param + csMode, VidLocal.preferred_mode);
751	>	D(bug(" GetDefaultMode -> %02x\n", VidLocal.preferred_mode));
752	>	WriteMacInt8(param + csMode, VidLocal.preferred_mode);
753		return noErr;
754
755		case cscGetCurrentMode: // Get current video mode (depth and resolution)
#	Line 743 \| Line 833 \| int16 VideoDriverStatus(uint32 pb, uint3
833		WriteMacInt32(param + csVerticalLines, y);
834		WriteMacInt32(param + csRefreshRate, 75 << 16);
835		WriteMacInt16(param + csMaxDepthMode, DepthToAppleMode(max_depth_of_resolution(id)));
836	+	WriteMacInt32(param + csResolutionFlags, 0);
837		return noErr;
838		}
839
#	Line 750 \| Line 841 \| int16 VideoDriverStatus(uint32 pb, uint3
841		uint32 id = ReadMacInt32(param + csDisplayModeID);
842		uint16 mode = ReadMacInt16(param + csDepthMode);
843		D(bug(" GetVideoParameters %04x/%08x\n", mode, id));
844	+	VidLocal.dm_present = true; // Display Manager seems to be present
845
846	<	std::vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
847	<	while (i != end) {
846	>	vector<video_mode>::const_iterator i, end = VideoModes.end();
847	>	for (i = VideoModes.begin(); i != end; ++i) {
848		if (DepthToAppleMode(i->depth) == mode && i->resolution_id == id) {
849		uint32 vp = ReadMacInt32(param + csVPBlockPtr);
850		WriteMacInt32(vp + vpBaseOffset, 0);
#	Line 807 \| Line 899 \| int16 VideoDriverStatus(uint32 pb, uint3
899		WriteMacInt32(param + csDeviceType, dev_type);
900		return noErr;
901		}
810	–	++i;
902		}
903		return paramErr; // specified resolution/depth not supported
904		}
905
906	+	case cscGetMultiConnect: {
907	+	uint32 conn = ReadMacInt32(param + csDisplayCountOrNumber);
908	+	D(bug(" GetMultiConnect %08x\n", conn));
909	+	if (conn == 0xffffffff) { // Get number of connections
910	+	WriteMacInt32(param + csDisplayCountOrNumber, 1); // Single-headed
911	+	return noErr;
912	+	} else if (conn == 1) { // Get information about first connection
913	+	WriteMacInt16(param + csConnectInfo + csDisplayType, 8); // Modeless connection
914	+	WriteMacInt8(param + csConnectInfo + csConnectTaggedType, 0);
915	+	WriteMacInt8(param + csConnectInfo + csConnectTaggedData, 0);
916	+	WriteMacInt32(param + csConnectInfo + csConnectFlags, 0x43); // All modes valid and safe, non-standard tagging
917	+	WriteMacInt32(param + csConnectInfo + csDisplayComponent, 0);
918	+	return noErr;
919	+	} else
920	+	return paramErr;
921	+	}
922	+
923		default:
924		printf("WARNING: Unknown VideoDriverStatus(%d)\n", code);
925		return statusErr;

Diff Legend

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

Comparing BasiliskII/src/video.cpp (file contents): Revision 1.15 by cebix, 2001-06-30T22:23:43Z vs. Revision 1.21 by cebix, 2001-07-04T11:12:19Z

Diff Legend

Comparing BasiliskII/src/video.cpp (file contents):
Revision 1.15 by cebix, 2001-06-30T22:23:43Z vs.
Revision 1.21 by cebix, 2001-07-04T11:12:19Z