ViewVC Help

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

root/cebix/BasiliskII/src/AmigaOS/video_amiga.cpp

Comparing BasiliskII/src/AmigaOS/video_amiga.cpp (file contents):
Revision 1.14 by cebix, 2001-06-27T20:05:29Z vs.
Revision 1.20 by jlachmann, 2001-10-14T18:00:44Z

#	Line 62 | Line 62 | static UWORD *null_pointer = NULL;                             //
62		static UWORD *current_pointer = (UWORD *)-1;    // Currently visible mouse pointer data
63		static LONG black_pen = -1, white_pen = -1;
64		static struct Process *periodic_proc = NULL;    // Periodic process
65	+	static int window_width, window_height;         // width and height for window display
66	+	static ULONG screen_mode_id;                    // mode ID for screen display
67
68		extern struct Task *MainTask;                                   // Pointer to main task (from main_amiga.cpp)
69
#	Line 88 | Line 90 | static const uint8 keycode2mac[0x80] = {
90
91
92		// Prototypes
93	+	static bool video_open(const video_mode &mode);
94	+	static void video_close();
95		static void periodic_func(void);
96	+	static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth);
97	+	static void add_modes(uint32 width, uint32 height, video_depth depth);
98	+	static ULONG find_mode_for_depth(uint32 width, uint32 height, uint32 depth);
99	+	static ULONG bits_from_depth(video_depth depth);
100
101
102		/*
103		*  Initialization
104		*/
105
98	–	// Add resolution to list of supported modes and set VideoMonitor
99	–	static void set_video_monitor(uint32 width, uint32 height, uint32 bytes_per_row, int depth)
100	–	{
101	–	video_mode mode;
102	–
103	–	mode.x = width;
104	–	mode.y = height;
105	–	mode.resolution_id = 0x80;
106	–	mode.bytes_per_row = bytes_per_row;
107	–
108	–	switch (depth) {
109	–	case 1:
110	–	mode.depth = VDEPTH_1BIT;
111	–	break;
112	–	case 2:
113	–	mode.depth = VDEPTH_2BIT;
114	–	break;
115	–	case 4:
116	–	mode.depth = VDEPTH_4BIT;
117	–	break;
118	–	case 8:
119	–	mode.depth = VDEPTH_8BIT;
120	–	break;
121	–	case 15:
122	–	mode.depth = VDEPTH_16BIT;
123	–	break;
124	–	case 16:
125	–	mode.depth = VDEPTH_16BIT;
126	–	break;
127	–	case 24:
128	–	case 32:
129	–	mode.depth = VDEPTH_32BIT;
130	–	break;
131	–	}
132	–
133	–	VideoModes.push_back(mode);
134	–	VideoMonitor.mode = mode;
135	–	}
106
107		// Open window
108		static bool init_window(int width, int height)
#	Line 156 | Line 126 | static bool init_window(int width, int h
126		TAG_END
127		);
128		if (the_win == NULL) {
129	<	ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
129	>	ErrorAlert(STR_OPEN_WINDOW_ERR);
130		return false;
131		}
132
133		// Create bitmap ("height + 2" for safety)
134		the_bitmap = AllocBitMap(width, height + 2, 1, BMF_CLEAR, NULL);
135		if (the_bitmap == NULL) {
136	<	ErrorAlert(GetString(STR_NO_MEM_ERR));
136	>	ErrorAlert(STR_NO_MEM_ERR);
137		return false;
138		}
139
140		// Add resolution and set VideoMonitor
171	–	set_video_monitor(width, height, the_bitmap->BytesPerRow, 1);
141		VideoMonitor.mac_frame_base = (uint32)the_bitmap->Planes[0];
142
143		// Set FgPen and BgPen
#	Line 208 | Line 177 | static bool init_pip(int width, int heig
177		TAG_END
178		);
179		if (the_win == NULL || error) {
180	<	ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
180	>	ErrorAlert(STR_OPEN_WINDOW_ERR);
181		return false;
182		}
183
#	Line 216 | Line 185 | static bool init_pip(int width, int heig
185		p96PIP_GetTags(the_win, P96PIP_SourceBitMap, (ULONG)&the_bitmap, TAG_END);
186
187		// Add resolution and set VideoMonitor
219	–	set_video_monitor(width, height, p96GetBitMapAttr(the_bitmap, P96BMA_BYTESPERROW), 16);
188		VideoMonitor.mac_frame_base = p96GetBitMapAttr(the_bitmap, P96BMA_MEMORY);
189	+
190		return true;
191		}
192
#	Line 237 | Line 206 | static bool init_screen_p96(ULONG mode_i
206		case 15:
207		case 16:
208		if (format != RGBFB_R5G5B5) {
209	<	ErrorAlert(GetString(STR_WRONG_SCREEN_FORMAT_ERR));
209	>	ErrorAlert(STR_WRONG_SCREEN_FORMAT_ERR);
210		return false;
211		}
212		break;
213		case 24:
214		case 32:
215		if (format != RGBFB_A8R8G8B8) {
216	<	ErrorAlert(GetString(STR_WRONG_SCREEN_FORMAT_ERR));
216	>	ErrorAlert(STR_WRONG_SCREEN_FORMAT_ERR);
217		return false;
218		}
219		break;
220		default:
221	<	ErrorAlert(GetString(STR_WRONG_SCREEN_DEPTH_ERR));
221	>	ErrorAlert(STR_WRONG_SCREEN_DEPTH_ERR);
222		return false;
223		}
224
#	Line 268 | Line 237 | static bool init_screen_p96(ULONG mode_i
237		TAG_END
238		);
239		if (the_screen == NULL) {
240	<	ErrorAlert(GetString(STR_OPEN_SCREEN_ERR));
240	>	ErrorAlert(STR_OPEN_SCREEN_ERR);
241		return false;
242		}
243
#	Line 276 | Line 245 | static bool init_screen_p96(ULONG mode_i
245		the_win = OpenWindowTags(NULL,
246		WA_Left, 0, WA_Top, 0,
247		WA_Width, width, WA_Height, height,
248	+	WA_SimpleRefresh, TRUE,
249		WA_NoCareRefresh, TRUE,
250		WA_Borderless, TRUE,
251		WA_Activate, TRUE,
#	Line 285 | Line 255 | static bool init_screen_p96(ULONG mode_i
255		TAG_END
256		);
257		if (the_win == NULL) {
258	<	ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
258	>	ErrorAlert(STR_OPEN_WINDOW_ERR);
259		return false;
260		}
261
262		ScreenToFront(the_screen);
263
264		// Add resolution and set VideoMonitor
295	–	set_video_monitor(width, height, p96GetBitMapAttr(the_screen->RastPort.BitMap, P96BMA_BYTESPERROW), depth);
265		VideoMonitor.mac_frame_base = p96GetBitMapAttr(the_screen->RastPort.BitMap, P96BMA_MEMORY);
266	+
267		return true;
268		}
269
#	Line 314 | Line 284 | static bool init_screen_cgfx(ULONG mode_
284		case 16:
285		// !!! PIXFMT_RGB15 is correct !!!
286		if (format != PIXFMT_RGB15) {
287	<	ErrorAlert(GetString(STR_WRONG_SCREEN_FORMAT_ERR));
287	>	ErrorAlert(STR_WRONG_SCREEN_FORMAT_ERR);
288		return false;
289		}
290		break;
291		case 24:
292		case 32:
293		if (format != PIXFMT_ARGB32) {
294	<	ErrorAlert(GetString(STR_WRONG_SCREEN_FORMAT_ERR));
294	>	ErrorAlert(STR_WRONG_SCREEN_FORMAT_ERR);
295		return false;
296		}
297		break;
298		default:
299	<	ErrorAlert(GetString(STR_WRONG_SCREEN_DEPTH_ERR));
299	>	ErrorAlert(STR_WRONG_SCREEN_DEPTH_ERR);
300		return false;
301		}
302
#	Line 343 | Line 313 | static bool init_screen_cgfx(ULONG mode_
313		TAG_END
314		);
315		if (the_screen == NULL) {
316	<	ErrorAlert(GetString(STR_OPEN_SCREEN_ERR));
316	>	ErrorAlert(STR_OPEN_SCREEN_ERR);
317		return false;
318		}
319
#	Line 351 | Line 321 | static bool init_screen_cgfx(ULONG mode_
321		the_win = OpenWindowTags(NULL,
322		WA_Left, 0, WA_Top, 0,
323		WA_Width, width, WA_Height, height,
324	+	WA_SimpleRefresh, TRUE,
325		WA_NoCareRefresh, TRUE,
326		WA_Borderless, TRUE,
327		WA_Activate, TRUE,
#	Line 360 | Line 331 | static bool init_screen_cgfx(ULONG mode_
331		TAG_END
332		);
333		if (the_win == NULL) {
334	<	ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
334	>	ErrorAlert(STR_OPEN_WINDOW_ERR);
335		return false;
336		}
337
#	Line 375 | Line 346 | static bool init_screen_cgfx(ULONG mode_
346		TAG_END
347		);
348		UnLockBitMap(handle);
349	<	set_video_monitor(width, height, GetCyberMapAttr(the_screen->RastPort.BitMap, CYBRMATTR_XMOD), depth);
349	>
350		VideoMonitor.mac_frame_base = frame_base;
351	+
352		return true;
353		}
354
355		bool VideoInit(bool classic)
356		{
357	+	int default_width, default_height, default_depth;
358	+
359		// Allocate blank mouse pointer data
360		null_pointer = (UWORD *)AllocMem(12, MEMF_PUBLIC | MEMF_CHIP | MEMF_CLEAR);
361		if (null_pointer == NULL) {
362	<	ErrorAlert(GetString(STR_NO_MEM_ERR));
362	>	ErrorAlert(STR_NO_MEM_ERR);
363		return false;
364		}
365
#	Line 403 | Line 377 | bool VideoInit(bool classic)
377
378		// Determine type and mode
379		display_type = DISPLAY_WINDOW;
380	<	int width = 512, height = 384;
381	<	ULONG mode_id = 0;
380	>
381	>	default_width = window_width = 512;
382	>	default_height = window_height = 384;
383	>
384		if (mode_str) {
385	<	if (sscanf(mode_str, "win/%d/%d", &width, &height) == 2)
385	>	if (sscanf(mode_str, "win/%d/%d", &window_width, &window_height) == 2)
386		display_type = DISPLAY_WINDOW;
387	<	else if (sscanf(mode_str, "pip/%d/%d", &width, &height) == 2 && P96Base)
387	>	else if (sscanf(mode_str, "pip/%d/%d", &window_width, &window_height) == 2 && P96Base)
388		display_type = DISPLAY_PIP;
389	<	else if (sscanf(mode_str, "scr/%08lx", &mode_id) == 1 && (CyberGfxBase || P96Base)) {
390	<	if (P96Base && p96GetModeIDAttr(mode_id, P96IDA_ISP96))
389	>	else if (sscanf(mode_str, "scr/%08lx", &screen_mode_id) == 1 && (CyberGfxBase || P96Base)) {
390	>	if (P96Base && p96GetModeIDAttr(screen_mode_id, P96IDA_ISP96))
391		display_type = DISPLAY_SCREEN_P96;
392	<	else if (CyberGfxBase && IsCyberModeID(mode_id))
392	>	else if (CyberGfxBase && IsCyberModeID(screen_mode_id))
393		display_type = DISPLAY_SCREEN_CGFX;
394		else {
395	<	ErrorAlert(GetString(STR_NO_P96_MODE_ERR));
395	>	ErrorAlert(STR_NO_P96_MODE_ERR);
396		return false;
397		}
398		}
399		}
400
401	+	// Construct list of supported modes
402	+	switch (display_type) {
403	+	case DISPLAY_WINDOW:
404	+	default_width = window_width;
405	+	default_height = window_height;
406	+	default_depth = 1;
407	+	add_modes(window_width, window_height, VDEPTH_1BIT);
408	+	break;
409	+
410	+	case DISPLAY_PIP:
411	+	default_depth = 16;
412	+	default_width = window_width;
413	+	default_height = window_height;
414	+	add_modes(window_width, window_height, VDEPTH_16BIT);
415	+	break;
416	+
417	+	case DISPLAY_SCREEN_P96:
418	+	case DISPLAY_SCREEN_CGFX:
419	+	struct DimensionInfo dimInfo;
420	+	DisplayInfoHandle handle = FindDisplayInfo(screen_mode_id);
421	+
422	+	if (NULL == handle)
423	+	return false;
424	+
425	+	if (GetDisplayInfoData(handle, (UBYTE *) &dimInfo, sizeof(dimInfo), DTAG_DIMS, 0) <= 0)
426	+	return false;
427	+
428	+	default_width = 1 + dimInfo.Nominal.MaxX - dimInfo.Nominal.MinX;
429	+	default_height = 1 + dimInfo.Nominal.MaxY - dimInfo.Nominal.MinY;
430	+	default_depth = dimInfo.MaxDepth;
431	+
432	+	for (unsigned d=VDEPTH_1BIT; d<=VDEPTH_32BIT; d++)
433	+	{
434	+	if (INVALID_ID != find_mode_for_depth(default_width, default_height, bits_from_depth(video_depth(d))))
435	+	{
436	+	add_modes(default_width, default_height, video_depth(d));
437	+	}
438	+	}
439	+	break;
440	+	}
441	+
442	+	video_init_depth_list();
443	+
444	+	#if DEBUG
445	+	bug("Available video modes:\n");
446	+	vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
447	+	while (i != end) {
448	+	bug(" %dx%d (ID %02x), %d colors\n", i->x, i->y, i->resolution_id, 1 << bits_from_depth(i->depth));
449	+	++i;
450	+	}
451	+	#endif
452	+
453	+	D(bug("VideoInit: def_width=%ld  def_height=%ld  def_depth=%ld\n", default_width, default_height, default_depth));
454	+
455	+	// Find requested default mode and open display
456	+	if (VideoModes.size() == 1)
457	+	return video_open(VideoModes[0]);
458	+	else {
459	+	// Find mode with specified dimensions
460	+	std::vector<video_mode>::const_iterator i, end = VideoModes.end();
461	+	for (i = VideoModes.begin(); i != end; ++i)
462	+	{
463	+	D(bug("VideoInit: w=%ld  h=%ld  d=%ld\n", i->x, i->y, bits_from_depth(i->depth)));
464	+	if (i->x == default_width && i->y == default_height && bits_from_depth(i->depth) == default_depth)
465	+	return video_open(*i);
466	+	}
467	+	return video_open(VideoModes[0]);
468	+	}
469	+
470	+	return true;
471	+	}
472	+
473	+
474	+	static bool video_open(const video_mode &mode)
475	+	{
476	+	ULONG depth_bits = bits_from_depth(mode.depth);
477	+	ULONG ID = find_mode_for_depth(mode.x, mode.y, depth_bits);
478	+
479	+	D(bug("video_open: width=%ld  height=%ld  depth=%ld  ID=%08lx\n", mode.x, mode.y, depth_bits, ID));
480	+
481	+	if (INVALID_ID == ID)
482	+	{
483	+	ErrorAlert(STR_NO_VIDEO_MODE_ERR);
484	+	return false;
485	+	}
486	+
487	+	VideoMonitor.mode = mode;
488	+
489		// Open display
490		switch (display_type) {
491		case DISPLAY_WINDOW:
492	<	if (!init_window(width, height))
492	>	if (!init_window(mode.x, mode.y))
493		return false;
494		break;
495
496		case DISPLAY_PIP:
497	<	if (!init_pip(width, height))
497	>	if (!init_pip(mode.x, mode.y))
498		return false;
499		break;
500
501		case DISPLAY_SCREEN_P96:
502	<	if (!init_screen_p96(mode_id))
502	>	if (!init_screen_p96(ID))
503		return false;
504		break;
505
506		case DISPLAY_SCREEN_CGFX:
507	<	if (!init_screen_cgfx(mode_id))
507	>	if (!init_screen_cgfx(ID))
508		return false;
509		break;
510		}
#	Line 453 | Line 517 | bool VideoInit(bool classic)
517		TAG_END
518		);
519		if (periodic_proc == NULL) {
520	<	ErrorAlert(GetString(STR_NO_MEM_ERR));
520	>	ErrorAlert(STR_NO_MEM_ERR);
521		return false;
522		}
523	+
524		return true;
525		}
526
527
528	<	/*
464	<	*  Deinitialization
465	<	*/
466	<
467	<	void VideoExit(void)
528	>	static void video_close()
529		{
530		// Stop periodic process
531		if (periodic_proc) {
#	Line 489 | Line 550 | void VideoExit(void)
550		ReleasePen(the_win->WScreen->ViewPort.ColorMap, white_pen);
551
552		CloseWindow(the_win);
553	+	the_win = NULL;
554		}
555		break;
556
#	Line 503 | Line 565 | void VideoExit(void)
565
566		// Close window
567		if (the_win)
568	+	{
569		CloseWindow(the_win);
570	+	the_win = NULL;
571	+	}
572
573		// Close screen
574		if (the_screen) {
#	Line 516 | Line 581 | void VideoExit(void)
581
582		// Close window
583		if (the_win)
584	+	{
585		CloseWindow(the_win);
586	+	the_win = NULL;
587	+	}
588
589		// Close screen
590		if (the_screen) {
#	Line 535 | Line 603 | void VideoExit(void)
603
604
605		/*
606	+	*  Deinitialization
607	+	*/
608	+
609	+	void VideoExit(void)
610	+	{
611	+	video_close();
612	+	}
613	+
614	+
615	+	/*
616		*  Set palette
617		*/
618
619	<	void video_set_palette(uint8 *pal)
619	>	void video_set_palette(uint8 *pal, int num)
620		{
621	<	if (display_type == DISPLAY_SCREEN_P96 || display_type == DISPLAY_SCREEN_CGFX) {
621	>	if ((display_type == DISPLAY_SCREEN_P96 || display_type == DISPLAY_SCREEN_CGFX)
622	>	&& !IsDirectMode(VideoMonitor.mode)) {
623
624		// Convert palette to 32 bits
625		ULONG table[2 + 256 * 3];
626	<	table[0] = 256 << 16;
627	<	table[256 * 3 + 1] = 0;
628	<	for (int i=0; i<256; i++) {
626	>	table[0] = num << 16;
627	>	table[num * 3 + 1] = 0;
628	>	for (int i=0; i<num; i++) {
629		table[i*3+1] = pal[i*3] * 0x01010101;
630		table[i*3+2] = pal[i*3+1] * 0x01010101;
631		table[i*3+3] = pal[i*3+2] * 0x01010101;
#	Line 564 | Line 643 | void video_set_palette(uint8 *pal)
643
644		void video_switch_to_mode(const video_mode &mode)
645		{
646	+	// Close and reopen display
647	+	video_close();
648	+	if (!video_open(mode))
649	+	{
650	+	ErrorAlert(STR_OPEN_WINDOW_ERR);
651	+	QuitEmulator();
652	+	}
653	+	}
654	+
655	+
656	+	/*
657	+	*  Close down full-screen mode (if bringing up error alerts is unsafe while in full-screen mode)
658	+	*/
659	+
660	+	void VideoQuitFullScreen(void)
661	+	{
662		}
663
664
#	Line 738 | Line 833 | static __saveds void periodic_func(void)
833		Forbid();
834		Signal(MainTask, SIGF_SINGLE);
835		}
836	+
837	+
838	+	// Add mode to list of supported modes
839	+	static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth)
840	+	{
841	+	video_mode mode;
842	+	mode.x = width;
843	+	mode.y = height;
844	+	mode.resolution_id = resolution_id;
845	+	mode.bytes_per_row = bytes_per_row;
846	+	mode.depth = depth;
847	+
848	+	D(bug("Added video mode: w=%ld  h=%ld  d=%ld\n", width, height, depth));
849	+
850	+	VideoModes.push_back(mode);
851	+	}
852	+
853	+	// Add standard list of windowed modes for given color depth
854	+	static void add_modes(uint32 width, uint32 height, video_depth depth)
855	+	{
856	+	D(bug("add_modes: w=%ld  h=%ld  d=%ld\n", width, height, depth));
857	+
858	+	if (width >= 512 && height >= 384)
859	+	add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth), depth);
860	+	if (width >= 640 && height >= 480)
861	+	add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth), depth);
862	+	if (width >= 800 && height >= 600)
863	+	add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth), depth);
864	+	if (width >= 1024 && height >= 768)
865	+	add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth), depth);
866	+	if (width >= 1152 && height >= 870)
867	+	add_mode(1152, 870, 0x84, TrivialBytesPerRow(1152, depth), depth);
868	+	if (width >= 1280 && height >= 1024)
869	+	add_mode(1280, 1024, 0x85, TrivialBytesPerRow(1280, depth), depth);
870	+	if (width >= 1600 && height >= 1200)
871	+	add_mode(1600, 1200, 0x86, TrivialBytesPerRow(1600, depth), depth);
872	+	}
873	+
874	+
875	+	static ULONG find_mode_for_depth(uint32 width, uint32 height, uint32 depth)
876	+	{
877	+	ULONG ID = BestModeID(BIDTAG_NominalWidth, width,
878	+	BIDTAG_NominalHeight, height,
879	+	BIDTAG_Depth, depth,
880	+	TAG_END);
881	+
882	+	return ID;
883	+	}
884	+
885	+
886	+	static ULONG bits_from_depth(video_depth depth)
887	+	{
888	+	int bits = 1 << depth;
889	+	if (bits == 16)
890	+	bits = 15;
891	+	else if (bits == 32)
892	+	bits = 24;
893	+
894	+	return bits;
895	+	}
896	+

Diff Legend

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