![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to svga.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to svga.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * SVGAlib interface.
5: *
6: * (c) 1995 Bernd Schmidt
7: */
8:
9: #include "sysconfig.h"
10: #include "sysdeps.h"
11:
12: #include <assert.h>
13: #include <ctype.h>
14: #include <signal.h>
15: #include <vga.h>
16: #include <vgamouse.h>
17: #include <vgakeyboard.h>
18:
19: #include "config.h"
20: #include "options.h"
21: #include "memory.h"
22: #include "custom.h"
23: #include "newcpu.h"
24: #include "keyboard.h"
25: #include "xwin.h"
26: #include "keybuf.h"
27: #include "gui.h"
28:
29: #define SCODE_CURSORBLOCKUP 103 /* Cursor key block. */
30: #define SCODE_CURSORBLOCKLEFT 105
31: #define SCODE_CURSORBLOCKRIGHT 106
32: #define SCODE_CURSORBLOCKDOWN 108
33:
34: #define SCODE_INSERT 110
35: #define SCODE_HOME 102
36: #define SCODE_PGUP 104
37: #define SCODE_DELETE 111
38: #define SCODE_END 107
39: #define SCODE_PGDN 109
40:
41: #define SCODE_KEYPAD0 82
42: #define SCODE_KEYPAD1 79
43: #define SCODE_KEYPAD2 80
44: #define SCODE_KEYPAD3 81
45: #define SCODE_KEYPAD4 75
46: #define SCODE_KEYPAD5 76
47: #define SCODE_KEYPAD6 77
48: #define SCODE_KEYPAD7 71
49: #define SCODE_KEYPAD8 72
50: #define SCODE_KEYPAD9 73
51: #define SCODE_KEYPADENTER 96
52: #define SCODE_KEYPADPLUS 78
53: #define SCODE_KEYPADMINUS 74
54:
55: #define SCODE_Q 16
56: #define SCODE_W 17
57: #define SCODE_E 18
58: #define SCODE_R 19
59: #define SCODE_T 20
60: #define SCODE_Y 21
61: #define SCODE_U 22
62: #define SCODE_I 23
63: #define SCODE_O 24
64: #define SCODE_P 25
65:
66: #define SCODE_A 30
67: #define SCODE_S 31
68: #define SCODE_D 32
69: #define SCODE_F 33
70: #define SCODE_G 34
71: #define SCODE_H 35
72: #define SCODE_J 36
73: #define SCODE_K 37
74: #define SCODE_L 38
75:
76: #define SCODE_Z 44
77: #define SCODE_X 45
78: #define SCODE_C 46
79: #define SCODE_V 47
80: #define SCODE_B 48
81: #define SCODE_N 49
82: #define SCODE_M 50
83:
84: #define SCODE_ESCAPE 1
85: #define SCODE_ENTER 28
86: #define SCODE_RIGHTCONTROL 97
87: #define SCODE_CONTROL 97
88: #define SCODE_RIGHTALT 100
89: #define SCODE_LEFTCONTROL 29
90: #define SCODE_LEFTALT 56
91: #define SCODE_SPACE 57
92:
93: #define SCODE_F1 59
94: #define SCODE_F2 60
95: #define SCODE_F3 61
96: #define SCODE_F4 62
97: #define SCODE_F5 63
98: #define SCODE_F6 64
99: #define SCODE_F7 65
100: #define SCODE_F8 66
101: #define SCODE_F9 67
102: #define SCODE_F10 68
103:
104: #define SCODE_0 11
105: #define SCODE_1 2
106: #define SCODE_2 3
107: #define SCODE_3 4
108: #define SCODE_4 5
109: #define SCODE_5 6
110: #define SCODE_6 7
111: #define SCODE_7 8
112: #define SCODE_8 9
113: #define SCODE_9 10
114:
115: #define SCODE_LEFTSHIFT 42
116: #define SCODE_RIGHTSHIFT 54
117: #define SCODE_TAB 15
118:
119: #define SCODE_F11 87
120: #define SCODE_F12 88
121: #define SCODE_NEXT 81
122: #define SCODE_PRIOR 73
123: #define SCODE_BS 14
124: /*
125: #define SCODE_asciicircum 1
126: */
127: #define SCODE_bracketleft 26
128: #define SCODE_bracketright 27
129: #define SCODE_comma 51
130: #define SCODE_period 52
131: #define SCODE_slash 53
132: #define SCODE_semicolon 39
133: #define SCODE_grave 40
134: #define SCODE_minus 12
135: #define SCODE_equal 13
136: #define SCODE_numbersign 43
137: #define SCODE_ltgt 86
138: #define SCODE_scrolllock 70
139:
140: #define SCODE_LWIN95 125
141: #define SCODE_RWIN95 126
142: #define SCODE_MWIN95 127
143:
144: void setup_brkhandler(void)
145: {
146: }
147:
148: static int vsize, bitdepth, bit_unit, using_linear;
149: static vga_modeinfo modeinfo;
150: static char *linear_mem = NULL;
151: static int need_dither;
152: static int x_size = 0, vidmode_linewidth;
153:
154: static UBYTE dither_buf[1000]; /* I hate having to think about array bounds */
155:
156: xcolnr xcolors[4096];
157:
158: struct vidbuf_description gfxvidinfo;
159:
160: static int x_size_table[MAX_SCREEN_MODES+1] = { 320, 320, 320, 640, 800 };
161:
162: static int vga_mode_table[MAX_SCREEN_MODES+1][MAX_COLOR_MODES+1] =
163: { { G320x200x256, G320x200x32K, G320x200x64K, G320x200x256, G320x200x16, G320x200x16M32 },
164: { G320x240x256, -1, -1, G320x240x256, -1, -1 },
165: { G320x400x256, -1, -1, G320x400x256, -1, -1 },
166: { G640x480x256, G640x480x32K, G640x480x64K, G640x480x256, G640x480x16, G640x480x16M32 },
167: { G800x600x256, G800x600x32K, G800x600x64K, G800x600x256, G800x600x16, G800x600x16M32 } };
168:
169: static int mode_bitdepth[MAX_COLOR_MODES+1][3] =
170: { { 8, 8, 0 }, { 15, 16, 0 }, { 16, 16, 0 }, { 8, 8, 1 }, { 4, 8, 1 }, { 24, 32, 0 } };
171:
172: void flush_line(int y)
173: {
174: int target_y = y;
175:
176: if (screen_res < 2)
177: target_y -= 8;
178: if (linear_mem == NULL) {
179: char *addr = gfxvidinfo.bufmem + y*gfxvidinfo.rowbytes;
180: if (target_y < modeinfo.height && target_y >= 0) {
181: if (need_dither) {
182: DitherLine(dither_buf, (UWORD *)addr, 0, y, x_size, bit_unit);
183: addr = dither_buf;
184: }
185: vga_drawscanline(target_y, addr);
186: }
187: } else {
188: if (need_dither && target_y >= 0) {
189: char *addr = gfxvidinfo.bufmem + y*gfxvidinfo.rowbytes;
190: DitherLine(linear_mem + vidmode_linewidth * target_y, (UWORD *)addr, 0, y, x_size, bit_unit);
191: }
192: }
193: }
194:
195: void flush_block(int a, int b)
196: {
197: abort();
198: }
199:
200: void flush_screen(int a, int b)
201: {
202: }
203:
204: void calc_adjustment(void)
205: {
206: switch (screen_res) {
207: case 0: case 1: case 2: /* LoRes, 320xfoo */
208: gfxvidinfo.x_adjust = prev_max_diwstop - 320;
209: break;
210:
211: case 3: /* 640xbar */
212: gfxvidinfo.x_adjust = prev_max_diwstop - 640;
213: break;
214: default:
215: gfxvidinfo.x_adjust = 0;
216: break;
217: }
218: }
219:
220: static int colors_allocated;
221:
222: static int get_color(int r, int g, int b, xcolnr *cnp)
223: {
224: if (colors_allocated == 256)
225: return -1;
226: *cnp = colors_allocated;
227: vga_setpalette(colors_allocated, doMask(r, 6, 0), doMask(g, 6, 0), doMask(b, 6, 0));
228: colors_allocated++;
229: return 1;
230: }
231:
232: static void init_colors(void)
233: {
234: if (need_dither) {
235: setup_dither(bitdepth, get_color);
236: } else {
237: int rw = 5, gw = 5, bw = 5;
238: colors_allocated = 0;
239: if (color_mode == 2) gw = 6;
240:
241: switch (gfxvidinfo.pixbytes) {
242: case 4:
243: alloc_colors64k(8, 8, 8, 16, 8, 0);
244: break;
245: case 2:
246: alloc_colors64k(rw, gw, bw, gw+bw, bw, 0);
247: break;
248: case 1:
249: alloc_colors256(get_color);
250: break;
251: default:
252: abort();
253: }
254: }
255: }
256:
257: int buttonstate[3] = { 0, 0, 0 };
258: int lastmx, lastmy;
259: int newmousecounters = 0;
260:
261: static int keystate[256];
262:
263: static int scancode2amiga(int scancode)
264: {
265: switch(scancode) {
266: case SCODE_A: return AK_A;
267: case SCODE_B: return AK_B;
268: case SCODE_C: return AK_C;
269: case SCODE_D: return AK_D;
270: case SCODE_E: return AK_E;
271: case SCODE_F: return AK_F;
272: case SCODE_G: return AK_G;
273: case SCODE_H: return AK_H;
274: case SCODE_I: return AK_I;
275: case SCODE_J: return AK_J;
276: case SCODE_K: return AK_K;
277: case SCODE_L: return AK_L;
278: case SCODE_M: return AK_M;
279: case SCODE_N: return AK_N;
280: case SCODE_O: return AK_O;
281: case SCODE_P: return AK_P;
282: case SCODE_Q: return AK_Q;
283: case SCODE_R: return AK_R;
284: case SCODE_S: return AK_S;
285: case SCODE_T: return AK_T;
286: case SCODE_U: return AK_U;
287: case SCODE_V: return AK_V;
288: case SCODE_W: return AK_W;
289: case SCODE_X: return AK_X;
290: case SCODE_Y: return AK_Y;
291: case SCODE_Z: return AK_Z;
292:
293: case SCODE_0: return AK_0;
294: case SCODE_1: return AK_1;
295: case SCODE_2: return AK_2;
296: case SCODE_3: return AK_3;
297: case SCODE_4: return AK_4;
298: case SCODE_5: return AK_5;
299: case SCODE_6: return AK_6;
300: case SCODE_7: return AK_7;
301: case SCODE_8: return AK_8;
302: case SCODE_9: return AK_9;
303:
304: case SCODE_KEYPAD0: return AK_NP0;
305: case SCODE_KEYPAD1: return AK_NP1;
306: case SCODE_KEYPAD2: return AK_NP2;
307: case SCODE_KEYPAD3: return AK_NP3;
308: case SCODE_KEYPAD4: return AK_NP4;
309: case SCODE_KEYPAD5: return AK_NP5;
310: case SCODE_KEYPAD6: return AK_NP6;
311: case SCODE_KEYPAD7: return AK_NP7;
312: case SCODE_KEYPAD8: return AK_NP8;
313: case SCODE_KEYPAD9: return AK_NP9;
314:
315: case SCODE_F1: return AK_F1;
316: case SCODE_F2: return AK_F2;
317: case SCODE_F3: return AK_F3;
318: case SCODE_F4: return AK_F4;
319: case SCODE_F5: return AK_F5;
320: case SCODE_F6: return AK_F6;
321: case SCODE_F7: return AK_F7;
322: case SCODE_F8: return AK_F8;
323: case SCODE_F9: return AK_F9;
324: case SCODE_F10: return AK_F10;
325:
326: case SCODE_BS: return AK_BS;
327: case SCODE_LEFTCONTROL: return AK_CTRL;
328: case SCODE_RIGHTCONTROL: return AK_CTRL;
329: case SCODE_TAB: return AK_TAB;
330: case SCODE_LEFTALT: return AK_LALT;
331: case SCODE_RIGHTALT: return AK_RALT;
332: case SCODE_ENTER: return AK_RET;
333: case SCODE_SPACE: return AK_SPC;
334: case SCODE_LEFTSHIFT: return AK_LSH;
335: case SCODE_RIGHTSHIFT: return AK_RSH;
336: case SCODE_ESCAPE: return AK_ESC;
337:
338: case SCODE_INSERT:
339: case SCODE_END:
340: case SCODE_HOME: break;
341:
342: case SCODE_DELETE: return AK_DEL;
343: case SCODE_CURSORBLOCKUP: return AK_UP;
344: case SCODE_CURSORBLOCKDOWN: return AK_DN;
345: case SCODE_CURSORBLOCKLEFT: return AK_LF;
346: case SCODE_CURSORBLOCKRIGHT: return AK_RT;
347:
348: case SCODE_F11: return AK_BACKSLASH;
349: /*
350: case SCODE_asciicircum: return AK_00;
351: */
352: case SCODE_bracketleft: return AK_LBRACKET;
353: case SCODE_bracketright: return AK_RBRACKET;
354: case SCODE_comma: return AK_COMMA;
355: case SCODE_period: return AK_PERIOD;
356: case SCODE_slash: return AK_SLASH;
357: case SCODE_semicolon: return AK_SEMICOLON;
358: case SCODE_grave: return AK_QUOTE;
359: case SCODE_minus: return AK_MINUS;
360: case SCODE_equal: return AK_EQUAL;
361:
362: /* This one turns off screen updates. */
363: case SCODE_scrolllock: return AK_inhibit;
364:
365: case SCODE_PGUP: case SCODE_RWIN95: return AK_RAMI;
366: case SCODE_PGDN: case SCODE_LWIN95: return AK_LAMI;
367:
368: /*#ifdef KBD_LANG_DE*/
369: case SCODE_numbersign: return AK_NUMBERSIGN;
370: case SCODE_ltgt: return AK_LTGT;
371: /*#endif*/
372: }
373: return -1;
374: }
375:
376: static void my_kbd_handler(int scancode, int newstate)
377: {
378: int akey = scancode2amiga(scancode);
379:
380: assert(scancode >= 0 && scancode < 0x100);
381: if (scancode == SCODE_F12) {
382: regs.spcflags |= SPCFLAG_BRK;
383: quit_program = 1;
384: }
385: if (keystate[scancode] == newstate)
386: return;
387: keystate[scancode] = newstate;
388:
389: if (akey == -1) {
390: return;
391: }
392:
393: if (newstate == KEY_EVENTPRESS) {
394: if (akey == AK_inhibit)
395: inhibit_frame ^= 1;
396: else
397: record_key (akey << 1);
398: } else
399: record_key ((akey << 1) | 1);
400:
401: /* "Affengriff" */
402: if(keystate[AK_CTRL] && keystate[AK_LAMI] && keystate[AK_RAMI])
403: m68k_reset();
404: }
405:
406: int graphics_init(void)
407: {
408: int i;
409: int vgamode;
410:
411: need_dither = 0;
412: using_linear = 0;
413:
414: if (screen_res < 3)
415: correct_aspect = 0;
416:
417: vgamode = vga_mode_table[screen_res][color_mode];
418: if (vgamode == -1) {
419: fprintf(stderr, "Sorry, this combination of color and video mode is not supported.\n");
420: return 0;
421: }
422:
423: bitdepth = mode_bitdepth[color_mode][0];
424: bit_unit = mode_bitdepth[color_mode][1];
425: need_dither = mode_bitdepth[color_mode][2];
426: x_size = x_size_table[screen_res];
427:
428: vga_init();
429: modeinfo = *vga_getmodeinfo (vgamode);
430:
431: vidmode_linewidth = modeinfo.linewidth;
432: gfxvidinfo.pixbytes = modeinfo.bytesperpixel;
433: if (!need_dither) {
434: if (modeinfo.bytesperpixel == 0) {
435: printf("Got a bogus value from SVGAlib... %s.\n",
436: screen_res == 1 || screen_res == 2 ? "trying to fix it" : "giving up");
437: if (screen_res != 1 && screen_res != 2)
438: return 0;
439: gfxvidinfo.pixbytes = 1;
440: }
441: } else {
442: gfxvidinfo.pixbytes = 2;
443: }
444:
445: if (vga_setmode(vgamode) < 0) {
446: sleep(1);
447: vga_setmode(TEXT);
448: fprintf(stderr, "SVGAlib doesn't like my video mode. Giving up.\n");
449: return 0;
450: }
451:
452: if ((modeinfo.flags & CAPABLE_LINEAR) && !no_xhair) {
453: if (vga_setlinearaddressing() != -1) {
454: linear_mem = (char *)vga_getgraphmem();
455: printf("Using linear addressing: %p.\n", linear_mem);
456: using_linear = !need_dither;
457: }
458: }
459:
460: vsize = correct_aspect ? 2*numscrlines : numscrlines;
461: gfxvidinfo.maxblocklines = 0;
462:
463: if (using_linear) {
464: gfxvidinfo.bufmem = linear_mem;
465: gfxvidinfo.rowbytes = modeinfo.linewidth;
466: } else {
467: gfxvidinfo.rowbytes = x_size * gfxvidinfo.pixbytes;
468: gfxvidinfo.bufmem = malloc(gfxvidinfo.rowbytes * vsize);
469: memset(gfxvidinfo.bufmem, 0, gfxvidinfo.rowbytes * vsize);
470: }
471:
472: gfxvidinfo.maxlinetoscr = x_size < 800 ? x_size : 0;
473: gfxvidinfo.x_adjust = 0;
474: gfxvidinfo.maxline = modeinfo.height;
475:
476: init_colors();
477: vga_setmousesupport(1);
478: mouse_init("/dev/mouse",vga_getmousetype(),10);
479: if (keyboard_init() != 0)
480: abort();
481: keyboard_seteventhandler(my_kbd_handler);
482: keyboard_translatekeys(DONT_CATCH_CTRLC);
483:
484: buttonstate[0] = buttonstate[1] = buttonstate[2] = 0;
485: for(i = 0; i < 256; i++)
486: keystate[i] = 0;
487:
488: lastmx = lastmy = 0;
489: newmousecounters = 0;
490:
491: mouse_setxrange(-1000,1000);
492: mouse_setyrange(-1000,1000);
493: mouse_setposition(0,0);
494:
495: return 1;
496: }
497:
498: void graphics_leave(void)
499: {
500: sleep(1); /* Maybe this will fix the "screen full of garbage" problem */
501: vga_setmode(TEXT);
502: keyboard_close();
503: dumpcustom();
504: }
505:
506: void handle_events(void)
507: {
508: int button = mouse_getbutton();
509:
510: keyboard_update();
511: mouse_update();
512: lastmx += mouse_getx();
513: lastmy += mouse_gety();
514: mouse_setposition(0,0);
515:
516: buttonstate[0] = button & 4;
517: buttonstate[1] = button & 2;
518: buttonstate[2] = button & 1;
519: }
520:
521: int debuggable(void)
522: {
523: return 0;
524: }
525:
526: int needmousehack(void)
527: {
528: return 0;
529: }
530:
531: void LED(int on)
532: {
533: }
534:
535: void target_specific_usage(void)
536: {
537: printf(" -S n : Sound emulation accuracy (n = 0, 1, 2 or 3)\n"
538: " For sound emulation, n = 2 is recommended\n");
539: printf(" -b n : Use n bits for sound output (8 or 16)\n");
540: printf(" -R n : Use n Hz to output sound. Common values are\n"
541: " 22050 Hz or 44100 Hz\n");
542: printf(" -B n : Use a sound buffer of n bytes (use small\n"
543: " values on fast machines)\n");
544: printf(" -x : Don't use SVGAlib linear framebuffer, even if available.\n");
545: printf(" -p command : Use command to pipe printer output to.\n");
546: printf(" -I device : Name of the used serial device (i.e. /dev/ttyS1\n");
547: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.