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.4 by cebix, 2000-07-22T16:07:19Z vs.
Revision 1.22 by cebix, 2001-07-09T11:21:59Z

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

Diff Legend

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