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