home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Emulatoren / UAE061.LZH / uae-0.6.1 / custom.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  82.0 KB  |  3,018 lines
  1.  /*
  2.   * UAE - The Un*x Amiga Emulator
  3.   * 
  4.   * Custom chip emulation
  5.   * 
  6.   * (c) 1995 Bernd Schmidt, Alessandro Bissacco
  7.   */
  8.  
  9. #include "sysconfig.h"
  10. #include "sysdeps.h"
  11.  
  12. #include <ctype.h>
  13. #include <assert.h>
  14.  
  15. #include "config.h"
  16. #include "options.h"
  17. #include "events.h"
  18. #include "memory.h"
  19. #include "custom.h"
  20. #include "cia.h"
  21. #include "disk.h"
  22. #include "blitter.h"
  23. #include "xwin.h"
  24. #include "os.h"
  25. #include "keybuf.h"
  26.  
  27. /*#define EMULATE_AGA*/
  28.  
  29. #ifndef EMULATE_AGA
  30. #define AGA_CHIPSET 0
  31. #else
  32. #define AGA_CHIPSET 1
  33. #endif
  34.  
  35. #define SMART_UPDATE 1
  36.  
  37. #define MAX_PLANES 8
  38.  
  39. #define PIXEL_XPOS(HPOS) (((HPOS)*2 - 0x30)*(use_lores ? 1 : 2))
  40.  
  41. /* These are default values for mouse calibration.
  42.  * The first two are default values for mstepx and mstepy.
  43.  * The second line set the orizontal and vertical offset for amiga and X 
  44.  * pointer matching
  45.  */
  46.    
  47. #define defstepx (1<<16)
  48. #define defstepy (1<<16)
  49. #define defxoffs 0
  50. #define defyoffs 0
  51.     
  52. /* Values below define mouse auto calibration process.
  53.  * They are not critical, change them if you want.
  54.  * The most important is calweight, which sets mouse adjustement rate */ 
  55.  
  56. static const int docal = 60, xcaloff = 40, ycaloff = 20;
  57. static const int calweight = 3;
  58. static int lastsampledmx, lastsampledmy;
  59.  
  60.  /*
  61.   * Events
  62.   */
  63.  
  64. unsigned long int cycles, nextevent, nextev_count, specialflags;
  65. int vpos;
  66. UWORD lof;
  67.  
  68. struct ev eventtab[ev_max];
  69.  
  70. int copper_active;
  71.  
  72. static const int dskdelay = 2; /* FIXME: ??? */
  73.  
  74.  /* 
  75.   * hardware register values that are visible/can be written to by someone
  76.   */
  77.  
  78. static UWORD cregs[256];
  79.  
  80. static UWORD dmacon,intena,intreq;
  81. UWORD adkcon; /* used by audio code */
  82.  
  83. static ULONG cop1lc,cop2lc,copcon;
  84.  
  85. /* Kludge. FIXME: How does sprite restart after vsync work? */
  86. static int spron[8];
  87. static CPTR sprpt[8];
  88.  
  89. static ULONG bpl1dat,bpl2dat,bpl3dat,bpl4dat,bpl5dat,bpl6dat,bpl7dat,bpl8dat;
  90. static WORD  bpl1mod,bpl2mod;
  91.  
  92. xcolnr acolors[64];
  93.  
  94. UWORD *r_bplpt[MAX_PLANES];
  95. static CPTR bplpt[MAX_PLANES];
  96.  
  97. /*static int blitcount[256];  blitter debug */
  98.  
  99. struct bplinfo {
  100. #if AGA_CHIPSET == 0
  101.     /* X86.S will break if this isn't at the beginning of the structure. */
  102.     UWORD color_regs[32];
  103. #else
  104.     ULONG color_regs[256];
  105. #endif
  106.     UWORD bplcon0,bplcon1,bplcon2,bplcon3,bplcon4;
  107.     UWORD diwstrt,diwstop,ddfstrt,ddfstop;
  108.  
  109.     UWORD sprdata[8], sprdatb[8], sprctl[8], sprpos[8];
  110.     int sprarmed[8];
  111. } bpl_info;
  112.  
  113. struct line_description
  114. {
  115.     int inborder;
  116.     xcolnr bordercol;
  117.     struct bplinfo bpl_info;
  118.     struct mem_notify_node *mnn;
  119.     CPTR bplpt[MAX_PLANES];
  120.     int linedata_valid;
  121. };
  122.  
  123. static int frame_redraw_necessary;
  124.  
  125. /* 50 words give you 800 horizontal pixels. An A500 can't do that, so it ought
  126.  * to be enough. */
  127. #define MAX_WORDS_PER_LINE 50
  128. static UWORD line_data[numscrlines * 2][MAX_PLANES][MAX_WORDS_PER_LINE];
  129. static struct line_description linedescr[numscrlines * 2];
  130.  
  131. static ULONG dskpt;
  132. static UWORD dsklen,dsksync;
  133.  
  134. static int joy0x, joy1x, joy0y, joy1y;
  135. int joy0button;
  136. UWORD joy0dir;
  137. static int lastspr0x,lastspr0y,lastdiffx,lastdiffy,spr0pos,spr0ctl;
  138. static int mstepx,mstepy,xoffs=defxoffs,yoffs=defyoffs;
  139. static int sprvbfl;
  140.  
  141. static enum { normal_mouse, dont_care_mouse, follow_mouse } mousestate;
  142.  
  143.  /*
  144.   * "hidden" hardware registers
  145.   */
  146.  
  147. int dblpf_ind1[256], dblpf_ind2[256], dblpf_2nd1[256], dblpf_2nd2[256];
  148. int dblpf_aga1[256], dblpf_aga2[256], linear_map_256[256], lots_of_twos[256];
  149.  
  150. int dblpfofs[] = { 0, 2, 4, 8, 16, 32, 64, 128 };
  151.  
  152. static ULONG coplc;
  153. static UWORD copi1,copi2;
  154.  
  155. static enum {
  156.     COP_stop, COP_read, COP_wait, COP_move, COP_skip
  157. } copstate;
  158.  
  159. static int dsklength;
  160.  
  161. int plffirstline,plflastline,plfstrt,plfstop,plflinelen;
  162. int diwfirstword,diwlastword;
  163. int plfpri[3];
  164.  
  165. int max_diwstop, prev_max_diwstop;
  166.  
  167. int dskdmaen; /* used in cia.c */
  168.  
  169. int bpldelay1, bpldelay2;
  170. int bplehb, bplham, bpldualpf, bpldualpfpri, bplplanecnt, bplhires;
  171.  
  172. static int pfield_fullline,pfield_linedone;
  173. static int pfield_linedmaon;
  174. static int pfield_lastpart_hpos,last_sprite;
  175. static int slowline_nextpos, slowline_linepos, slowline_lasttoscr;
  176.  
  177. union {
  178.     /* Let's try to align this thing. */
  179.     double uupzuq;
  180.     long int cruxmedo;
  181.     unsigned char apixels[1000];
  182. } pixdata;
  183.  
  184. char spixels[1000]; /* for sprites */
  185. char spixstate[1000]; /* more sprites */
  186.  
  187. ULONG ham_linebuf[1000];
  188. ULONG aga_linebuf[1000], *aga_lbufptr;
  189.  
  190. char *xlinebuffer;
  191. int next_lineno, linetoscreen, line_in_border;
  192.  
  193. /*
  194.  * Statistics
  195.  */
  196.  
  197. static unsigned long int msecs = 0, frametime = 0, timeframes = 0;
  198. static unsigned long int seconds_base;
  199. int bogusframe;
  200.  
  201. /*
  202.  * helper functions
  203.  */
  204.  
  205. static void pfield_doline_slow(int);
  206. static void pfield_doline(void);
  207. static void do_sprites(int, int);
  208.  
  209. int inhibit_frame;
  210. static int framecnt = 0;
  211.  
  212. static __inline__ void count_frame(void)
  213. {
  214.     if (inhibit_frame) 
  215.         framecnt = 1;
  216.     else {
  217.     framecnt++;
  218.     if (framecnt >= framerate)
  219.             framecnt = 0;
  220.     }
  221. }
  222.  
  223. static __inline__ void setclr(UWORD *p, UWORD val)
  224. {
  225.     if (val & 0x8000) {
  226.     *p |= val & 0x7FFF;
  227.     } else {
  228.     *p &= ~val;
  229.     }
  230. }
  231.  
  232. int dmaen(UWORD dmamask)
  233. {
  234.     return (dmamask & dmacon) && (dmacon & 0x200);
  235. }
  236.  
  237. static __inline__ int current_hpos(void)
  238. {
  239.     return cycles - eventtab[ev_hsync].oldcycles;
  240. }
  241.  
  242. static void calcdiw(void)
  243. {
  244.     if (use_lores) {
  245.     diwfirstword = (bpl_info.diwstrt & 0xFF) - 0x30 - 1;
  246.     diwlastword  = (bpl_info.diwstop & 0xFF) + 0x100 - 0x30 - 1;
  247.     } else {
  248.     diwfirstword = (bpl_info.diwstrt & 0xFF) * 2 - 0x60 - 2;
  249.     diwlastword  = (bpl_info.diwstop & 0xFF) * 2 + 0x200 - 0x60 - 2;
  250.     }
  251.     if (diwfirstword < 0) diwfirstword = 0;
  252.     if (diwlastword > max_diwstop) max_diwstop = diwlastword;
  253.     
  254.     plffirstline = bpl_info.diwstrt >> 8;
  255.     plflastline = bpl_info.diwstop >> 8;
  256. #if 0
  257.     /* This happens far too often. */
  258.     if (plffirstline < minfirstline) {
  259.     fprintf(stderr, "Warning: Playfield begins before line %d!\n", minfirstline);
  260.     plffirstline = minfirstline;
  261.     }
  262. #endif
  263.     if ((plflastline & 0x80) == 0) plflastline |= 0x100;
  264. #if 0 /* Turrican does this */
  265.     if (plflastline > 313) {
  266.     fprintf(stderr, "Warning: Playfield out of range!\n");
  267.     plflastline = 313;
  268.     }
  269. #endif
  270.     plfstrt = bpl_info.ddfstrt;
  271.     plfstop = bpl_info.ddfstop;
  272.     if (plfstrt < 0x18) plfstrt = 0x18;
  273.     if (plfstop > 0xD8) plfstop = 0xD8;
  274.     if (plfstrt > plfstop) plfstrt = plfstop;
  275.  
  276.     /* ! If the masking operation is changed, the pfield_doline code could break
  277.      * on some systems (alignment) */
  278.     /* This actually seems to be correct now... */
  279.     plfstrt &= ~3;
  280.     plfstop &= ~3;
  281.     plflinelen = (plfstop-plfstrt+15) & ~7;
  282. }
  283.  
  284. /*
  285.  * Screen update macros/functions
  286.  */
  287.  
  288. static void decode_ham6 (int pix, int stoppos)
  289. {
  290.     static UWORD lastcolor;
  291.     ULONG *buf = ham_linebuf; 
  292.  
  293.     if (!bplham || bplplanecnt != 6)
  294.     return;
  295.     
  296.     if (pix <= diwfirstword) {
  297.     pix = diwfirstword;
  298.     lastcolor = bpl_info.color_regs[0];
  299.     }
  300.  
  301.     while (pix < diwlastword && pix < stoppos) {
  302.     int pv = pixdata.apixels[pix];
  303.     switch(pv & 0x30) {
  304.      case 0x00: lastcolor = bpl_info.color_regs[pv]; break;
  305.      case 0x10: lastcolor &= 0xFF0; lastcolor |= (pv & 0xF); break;
  306.      case 0x20: lastcolor &= 0x0FF; lastcolor |= (pv & 0xF) << 8; break;
  307.      case 0x30: lastcolor &= 0xF0F; lastcolor |= (pv & 0xF) << 4; break;
  308.     }
  309.  
  310.     buf[pix++] = lastcolor;
  311.     }    
  312. }
  313.  
  314. static void decode_ham_aga (int pix, int stoppos)
  315. {
  316.     static ULONG lastcolor;
  317.     ULONG *buf = ham_linebuf; 
  318.  
  319.     if (!bplham || (bplplanecnt != 6 && bplplanecnt != 8))
  320.     return;
  321.     
  322.     if (pix <= diwfirstword) {
  323.     pix = diwfirstword;
  324.     lastcolor = bpl_info.color_regs[0];
  325.     }
  326.  
  327.     if (bplplanecnt == 6) {
  328.     /* HAM 6 */
  329.     while (pix < diwlastword && pix < stoppos) {
  330.         int pv = pixdata.apixels[pix];
  331.         switch(pv & 0x30) {
  332.          case 0x00: lastcolor = bpl_info.color_regs[pv]; break;
  333.          case 0x10: lastcolor &= 0xFFFF00; lastcolor |= (pv & 0xF)*0x11; break;
  334.          case 0x20: lastcolor &= 0x00FFFF; lastcolor |= (pv & 0xF)*0x11 << 16; break;
  335.          case 0x30: lastcolor &= 0xFF00FF; lastcolor |= (pv & 0xF)*0x11 << 8; break;
  336.         }        
  337.         buf[pix++] = lastcolor;
  338.     }
  339.     } else if (bplplanecnt == 8) {
  340.     /* HAM 8 */
  341.     while (pix < diwlastword && pix < stoppos) {
  342.         int pv = pixdata.apixels[pix];
  343.         switch(pv & 0x3) {
  344.          case 0x0: lastcolor = bpl_info.color_regs[pv >> 2]; break;
  345.          case 0x1: lastcolor &= 0xFFFF03; lastcolor |= (pv & 0xFC); break;
  346.          case 0x2: lastcolor &= 0x03FFFF; lastcolor |= (pv & 0xFC) << 16; break;
  347.          case 0x3: lastcolor &= 0xFF03FF; lastcolor |= (pv & 0xFC) << 8; break;
  348.         }
  349.         buf[pix++] = lastcolor;
  350.     }
  351.     }
  352. }
  353.  
  354. #define LINE_TO_SCR(NAME, TYPE, DO_DOUBLE) \
  355. static void NAME(int pix, int stoppos, int offset) \
  356. { \
  357.     TYPE *buf = (TYPE *)xlinebuffer; \
  358.     int oldpix = pix; \
  359.     buf -= pix; \
  360.     if (DO_DOUBLE) offset /= sizeof(TYPE); \
  361.     while (pix < diwfirstword && pix < stoppos) { \
  362.         TYPE d = acolors[0]; \
  363.     buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  364.     pix++; \
  365.     } \
  366.     if (bplham && bplplanecnt == 6) { \
  367.     /* HAM 6 */ \
  368.     while (pix < diwlastword && pix < stoppos) { \
  369.         TYPE d = xcolors[ham_linebuf[pix]]; \
  370.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  371.         pix++; \
  372.     } \
  373.     } else if (bpldualpf) { \
  374.     /* Dual playfield */ \
  375.     int *lookup = bpldualpfpri ? dblpf_ind2 : dblpf_ind1; \
  376.     while (pix < diwlastword && pix < stoppos) { \
  377.         int pixcol = pixdata.apixels[pix]; \
  378.         TYPE d; \
  379.         if (spixstate[pix]) { \
  380.         d = acolors[pixcol]; \
  381.         } else { \
  382.         d = acolors[lookup[pixcol]]; \
  383.         } \
  384.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  385.         pix++; \
  386.     } \
  387.     } else { \
  388.     while (pix < diwlastword && pix < stoppos) { \
  389.         TYPE d = acolors[pixdata.apixels[pix]]; \
  390.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  391.         pix++; \
  392.     } \
  393.     } \
  394.     while (pix < stoppos) { \
  395.         TYPE d = acolors[0]; \
  396.     buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  397.     pix++; \
  398.     } \
  399.     xlinebuffer = (char *)(((TYPE *)xlinebuffer) + pix - oldpix); \
  400. }
  401.  
  402. /* WARNING: Not too much of this will work correctly yet. */
  403.  
  404. static void pfield_linetoscr_aga(int pix, int stoppos)
  405. {
  406.     ULONG *buf = aga_lbufptr;
  407.     int i;
  408.     int xor = (UBYTE)(bpl_info.bplcon4 >> 8);
  409.     int oldpix = pix; \
  410.  
  411.     buf -= pix; \
  412.  
  413.     for (i = 0; i < stoppos; i++)
  414.     pixdata.apixels[i] ^= xor;
  415.     
  416.     while (pix < diwfirstword && pix < stoppos) {
  417.     buf[pix++] = bpl_info.color_regs[0];
  418.     }
  419.     if (bplham) {
  420.     while (pix < diwlastword && pix < stoppos) {
  421.         ULONG d = ham_linebuf[pix];
  422.         buf[pix] = d;
  423.         pix++;
  424.     }
  425.     } else if (bpldualpf) {
  426.     /* Dual playfield */
  427.     int *lookup = bpldualpfpri ? dblpf_aga2 : dblpf_aga1;
  428.     int *lookup_no = bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1;
  429.     while (pix < diwlastword && pix < stoppos) {
  430.         int pixcol = pixdata.apixels[pix];
  431.         int pfno = lookup_no[pixcol];
  432.         
  433.         if (spixstate[pix]) {
  434.             buf[pix] = bpl_info.color_regs[pixcol];
  435.         } else {
  436.         int val = lookup[pixdata.apixels[pix]];
  437.         if (pfno == 2) 
  438.             val += dblpfofs[(bpl_info.bplcon2 >> 10) & 7];
  439.         buf[pix] = bpl_info.color_regs[val];
  440.         }
  441.         pix++;
  442.     }
  443.     } else if (bplehb) {
  444.     while (pix < diwlastword && pix < stoppos) {
  445.             int pixcol = pixdata.apixels[pix];
  446.         ULONG d = bpl_info.color_regs[pixcol];
  447.         /* What about sprites? */
  448.         if (pixcol & 0x20)
  449.         d = (d & 0x777777) >> 1;
  450.         buf[pix] = d;
  451.         pix++;
  452.     }
  453.     } else {
  454.     while (pix < diwlastword && pix < stoppos) {
  455.         int pixcol = pixdata.apixels[pix];
  456.         buf[pix] = bpl_info.color_regs[pixcol];
  457.         pix++;
  458.     }
  459.     }
  460.     while (pix < stoppos) {
  461.     buf[pix++] = bpl_info.color_regs[0];
  462.     }
  463.     aga_lbufptr += pix - oldpix;
  464. }
  465.  
  466. static void aga_translate32(int start, int stop)
  467. {
  468.     memcpy (((ULONG *)xlinebuffer) + start, aga_linebuf + start, 4*(stop-start));
  469. }
  470.  
  471. static void aga_translate16(int start, int stop)
  472. {
  473.     int i;
  474.     for (i = start; i < stop; i++) {
  475.     ULONG d = aga_linebuf[i];
  476.     UWORD v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
  477.     ((UWORD *)xlinebuffer)[i] = xcolors[v];
  478.     }
  479. }
  480.  
  481. static void aga_translate8(int start, int stop)
  482. {
  483.     int i;
  484.     for (i = start; i < stop; i++) {
  485.     ULONG d = aga_linebuf[i];
  486.     UWORD v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
  487.     ((UBYTE *)xlinebuffer)[i] = xcolors[v];
  488.     }
  489. }
  490.  
  491.  
  492.  
  493. #define FILL_LINE(NAME, TYPE) \
  494. static void NAME(char *buf) \
  495. { \
  496.     TYPE *b = (TYPE *)buf; \
  497.     int i;\
  498.     int maxpos = gfxvidinfo.maxlinetoscr; \
  499.     xcolnr col = acolors[0]; \
  500.     if (!maxpos) maxpos = 796; \
  501.     for (i = 0; i < maxpos; i++) \
  502.         *b++ = col; \
  503. }
  504.  
  505. LINE_TO_SCR(pfield_linetoscr_8, UBYTE, 0)
  506. LINE_TO_SCR(pfield_linetoscr_16, UWORD, 0)
  507. LINE_TO_SCR(pfield_linetoscr_32, ULONG, 0)
  508. LINE_TO_SCR(pfield_linetoscr_8_double_slow, UBYTE, 1)
  509. LINE_TO_SCR(pfield_linetoscr_16_double_slow, UWORD, 1)
  510. LINE_TO_SCR(pfield_linetoscr_32_double_slow, ULONG, 1)
  511.  
  512. FILL_LINE(fill_line_8, UBYTE)
  513. FILL_LINE(fill_line_16, UWORD)
  514. FILL_LINE(fill_line_32, ULONG)
  515.  
  516. #define pfield_linetoscr_full8 pfield_linetoscr_8
  517. #define pfield_linetoscr_full16 pfield_linetoscr_16
  518. #define pfield_linetoscr_full32 pfield_linetoscr_32
  519.  
  520. #define pfield_linetoscr_full8_double pfield_linetoscr_8_double_slow
  521. #define pfield_linetoscr_full16_double pfield_linetoscr_16_double_slow
  522. #define pfield_linetoscr_full32_double pfield_linetoscr_32_double_slow
  523.  
  524. #if 1 && defined(X86_ASSEMBLY)
  525. #undef pfield_linetoscr_full8
  526. #undef pfield_linetoscr_full16
  527. extern void pfield_linetoscr_full8(int, int, int) __asm__("pfield_linetoscr_full8");
  528. extern void pfield_linetoscr_full16(int, int, int) __asm__("pfield_linetoscr_full16");
  529. #undef pfield_linetoscr_full8_double
  530. #undef pfield_linetoscr_full16_double
  531.  
  532. static void pfield_linetoscr_full8_double(int start, int stop, int offset)
  533. {
  534.     char *oldxlb = (char *)xlinebuffer;
  535.     pfield_linetoscr_full8(start,stop,offset);
  536.     xlinebuffer = oldxlb + offset;
  537.     pfield_linetoscr_full8(start,stop,offset);
  538. }
  539. static void pfield_linetoscr_full16_double(int start, int stop, int offset)
  540. {
  541.     char *oldxlb = (char *)xlinebuffer;
  542.     pfield_linetoscr_full16(start,stop,offset);
  543.     xlinebuffer = oldxlb + offset;
  544.     pfield_linetoscr_full16(start,stop,offset);
  545. }
  546. #endif
  547.  
  548. static __inline__ void fill_line(int y)
  549. {
  550.     switch (gfxvidinfo.pixbytes) {
  551.      case 1: fill_line_8(gfxvidinfo.bufmem + gfxvidinfo.rowbytes * y); break;
  552.      case 2: fill_line_16(gfxvidinfo.bufmem + gfxvidinfo.rowbytes * y); break;
  553.      case 4: fill_line_32(gfxvidinfo.bufmem + gfxvidinfo.rowbytes * y); break;
  554.     }
  555. }
  556.  
  557. static void pfield_do_linetoscr(int start, int stop)
  558. {
  559.     int factor = use_lores ? 1 : 2;
  560.     int oldstop = stop;
  561.     int real_start, real_stop;
  562.     
  563.     start = PIXEL_XPOS(start);
  564.     if (start < 8*factor)
  565.     start = 8*factor;
  566.     stop = PIXEL_XPOS(stop);
  567.     if (stop > 406*factor)
  568.     stop = 406*factor;
  569.     
  570.     if (start >= stop)
  571.     return;
  572.     if (stop <= gfxvidinfo.x_adjust)
  573.     return;
  574.     
  575.     slowline_lasttoscr = oldstop;
  576.  
  577.     if (start < gfxvidinfo.x_adjust)
  578.     real_start = gfxvidinfo.x_adjust;
  579.     else
  580.     real_start = start;
  581.     
  582.     if (gfxvidinfo.maxlinetoscr) {
  583.     real_stop = gfxvidinfo.x_adjust + gfxvidinfo.maxlinetoscr;
  584.     if (real_stop > stop)
  585.         real_stop = stop;
  586.     } else
  587.     real_stop = stop;
  588.  
  589. #if AGA_CHIPSET == 0
  590.     if (start == 8*factor && stop == 406*factor) {
  591.     switch (gfxvidinfo.pixbytes) {
  592.      case 1: pfield_linetoscr_full8 (real_start, real_stop, 0); break;
  593.      case 2: pfield_linetoscr_full16 (real_start, real_stop, 0); break;
  594.      case 4: pfield_linetoscr_full32 (real_start, real_stop, 0); break;
  595.     }
  596.     } else {
  597.     if (real_start >= real_stop)
  598.         return;
  599.     switch (gfxvidinfo.pixbytes) {
  600.      case 1: pfield_linetoscr_8 (real_start, real_stop, 0); break;
  601.      case 2: pfield_linetoscr_16 (real_start, real_stop, 0); break;
  602.      case 4: pfield_linetoscr_32 (real_start, real_stop, 0); break;
  603.     }
  604.     }
  605. #else
  606.     pfield_linetoscr_aga(real_start, real_stop);
  607. #endif
  608. }
  609.  
  610. static void pfield_do_linetoscr_full(int double_line)
  611. {
  612.     int factor = use_lores ? 1 : 2;
  613.     int stop, start;
  614.     
  615.     start = 8*factor;
  616.     stop = 406*factor;
  617.     
  618.     if (start < gfxvidinfo.x_adjust)
  619.     start = gfxvidinfo.x_adjust;
  620.     
  621.     if (gfxvidinfo.maxlinetoscr) {
  622.     int tmp = gfxvidinfo.x_adjust + gfxvidinfo.maxlinetoscr;
  623.     if (tmp < stop)
  624.         stop = tmp;
  625.     }
  626.  
  627. #if AGA_CHIPSET == 0
  628.     if (double_line) {
  629.     switch (gfxvidinfo.pixbytes) {
  630.      case 1: pfield_linetoscr_full8_double (start, stop, gfxvidinfo.rowbytes); break;
  631.      case 2: pfield_linetoscr_full16_double (start, stop, gfxvidinfo.rowbytes); break;
  632.      case 4: pfield_linetoscr_full32_double (start, stop, gfxvidinfo.rowbytes); break;
  633.     }
  634.     } else 
  635.     switch (gfxvidinfo.pixbytes) {
  636.      case 1: pfield_linetoscr_full8 (start, stop, 0); break;
  637.      case 2: pfield_linetoscr_full16 (start, stop, 0); break;
  638.      case 4: pfield_linetoscr_full32 (start, stop, 0); break;
  639.     }
  640. #else
  641.     pfield_linetoscr_aga(start, stop);
  642. #endif
  643. }
  644.  
  645. /*
  646.  * This function is called whenever a hardware register that controls the
  647.  * screen display is modified. Usually, this routine does nothing. But in
  648.  * some cases, e.g., when a color changes in mid-screen, as in copper-plasma
  649.  * effects, this function switches the update method from the fast full-line
  650.  * update to the much slower single-color-clock update.
  651.  */
  652. static void pfield_may_need_update(int colreg)
  653. {
  654.     int i;
  655.     
  656.     /* Ignore, if this happened before or after the DDF window */
  657.     if (framecnt != 0 || !pfield_linedmaon || current_hpos() <= plfstrt
  658.     || vpos < plffirstline || vpos < minfirstline || vpos >= plflastline
  659.     || next_lineno >= gfxvidinfo.maxline)
  660.     {
  661.         return;
  662.     }
  663.     /* 
  664.      * If a color reg was modified, it is only important if we are within
  665.      * the DIW.
  666.      */
  667.     if (PIXEL_XPOS(current_hpos()) <= diwfirstword && colreg)
  668.         return;
  669.  
  670.     /*
  671.      * If we are past the DDF window, me might as well draw the complete
  672.      * line now.
  673.      */
  674.     if (current_hpos() > plfstrt + plflinelen && pfield_fullline) {
  675.     if (!pfield_linedone)
  676.         pfield_doline();
  677.     pfield_linedone = 1;
  678.     return;
  679.     }
  680.         
  681.     do_sprites(vpos, current_hpos());
  682.     if (pfield_fullline) {
  683.     pfield_lastpart_hpos = 0;
  684.     memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  685.     memset(spixstate,0,sizeof spixstate);
  686.     pfield_fullline = 0;
  687.     slowline_nextpos = -1;
  688.     slowline_linepos = 0;
  689.     slowline_lasttoscr = 0;
  690.     } else {    
  691.     assert(pfield_lastpart_hpos <= current_hpos());
  692.     }
  693.     for (i = pfield_lastpart_hpos; i < current_hpos(); i++) {
  694.     pfield_doline_slow(i);
  695.     }
  696.     if (colreg) {
  697.     pfield_do_linetoscr(slowline_lasttoscr, current_hpos());
  698.     }
  699.     pfield_lastpart_hpos = current_hpos();
  700. }
  701.  
  702. /* Apparently, the DMA bit is tested by the hardware at some point,
  703.  * presumably at the ddfstart position, to determine whether it
  704.  * ought to draw the line.
  705.  * This is probably not completely correct, but should not matter
  706.  * very much.
  707.  */
  708. static void pfield_calclinedma(void)
  709. {
  710.     if (current_hpos() >= plfstrt)
  711.         return;
  712.     
  713.     pfield_linedmaon = dmaen(DMA_BITPLANE);
  714. }
  715.  
  716.  /* 
  717.   * register functions
  718.   */
  719.  
  720. static UWORD DMACONR(void)
  721. {
  722.     return (dmacon | (bltstate==BLT_done ? 0 : 0x4000)
  723.         | (blt_info.blitzero ? 0x2000 : 0));
  724. }
  725. static UWORD INTENAR(void) { return intena; }
  726. static UWORD INTREQR(void) { return intreq; }
  727. static UWORD ADKCONR(void) { return adkcon; }
  728. static UWORD VPOSR(void) 
  729. {
  730. #if AGA_CHIPSET == 1
  731.     return (vpos >> 8) | lof | 0x2300;
  732. #elif defined (ECS_AGNUS)
  733.     return (vpos >> 8) | lof | 0x2000;
  734. #else
  735.     return (vpos >> 8) | lof;
  736. #endif
  737. }
  738. static void  VPOSW(UWORD v)  { lof = v & 0x8000; }
  739. static UWORD VHPOSR(void) { return (vpos << 8) | current_hpos(); } 
  740.  
  741. static void  COP1LCH(UWORD v) { cop1lc= (cop1lc & 0xffff) | ((ULONG)v << 16); }
  742. static void  COP1LCL(UWORD v) { cop1lc= (cop1lc & ~0xffff) | v; }
  743. static void  COP2LCH(UWORD v) { cop2lc= (cop2lc & 0xffff) | ((ULONG)v << 16); }
  744. static void  COP2LCL(UWORD v) { cop2lc= (cop2lc & ~0xffff) | v; }
  745.  
  746. static void  COPJMP1(UWORD a)
  747. {
  748.     coplc = cop1lc; copstate = COP_read; 
  749.     eventtab[ev_copper].active = 1; eventtab[ev_copper].oldcycles = cycles;
  750.     eventtab[ev_copper].evtime = 4; events_schedule();
  751.     copper_active = 1;
  752. }
  753. static void  COPJMP2(UWORD a)
  754. {
  755.     coplc = cop2lc; copstate = COP_read; 
  756.     eventtab[ev_copper].active = 1; eventtab[ev_copper].oldcycles = cycles;
  757.     eventtab[ev_copper].evtime = 4; events_schedule();
  758.     copper_active = 1;
  759. }
  760.  
  761. static void  DMACON(UWORD v) 
  762. {
  763.     UWORD oldcon = dmacon;
  764.     setclr(&dmacon,v); dmacon &= 0x1FFF;
  765.     pfield_calclinedma();
  766.     
  767.     /* FIXME? Maybe we need to think a bit more about the master DMA enable 
  768.      * bit in these cases. */
  769.     if ((dmacon & DMA_COPPER) > (oldcon & DMA_COPPER)) { 
  770.     COPJMP1(0);
  771.     }
  772.     if ((dmacon & DMA_SPRITE) > (oldcon & DMA_SPRITE)) {
  773.     int i;
  774.     for (i = 0; i < 8; i++)
  775.         spron[i] = 1;
  776.     }
  777.     if ((dmacon & DMA_BLITPRI) > (oldcon & DMA_BLITPRI) && bltstate != BLT_done) {
  778.     static int count = 0;
  779.     if (!count) {
  780.         count = 1;
  781.         fprintf(stderr, "warning: Program is doing blitpri hacks.\n");
  782.     }
  783.     specialflags |= SPCFLAG_BLTNASTY;
  784.     }
  785.     if (copper_active && !eventtab[ev_copper].active) {
  786.     eventtab[ev_copper].active = 1;
  787.     eventtab[ev_copper].oldcycles = cycles;
  788.     eventtab[ev_copper].evtime = 1;
  789.     events_schedule();
  790.     }
  791. }
  792. static void  INTENA(UWORD v) { setclr(&intena,v); specialflags |= SPCFLAG_INT; }
  793. void  INTREQ(UWORD v) { setclr(&intreq,v); specialflags |= SPCFLAG_INT; }
  794. static void  ADKCON(UWORD v) { setclr(&adkcon,v); }
  795.  
  796. static void  BPLPTH(UWORD v, int num) { bplpt[num] = (bplpt[num] & 0xffff) | ((ULONG)v << 16); }
  797. static void  BPLPTL(UWORD v, int num) { bplpt[num] = (bplpt[num] & ~0xffff) | (v & 0xFFFE); }
  798.  
  799. /*
  800.  * I've seen the listing of an example program that changes 
  801.  * from lo- to hires while a line is being drawn. That's
  802.  * awful, but we want to emulate it.
  803.  */
  804. static void  BPLCON0(UWORD v) 
  805. {
  806.     if (bpl_info.bplcon0 == v)
  807.     return;
  808.     pfield_may_need_update(0);
  809.     bpl_info.bplcon0 = v;
  810.     bplhires = (v & 0x8000) == 0x8000;
  811.     bplplanecnt = (v & 0x7000) >> 12;
  812.     bplham = (v & 0x800) == 0x800;
  813.     bpldualpf = (v & 0x400) == 0x400;
  814.     bplehb = (v & 0xFDC0) == 0x6000 && !(bpl_info.bplcon2 & 0x200); /* see below */
  815.     calcdiw(); /* This should go away. */
  816. }
  817. static void  BPLCON1(UWORD v) 
  818. {
  819.     if (bpl_info.bplcon1 == v)
  820.     return;
  821.     pfield_may_need_update(0);
  822.     bpl_info.bplcon1 = v; 
  823.     bpldelay1 = v & 0xF; 
  824.     bpldelay2 = (v >> 4) & 0xF; 
  825. }
  826. static void  BPLCON2(UWORD v) 
  827. {
  828.     if (bpl_info.bplcon2 == v)
  829.     return;
  830.     pfield_may_need_update(0); 
  831.     bpl_info.bplcon2 = v;
  832.     bpldualpfpri = (v & 0x40) == 0x40;
  833.     plfpri[1] = 1 << 2*(v & 7);
  834.     plfpri[2] = 1 << 2*((v>>3) & 7);
  835.     bplehb = (bpl_info.bplcon0 & 0xFDC0) == 0x6000 && !(v & 0x200); /* see above */
  836. }
  837. static void  BPLCON3(UWORD v) 
  838. {
  839.     if (bpl_info.bplcon3 == v)
  840.     return;
  841.     pfield_may_need_update(0); 
  842.     bpl_info.bplcon3 = v; 
  843. }
  844. static void  BPLCON4(UWORD v) 
  845. {
  846.     if (bpl_info.bplcon4 == v)
  847.     return;
  848.     pfield_may_need_update(0); 
  849.     bpl_info.bplcon4 = v; 
  850. }
  851.  
  852. static void  BPL1MOD(UWORD v)
  853. {
  854.     v &= ~1;
  855.     if (bpl1mod == v)
  856.     return;
  857.     pfield_may_need_update(0); 
  858.     bpl1mod = v;
  859. }
  860. static void  BPL2MOD(UWORD v)
  861. { 
  862.     v &= ~1;
  863.     if (bpl2mod == v)
  864.     return;
  865.     pfield_may_need_update(0); 
  866.     bpl2mod = v;
  867. }
  868.  
  869. static void  BPL1DAT(UWORD v) { bpl1dat = v; }
  870. static void  BPL2DAT(UWORD v) { bpl2dat = v; }
  871. static void  BPL3DAT(UWORD v) { bpl3dat = v; }
  872. static void  BPL4DAT(UWORD v) { bpl4dat = v; }
  873. static void  BPL5DAT(UWORD v) { bpl5dat = v; }
  874. static void  BPL6DAT(UWORD v) { bpl6dat = v; }
  875.  
  876. /* We call pfield_may_need_update() from here. Actually, 
  877.  * I have no idea what happens if someone changes ddf or
  878.  * diw mid-line, and I don't really want to know. I doubt
  879.  * that this sort of thing was ever used to create a
  880.  * useful effect.
  881.  */
  882. static void  DIWSTRT(UWORD v) 
  883. {
  884.     if (bpl_info.diwstrt == v)
  885.     return;
  886.     pfield_may_need_update(0);
  887.     bpl_info.diwstrt = v; 
  888.     calcdiw();
  889. }
  890. static void  DIWSTOP(UWORD v)
  891. {
  892.     if (bpl_info.diwstop == v)
  893.     return;
  894.     pfield_may_need_update(0);
  895.     bpl_info.diwstop = v; 
  896.     calcdiw();
  897. }
  898. static void  DDFSTRT(UWORD v)
  899. { 
  900.     if (bpl_info.ddfstrt == v)
  901.     return;
  902.     pfield_may_need_update(0);
  903.     bpl_info.ddfstrt = v; 
  904.     calcdiw();
  905. }
  906. static void  DDFSTOP(UWORD v) 
  907. { 
  908.     if (bpl_info.ddfstop == v)
  909.     return;
  910.     pfield_may_need_update(0); 
  911.     bpl_info.ddfstop = v;
  912.     calcdiw();
  913. }
  914.  
  915. static void  BLTADAT(UWORD v) 
  916. {
  917.     maybe_blit(); 
  918.     blt_info.bltadat = v; 
  919. }
  920. static void  BLTBDAT(UWORD v)
  921. {
  922.     maybe_blit(); 
  923.     blt_info.bltbdat = v; 
  924. }
  925. static void  BLTCDAT(UWORD v) { maybe_blit(); blt_info.bltcdat = v; }
  926.  
  927. static void  BLTAMOD(UWORD v) { maybe_blit(); blt_info.bltamod = v & 0xFFFE; }
  928. static void  BLTBMOD(UWORD v) { maybe_blit(); blt_info.bltbmod = v & 0xFFFE; }
  929. static void  BLTCMOD(UWORD v) { maybe_blit(); blt_info.bltcmod = v & 0xFFFE; }
  930. static void  BLTDMOD(UWORD v) { maybe_blit(); blt_info.bltdmod = v & 0xFFFE; }
  931.  
  932. static void  BLTCON0(UWORD v) { maybe_blit(); bltcon0 = v; }
  933. /* The next category is "Most useless hardware register". 
  934.  * And the winner is... */
  935. static void  BLTCON0L(UWORD v) { maybe_blit(); bltcon0 = (bltcon0 & 0xFF00) | (v & 0xFF); }
  936. static void  BLTCON1(UWORD v) { maybe_blit(); bltcon1 = v; }
  937.  
  938. static void  BLTAFWM(UWORD v) { maybe_blit(); blt_info.bltafwm = v; }
  939. static void  BLTALWM(UWORD v) { maybe_blit(); blt_info.bltalwm = v; }
  940.  
  941. static void  BLTAPTH(UWORD v) { maybe_blit(); bltapt= (bltapt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  942. static void  BLTAPTL(UWORD v) { maybe_blit(); bltapt= (bltapt & ~0xffff) | (v & 0xFFFE); }
  943. static void  BLTBPTH(UWORD v) { maybe_blit(); bltbpt= (bltbpt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  944. static void  BLTBPTL(UWORD v) { maybe_blit(); bltbpt= (bltbpt & ~0xffff) | (v & 0xFFFE); }
  945. static void  BLTCPTH(UWORD v) { maybe_blit(); bltcpt= (bltcpt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  946. static void  BLTCPTL(UWORD v) { maybe_blit(); bltcpt= (bltcpt & ~0xffff) | (v & 0xFFFE); }
  947. static void  BLTDPTH(UWORD v) { maybe_blit(); bltdpt= (bltdpt & 0xffff) | ((ULONG)(v & 0x1F) << 16); }
  948. static void  BLTDPTL(UWORD v) { maybe_blit(); bltdpt= (bltdpt & ~0xffff) | (v & 0xFFFE); }
  949. static void  BLTSIZE(UWORD v) 
  950. {
  951.     bltsize = v;
  952.     
  953.     maybe_blit(); 
  954.  
  955.     blt_info.vblitsize = bltsize >> 6;
  956.     blt_info.hblitsize = bltsize & 0x3F;
  957.     if (!blt_info.vblitsize) blt_info.vblitsize = 1024;
  958.     if (!blt_info.hblitsize) blt_info.hblitsize = 64;
  959.     
  960.     bltstate = BLT_init; 
  961.     specialflags |= SPCFLAG_BLIT; 
  962. }
  963. static void BLTSIZV(UWORD v) 
  964. {
  965.     maybe_blit(); 
  966.     oldvblts = v & 0x7FFF;
  967. }
  968. static void BLTSIZH(UWORD v) 
  969. {
  970.     maybe_blit(); 
  971.     blt_info.hblitsize = v & 0x7FF;
  972.     blt_info.vblitsize = oldvblts;
  973.     if (!blt_info.vblitsize) blt_info.vblitsize = 32768;
  974.     if (!blt_info.hblitsize) blt_info.hblitsize = 0x800;
  975.     bltstate = BLT_init; 
  976.     specialflags |= SPCFLAG_BLIT;
  977. }
  978. static void  SPRxCTL_1(UWORD v, int num)
  979. {
  980.     bpl_info.sprctl[num] = v;
  981.     bpl_info.sprarmed[num] = 0;
  982.     if (bpl_info.sprpos[num] == 0 && v == 0)
  983.     spron[num] = 0;
  984.     else
  985.     spron[num] |= 2;
  986. }
  987. static void  SPRxPOS_1(UWORD v, int num) 
  988. {
  989.     bpl_info.sprpos[num] = v; 
  990. }
  991. static void  SPRxDATA_1(UWORD v, int num)
  992. {
  993.     bpl_info.sprdata[num] = v;
  994.     bpl_info.sprarmed[num] = 1; 
  995. }
  996. static void  SPRxDATB_1(UWORD v, int num) 
  997. {
  998.     bpl_info.sprdatb[num] = v;
  999. }
  1000. static void  SPRxCTL(UWORD v, int num) { pfield_may_need_update(0); SPRxCTL_1(v, num); }
  1001. static void  SPRxPOS(UWORD v, int num) { pfield_may_need_update(0); SPRxPOS_1(v, num); }
  1002. static void  SPRxDATA(UWORD v, int num){ pfield_may_need_update(0); SPRxDATA_1(v, num); }
  1003. static void  SPRxDATB(UWORD v, int num){ pfield_may_need_update(0); SPRxDATB_1(v, num); }
  1004. static void  SPRxPTH(UWORD v, int num)
  1005. {
  1006.     sprpt[num] &= 0xffff; 
  1007.     sprpt[num] |= (ULONG)v << 16; 
  1008.     if (!spron[num]) spron[num] = 1; 
  1009. }
  1010. static void  SPRxPTL(UWORD v, int num)
  1011. {
  1012.     sprpt[num] &= ~0xffff; 
  1013.     sprpt[num] |= v; 
  1014.     if (!spron[num]) spron[num] = 1; 
  1015. }
  1016.  
  1017. static void  COLOR(UWORD v, int num)
  1018. {
  1019.     int r,g,b;
  1020.     int cr,cg,cb;
  1021.     int colreg;
  1022.     
  1023.     v &= 0xFFF;
  1024. #if AGA_CHIPSET == 1
  1025.     {
  1026.     ULONG cval;
  1027.     colreg = ((bpl_info.bplcon3 >> 13) & 7) * 32 + num;
  1028.     r = (v & 0xF00) >> 8;
  1029.     g = (v & 0xF0) >> 4;
  1030.     b = (v & 0xF) >> 0;
  1031.     cr = bpl_info.color_regs[colreg] >> 16;
  1032.     cg = (bpl_info.color_regs[colreg] >> 8) & 0xFF;
  1033.     cb = bpl_info.color_regs[colreg] & 0xFF;
  1034.  
  1035.     if (bpl_info.bplcon3 & 0x200) {
  1036.         cr &= 0xF0; cr |= r;
  1037.         cg &= 0xF0; cg |= g;
  1038.         cb &= 0xF0; cb |= b;
  1039.     } else {
  1040.         cr = r + (r << 4);
  1041.         cg = g + (g << 4);
  1042.         cb = b + (b << 4);
  1043.     }
  1044.     cval = (cr << 16) | (cg << 8) | cb;
  1045.     if (cval == bpl_info.color_regs[colreg])
  1046.         return;
  1047.     bpl_info.color_regs[colreg] = cval;
  1048.     pfield_may_need_update(1);
  1049.     }
  1050. #else 
  1051.     {
  1052.     if (bpl_info.color_regs[num] == v)
  1053.         return;
  1054.     pfield_may_need_update(1);
  1055.     bpl_info.color_regs[num] = v;
  1056.     acolors[num] = xcolors[v];
  1057.     acolors[num+32] = xcolors[(v >> 1) & 0x777];
  1058.     }
  1059. #endif
  1060. }
  1061.  
  1062. static void  DSKSYNC(UWORD v) { dsksync = v; }
  1063. static void  DSKDAT(UWORD v) { fprintf(stderr, "DSKDAT written. Not good.\n"); }
  1064. static void  DSKPTH(UWORD v) { dskpt = (dskpt & 0xffff) | ((ULONG)v << 16); }
  1065. static void  DSKPTL(UWORD v) { dskpt = (dskpt & ~0xffff) | (v); }
  1066.  
  1067. static void  DSKLEN(UWORD v) 
  1068. {
  1069.     if (v & 0x8000) {
  1070.     dskdmaen++; 
  1071.     } else { 
  1072.     dskdmaen = 0;
  1073.     if (eventtab[ev_diskblk].active)
  1074.         fprintf(stderr, "warning: Disk DMA aborted!\n");
  1075.     eventtab[ev_diskblk].active = 0;
  1076.     events_schedule();
  1077.     
  1078.     }
  1079.     dsklen = dsklength = v; dsklength &= 0x3fff;
  1080.     if (dskdmaen == 2 && dsksync != 0x4489 && (adkcon & 0x400)) {
  1081.     fprintf(stderr, "Non-standard sync: %04x len: %x\n", dsksync, dsklength);
  1082.     }
  1083.     if (dskdmaen > 1) {
  1084.     if (dsklen & 0x4000) {
  1085.         eventtab[ev_diskblk].active = 1;
  1086.         eventtab[ev_diskblk].oldcycles = cycles;
  1087.         eventtab[ev_diskblk].evtime = 40; /* ??? */
  1088.         events_schedule();
  1089.     } else {
  1090.         int result = DISK_PrepareReadMFM(dsklength, dsksync, adkcon & 0x400);
  1091.         if (result) {
  1092.         eventtab[ev_diskblk].active = 1;
  1093.         eventtab[ev_diskblk].oldcycles = cycles;
  1094.         eventtab[ev_diskblk].evtime = result;
  1095.         events_schedule();
  1096.         }
  1097.     }
  1098.     }
  1099. }
  1100.  
  1101. static UWORD DSKBYTR(void)
  1102. {
  1103.     UWORD v = (dsklen >> 1) & 0x6000;
  1104.     UWORD mfm, byte;
  1105.     if (DISK_GetData(&mfm, &byte))
  1106.     v |= 0x8000;
  1107.     v |= byte;
  1108.     if (dsksync == mfm) v |= 0x1000;
  1109.     return v;
  1110. }
  1111.  
  1112. static UWORD DSKDATR(void) 
  1113. {
  1114.     UWORD mfm, byte;
  1115.     DISK_GetData(&mfm, &byte);
  1116.     return mfm; 
  1117. }
  1118. static UWORD POTGOR(void)
  1119. {
  1120.     UWORD v = 0xFFFF;
  1121.     if (buttonstate[2])
  1122.     v &= 0xFBFF;
  1123.  
  1124.     if (buttonstate[1])
  1125.     v &= 0xFEFF;
  1126.     
  1127.     return v;
  1128. }
  1129. static UWORD POT0DAT(void)
  1130. {
  1131.     static UWORD cnt = 0;
  1132.     if (buttonstate[2])
  1133.     cnt = ((cnt + 1) & 0xFF) | (cnt & 0xFF00);
  1134.     if (buttonstate[1])
  1135.     cnt += 0x100;
  1136.     
  1137.     return cnt;
  1138. }
  1139. static UWORD JOY0DAT(void) { return joy0x + (joy0y << 8); }
  1140. static UWORD JOY1DAT(void)
  1141. {
  1142.     return joy0dir;
  1143. }
  1144. static void JOYTEST(UWORD v)
  1145. {
  1146.     joy0x = joy1x = v & 0xFC;
  1147.     joy0y = joy1y = (v >> 8) & 0xFC;    
  1148. }
  1149. static void AUD0LCH(UWORD v) { audlc[0] = (audlc[0] & 0xffff) | ((ULONG)v << 16); }
  1150. static void AUD0LCL(UWORD v) { audlc[0] = (audlc[0] & ~0xffff) | v; }
  1151. static void AUD1LCH(UWORD v) { audlc[1] = (audlc[1] & 0xffff) | ((ULONG)v << 16); }
  1152. static void AUD1LCL(UWORD v) { audlc[1] = (audlc[1] & ~0xffff) | v; }
  1153. static void AUD2LCH(UWORD v) { audlc[2] = (audlc[2] & 0xffff) | ((ULONG)v << 16); }
  1154. static void AUD2LCL(UWORD v) { audlc[2] = (audlc[2] & ~0xffff) | v; }
  1155. static void AUD3LCH(UWORD v) { audlc[3] = (audlc[3] & 0xffff) | ((ULONG)v << 16); }
  1156. static void AUD3LCL(UWORD v) { audlc[3] = (audlc[3] & ~0xffff) | v; }
  1157. static void AUD0PER(UWORD v) { audper[0] = v; }
  1158. static void AUD1PER(UWORD v) { audper[1] = v; }
  1159. static void AUD2PER(UWORD v) { audper[2] = v; }
  1160. static void AUD3PER(UWORD v) { audper[3] = v; }
  1161. static void AUD0VOL(UWORD v) { audvol[0] = v & 64 ? 63 : v & 63; }
  1162. static void AUD1VOL(UWORD v) { audvol[1] = v & 64 ? 63 : v & 63; }
  1163. static void AUD2VOL(UWORD v) { audvol[2] = v & 64 ? 63 : v & 63; }
  1164. static void AUD3VOL(UWORD v) { audvol[3] = v & 64 ? 63 : v & 63; }
  1165. static void AUD0LEN(UWORD v) { audlen[0] = v; }
  1166. static void AUD1LEN(UWORD v) { audlen[1] = v; }
  1167. static void AUD2LEN(UWORD v) { audlen[2] = v; }
  1168. static void AUD3LEN(UWORD v) { audlen[3] = v; }
  1169.  
  1170. static UWORD SERDATR(void) { return 0; }
  1171.  
  1172. static int copcomp(void)
  1173. {
  1174.     UWORD vp = vpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1175.     UWORD hp = current_hpos() & (copi2 & 0xFE);
  1176.     UWORD vcmp = copi1 >> 8;
  1177.     UWORD hcmp = copi1 & 0xFE;
  1178.     return (vp > vcmp || (vp == vcmp && hp >= hcmp)) && ((copi2 & 0x8000) || !(DMACONR() & 0x4000));
  1179. }
  1180.  
  1181. /*
  1182.  * Calculate the minimum number of cycles after which the
  1183.  * copper comparison becomes true. This is quite tricky. I hope it works.
  1184.  */
  1185. static int calc_copcomp_true(int currvpos, int currhpos)
  1186. {    
  1187.     UWORD vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1188.     UWORD hp = currhpos & (copi2 & 0xFE);
  1189.     UWORD vcmp = copi1 >> 8;
  1190.     UWORD hcmp = copi1 & 0xFE;
  1191.     int copper_time_hpos;
  1192.     int cycleadd = maxhpos - currhpos;
  1193.     int coptime = 0;
  1194.  
  1195.     if ((vp > vcmp || (vp == vcmp && hp >= hcmp)) && ((copi2 & 0x8000) || !(DMACONR() & 0x4000)))
  1196.         return 0;    
  1197.  
  1198.     try_again:
  1199.  
  1200.     while (vp < vcmp) {
  1201.     currvpos++;
  1202.     if (currvpos > maxvpos + 1)
  1203.         return -1;
  1204.     currhpos = 0;
  1205.     coptime += cycleadd;
  1206.     cycleadd = maxhpos;
  1207.     vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1208.     }
  1209.     if (coptime > 0 && bplhires && bplplanecnt == 4)
  1210.     return coptime;
  1211.     copper_time_hpos = currhpos;
  1212.     hp = copper_time_hpos & (copi2 & 0xFE);
  1213.     if (!(vp > vcmp)) {    
  1214.     while (hp < hcmp-2) {
  1215.         currhpos++;
  1216.         /* Copper DMA is turned off in Hires 4 bitplane mode */
  1217.         if (!bplhires || bplplanecnt < 4 || !dmaen(DMA_BITPLANE)
  1218.         || currhpos < plfstrt-2 || currhpos > (plfstop+4))
  1219.         copper_time_hpos++;
  1220.         
  1221.         if (currhpos > maxhpos-4) {
  1222.         /* Now, what? There might be a good position on the
  1223.          * next line. But it can also be the FFFF FFFE
  1224.          * case.
  1225.          */
  1226.         currhpos = 0;
  1227.         currvpos++;
  1228.         vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  1229.         goto try_again;
  1230.         }
  1231.         coptime++;
  1232.         hp = copper_time_hpos & (copi2 & 0xFE);
  1233.     }
  1234.     }
  1235.     if (coptime == 0) /* waiting for the blitter */
  1236.         return 1;
  1237.  
  1238.     return coptime;
  1239. }
  1240.  
  1241. static void copper_read(void)
  1242. {
  1243.     if (dmaen(DMA_COPPER)){
  1244.     copi1 = chipmem_bank.wget(coplc); 
  1245.     copi2 = chipmem_bank.wget(coplc+2);
  1246.     coplc += 4;
  1247.     eventtab[ev_copper].oldcycles = cycles;
  1248.     eventtab[ev_copper].evtime = (copi1 & 1) ? (copi2 & 1) ? 10 : 8 : 4;
  1249.     copstate = (copi1 & 1) ? (copi2 & 1) ? COP_skip : COP_wait : COP_move;
  1250.     } else {
  1251.     copstate = COP_read;
  1252.     eventtab[ev_copper].active = 0;
  1253.     }
  1254. }
  1255.  
  1256. static void do_copper(void)
  1257. {    
  1258.     switch(copstate){
  1259.      case COP_read:
  1260.     copper_read();
  1261.     break;
  1262.      case COP_move:
  1263.     if (copi1 >= (copcon & 2 ? 0x40 : 0x80)) {
  1264.         custom_bank.wput(copi1,copi2);
  1265.         copper_read();
  1266.     } else {
  1267.         copstate = COP_stop;
  1268.         eventtab[ev_copper].active = 0;
  1269.         copper_active = 0;
  1270.     }
  1271.     break;
  1272.      case COP_skip:
  1273.     if (calc_copcomp_true(vpos, current_hpos()) == 0)
  1274.         coplc += 4;
  1275.     copper_read();
  1276.     break;
  1277.      case COP_wait: {        
  1278.      int coptime = calc_copcomp_true(vpos, current_hpos());
  1279.      if (coptime < 0) {
  1280.          copstate = COP_stop;
  1281.          eventtab[ev_copper].active = 0;
  1282.          copper_active = 0;
  1283.      } else {         
  1284.          if (!coptime)
  1285.               copper_read();
  1286.          else {
  1287.          eventtab[ev_copper].evtime = coptime;
  1288.          eventtab[ev_copper].oldcycles = cycles;
  1289.          }
  1290.      }
  1291.      break;
  1292.      }
  1293.      case COP_stop:
  1294.     eventtab[ev_copper].active = 0;
  1295.     copper_active = 0;
  1296.     break;
  1297.     }
  1298. }
  1299.  
  1300. static void diskblk_handler(void)
  1301. {
  1302.     specialflags |= SPCFLAG_DISK;
  1303.     eventtab[ev_diskblk].active = 0;
  1304. }
  1305.  
  1306. void do_disk(void)
  1307. {
  1308.     if (dskdmaen != 2 && (specialflags & SPCFLAG_DISK)) {
  1309.         static int warned=0;
  1310.     if(!warned) {fprintf(stderr, "BUG!\n");warned=1;return;}
  1311.     }
  1312.     if (dmaen(0x10)){
  1313.     if (dsklen & 0x4000) {
  1314.         if (!chipmem_bank.check (dskpt, 2*dsklength)) {
  1315.         fprintf(stderr, "warning: Bad disk write DMA pointer\n");
  1316.         } else {
  1317.         UWORD *mfmp = get_real_address (dskpt);
  1318.         DISK_InitWrite();
  1319.         memcpy (mfmwrite, mfmp, 2*dsklength);
  1320.         DISK_WriteData(dsklength);
  1321.         }
  1322.     } else {
  1323.         int result = DISK_ReadMFM (dskpt);
  1324.     }
  1325.     specialflags &= ~SPCFLAG_DISK;
  1326.     INTREQ(0x9002);
  1327.     dskdmaen = -1;
  1328.     }
  1329. }
  1330.  
  1331. static __inline__ void pfield_fetchdata(void)
  1332. {
  1333.     if (dmaen(0x100) && pfield_linedmaon) {
  1334.     switch(bplplanecnt){
  1335.      case 8:
  1336.         bpl8dat = chipmem_bank.wget(bplpt[7]); bplpt[7] += 2; bpl8dat <<= 7;
  1337.      case 7:
  1338.         bpl7dat = chipmem_bank.wget(bplpt[6]); bplpt[6] += 2; bpl7dat <<= 6;
  1339.      case 6:
  1340.         bpl6dat = chipmem_bank.wget(bplpt[5]); bplpt[5] += 2; bpl6dat <<= 5;
  1341.      case 5:
  1342.         bpl5dat = chipmem_bank.wget(bplpt[4]); bplpt[4] += 2; bpl5dat <<= 4;
  1343.      case 4:
  1344.         bpl4dat = chipmem_bank.wget(bplpt[3]); bplpt[3] += 2; bpl4dat <<= 3;
  1345.      case 3:
  1346.         bpl3dat = chipmem_bank.wget(bplpt[2]); bplpt[2] += 2; bpl3dat <<= 2;
  1347.      case 2:
  1348.         bpl2dat = chipmem_bank.wget(bplpt[1]); bplpt[1] += 2; bpl2dat <<= 1;
  1349.      case 1:
  1350.         bpl1dat = chipmem_bank.wget(bplpt[0]); bplpt[0] += 2;
  1351.     }
  1352.     }
  1353. }
  1354.  
  1355. static void do_sprites(int currvp, int currhp)
  1356. {   
  1357.     int i;
  1358.     int maxspr = currhp/4 -0x18/ 4;
  1359.     
  1360.     if (currvp == 0)
  1361.     return;
  1362.     if (maxspr < 0)
  1363.     return;
  1364.     if (maxspr > 7)
  1365.     maxspr = 7;
  1366.     
  1367.     for(i = last_sprite; i <= maxspr; i++) {
  1368.     int vstart = (bpl_info.sprpos[i] >> 8) | ((bpl_info.sprctl[i] << 6) & 0x100);
  1369.     int vstop = (bpl_info.sprctl[i] >> 8) | ((bpl_info.sprctl[i] << 7) & 0x100);
  1370.     if ((vstart <= currvp && vstop >= currvp) || spron[i] == 1) {
  1371.         if (dmaen(0x20)) {
  1372.         UWORD data1 = chipmem_bank.wget(sprpt[i]);
  1373.         UWORD data2 = chipmem_bank.wget(sprpt[i]+2);
  1374.         sprpt[i] += 4;
  1375.         
  1376.         if (vstop != currvp && spron[i] != 1) {
  1377.             /* Hack for X mouse auto-calibration */
  1378.             if (i == 0 && !sprvbfl && ((bpl_info.sprpos[0]&0xff)<<2)>0x60) {
  1379.             int old0ctl = spr0ctl, old0pos = spr0pos;
  1380.             spr0ctl=bpl_info.sprctl[0];
  1381.             spr0pos=bpl_info.sprpos[0];
  1382.             sprvbfl=2;
  1383.             }
  1384.             SPRxDATB_1(data2, i);
  1385.             SPRxDATA_1(data1, i);
  1386.         } else {
  1387.             SPRxPOS_1(data1, i);
  1388.             SPRxCTL_1(data2, i);
  1389.         }
  1390.         }
  1391.     }
  1392.     }
  1393.     last_sprite = maxspr + 1;
  1394. }
  1395.  
  1396. static __inline__ void pfield_modulos(int add)
  1397. {
  1398.     switch(bplplanecnt){
  1399.      case 8:
  1400.     bplpt[7] += add + bpl2mod;
  1401.      case 7:
  1402.     bplpt[6] += add + bpl1mod;
  1403.      case 6:
  1404.     bplpt[5] += add + bpl2mod;
  1405.      case 5:
  1406.     bplpt[4] += add + bpl1mod;
  1407.      case 4:
  1408.     bplpt[3] += add + bpl2mod;
  1409.      case 3:
  1410.     bplpt[2] += add + bpl1mod;
  1411.      case 2:
  1412.     bplpt[1] += add + bpl2mod;
  1413.      case 1:
  1414.     bplpt[0] += add + bpl1mod;
  1415.     }
  1416. }
  1417.  
  1418. #if AGA_CHIPSET == 0
  1419. static void pfield_sprite (int num, int sprxp, UWORD data, UWORD datb, int lores)
  1420. {
  1421.     int i;
  1422.  
  1423.     int *lookup = bpldualpf ? (bpldualpfpri ? dblpf_ind2 : dblpf_ind1) : linear_map_256;
  1424.     int *lookup_no = bpldualpf ? (bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1) : lots_of_twos;
  1425.  
  1426.     for(i = 15; i >= 0; i--, data >>= 1, datb >>= 1) {
  1427.     int sprxpos = sprxp + i*(lores ? 1 : 2);
  1428.     int plno;
  1429.     int col;
  1430.  
  1431.     /* When doing the slow line update, the following condition can
  1432.      * happen. Lower-numbered sprites get the higher priority. */
  1433.     if (spixstate[sprxpos] & ((1 << num)-1))
  1434.         continue;
  1435.  
  1436.     /* Check the priority, but only if we did not already put a sprite
  1437.      * pixel at this position. If there's already a sprite pixel here, 
  1438.      * the priority was previously tested. */
  1439.     if (!spixstate[sprxpos]) {
  1440.         /* ??? What about hires mode when one hires pixel is 0, enabling the
  1441.          * sprite, and the other is != 0, blocking it? */
  1442.         plno = lookup_no[pixdata.apixels[sprxpos]];
  1443.         if (plno != 0 && (1 << num) >= plfpri[plno])
  1444.         continue;
  1445.     }
  1446.  
  1447.     if ((bpl_info.sprctl[num] & 0x80) && (num & 1)) {
  1448.         /* Attached sprite */
  1449.         col = ((data << 2) & 4) + ((datb << 3) & 8);
  1450.         spixstate[sprxpos] |= 1 << (num-1);
  1451.         spixels[sprxpos] = col;
  1452.     } else {            
  1453.         col = (data & 1) | ((datb << 1) & 2);
  1454.         if (spixstate[sprxpos] & (1 << num)) {
  1455.         /* Finish attached sprite */
  1456.         /* Did the upper half of the sprite have any bits set? */
  1457.         if (spixstate[sprxpos] & (1 << (num+1)))
  1458.             col += spixels[sprxpos];
  1459.         /* Is there any sprite pixel at this position at all? */
  1460.         if (!col) {
  1461.             spixstate[sprxpos] &= ~(3 << num);
  1462.         } else
  1463.             col += 16;
  1464.         } else {
  1465.         if (col) {
  1466.             col |= 16 | ((num & 6) << 1);
  1467.         }
  1468.         }
  1469.     }
  1470.     if (col) {
  1471.         pixdata.apixels[sprxpos] = col;
  1472.         spixstate[sprxpos] |= 1<<num;
  1473.         if (!lores) {
  1474.         pixdata.apixels[sprxpos+1] = col;
  1475.         spixstate[sprxpos+1] |= 1<<num;
  1476.         }
  1477.         if (bplham && bplplanecnt == 6) {
  1478.         ham_linebuf[sprxpos] = bpl_info.color_regs[col];
  1479.         if (!lores)
  1480.             ham_linebuf[sprxpos+1] = bpl_info.color_regs[col];
  1481.         }
  1482.     }
  1483.     }
  1484. }
  1485. #else /* AGA version */
  1486. static void pfield_sprite (int num, int sprxp, UWORD data, UWORD datb, int lores)
  1487. {
  1488.     int i;
  1489.  
  1490.     int *lookup = bpldualpf ? (bpldualpfpri ? dblpf_ind2 : dblpf_ind1) : linear_map_256;
  1491.     int *lookup_no = bpldualpf ? (bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1) : lots_of_twos;
  1492.  
  1493.     for(i = 15; i >= 0; i--, data >>= 1, datb >>= 1) {
  1494.     int sprxpos = sprxp + i*(lores ? 1 : 2);
  1495.     int plno;
  1496.     int col;
  1497.  
  1498.     /* When doing the slow line update, the following condition can
  1499.      * happen. Lower-numbered sprites get the higher priority. */
  1500.     if (spixstate[sprxpos] & ((1 << num)-1))
  1501.         continue;
  1502.  
  1503.     /* Check the priority, but only if we did not already put a sprite
  1504.      * pixel at this position. If there's already a sprite pixel here, 
  1505.      * the priority was previously tested. */
  1506.     if (!spixstate[sprxpos]) {
  1507.         /* ??? What about hires mode when one hires pixel is 0, enabling the
  1508.          * sprite, and the other is != 0, blocking it? */
  1509.         plno = lookup_no[pixdata.apixels[sprxpos]];
  1510.         if (plno != 0 && (1 << num) >= plfpri[plno])
  1511.         continue;
  1512.     }
  1513.  
  1514.     if ((bpl_info.sprctl[num] & 0x80) && (num & 1)) {
  1515.         /* Attached sprite */
  1516.         col = ((data << 2) & 4) + ((datb << 3) & 8);
  1517.         spixstate[sprxpos] |= 1 << (num-1);
  1518.         spixels[sprxpos] = col;
  1519.     } else {            
  1520.         col = (data & 1) | ((datb << 1) & 2);
  1521.         if (spixstate[sprxpos] & (1 << num)) {
  1522.         /* Finish attached sprite */
  1523.         /* Did the upper half of the sprite have any bits set? */
  1524.         if (spixstate[sprxpos] & (1 << (num+1)))
  1525.             col += spixels[sprxpos];
  1526.         /* Is there any sprite pixel at this position at all? */
  1527.         if (!col) {
  1528.             spixstate[sprxpos] &= ~(3 << num);
  1529.         } else
  1530.             col += ((bpl_info.bplcon4 << (num & 1 ? 4 : 0)) & 240);
  1531.         } else {
  1532.         if (col) {
  1533.             col |= ((bpl_info.bplcon4 << (num & 1 ? 4 : 0)) & 240) | ((num & 6) << 1);
  1534.         }
  1535.         }
  1536.     }
  1537.     if (col) {
  1538.         pixdata.apixels[sprxpos] = col;
  1539.         spixstate[sprxpos] |= 1<<num;
  1540.         if (!lores) {
  1541.         pixdata.apixels[sprxpos+1] = col;
  1542.         spixstate[sprxpos+1] |= 1<<num;
  1543.         }
  1544.         if (bplham && bplplanecnt == 6) {
  1545.         ham_linebuf[sprxpos] = bpl_info.color_regs[col];
  1546.         if (!lores)
  1547.             ham_linebuf[sprxpos+1] = bpl_info.color_regs[col];
  1548.         }
  1549.     }
  1550.     }
  1551. }
  1552. #endif
  1553.  
  1554. static __inline__ UWORD *pfield_xlateptr(CPTR plpt, int bytecount)
  1555. {
  1556.     if (!chipmem_bank.check(plpt,bytecount)) {
  1557.     static int count = 0;
  1558.     if (count < 5) {
  1559.         count++;
  1560.         fprintf(stderr, "Warning: Bad playfield pointer");
  1561.         if (count == 5) fprintf(stderr, " (no further warnings)");
  1562.         fprintf(stderr, "\n");
  1563.     }
  1564.     return NULL;
  1565.     }
  1566.     return chipmem_bank.xlateaddr(plpt);
  1567. }
  1568.  
  1569. static void pfield_doline_slow_h(int currhpos)
  1570. {
  1571.     int xpos = currhpos * 4 - 0x60;
  1572.         
  1573.     if (bplhires) {
  1574.     int offs1 = xpos + 16 + bpldelay1*2;
  1575.     int offs2 = xpos + 16 + bpldelay2*2;
  1576.     
  1577.     int pix;
  1578.     for(pix = 15; pix >= 0; pix--) {
  1579.         switch(bplplanecnt) {
  1580.          case 8:
  1581.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80; bpl8dat >>= 1;
  1582.          case 7:
  1583.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; bpl7dat >>= 1;
  1584.          case 6:
  1585.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20; bpl6dat >>= 1;
  1586.          case 5:
  1587.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10; bpl5dat >>= 1;
  1588.          case 4:
  1589.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8; bpl4dat >>= 1;
  1590.          case 3:
  1591.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; bpl3dat >>= 1;
  1592.          case 2:
  1593.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; bpl2dat >>= 1;
  1594.          case 1:
  1595.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; bpl1dat >>= 1;
  1596.         }
  1597.     }
  1598.     } else {
  1599.     int offs1 = xpos + 32 + bpldelay1*2;
  1600.     int offs2 = xpos + 32 + bpldelay2*2;
  1601.     
  1602.     int pix;
  1603.     for(pix = 30; pix >= 0; pix -= 2) {
  1604.         switch(bplplanecnt) {
  1605.          case 8:
  1606.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80;
  1607.         pixdata.apixels[pix + offs2 + 1] |= bpl8dat & 0x80; bpl8dat >>= 1;
  1608.          case 7:
  1609.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; 
  1610.         pixdata.apixels[pix + offs1 + 1] |= bpl7dat & 0x40; bpl7dat >>= 1;
  1611.          case 6:
  1612.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20;
  1613.         pixdata.apixels[pix + offs2 + 1] |= bpl6dat & 0x20; bpl6dat >>= 1;
  1614.          case 5:
  1615.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10;
  1616.         pixdata.apixels[pix + offs1 + 1] |= bpl5dat & 0x10; bpl5dat >>= 1;
  1617.          case 4:
  1618.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8;
  1619.         pixdata.apixels[pix + offs2 + 1] |= bpl4dat & 0x8; bpl4dat >>= 1;
  1620.          case 3:
  1621.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; 
  1622.         pixdata.apixels[pix + offs1 + 1] |= bpl3dat & 0x4; bpl3dat >>= 1;
  1623.          case 2:
  1624.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; 
  1625.         pixdata.apixels[pix + offs2 + 1] |= bpl2dat & 0x2; bpl2dat >>= 1;
  1626.          case 1:
  1627.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; 
  1628.         pixdata.apixels[pix + offs1 + 1] |= bpl1dat & 0x1; bpl1dat >>= 1;
  1629.         }
  1630.     }
  1631.     }    
  1632. }
  1633.  
  1634. static void pfield_doline_slow_l(int currhpos)
  1635. {
  1636.     int xpos = currhpos * 2 - 0x30;
  1637.     
  1638.     if (bplhires) {
  1639.     int offs1 = xpos + 8 + bpldelay1;
  1640.     int offs2 = xpos + 8 + bpldelay2;
  1641.     
  1642.     int pix;
  1643.     for(pix = 7; pix >= 0; pix--) {
  1644.         switch(bplplanecnt) {
  1645.          case 8:
  1646.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80; bpl8dat >>= 2;
  1647.          case 7:
  1648.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; bpl7dat >>= 2;
  1649.          case 6:
  1650.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20; bpl6dat >>= 2;
  1651.          case 5:
  1652.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10; bpl5dat >>= 2;
  1653.          case 4:
  1654.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8; bpl4dat >>= 2;
  1655.          case 3:
  1656.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; bpl3dat >>= 2;
  1657.          case 2:
  1658.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; bpl2dat >>= 2;
  1659.          case 1:
  1660.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; bpl1dat >>= 2;
  1661.         }
  1662.     }
  1663.     } else {
  1664.     int offs1 = xpos + 16 + bpldelay1;
  1665.     int offs2 = xpos + 16 + bpldelay2;
  1666.     
  1667.     int pix;
  1668.     for(pix = 15; pix >= 0; pix --) {
  1669.         switch(bplplanecnt) {
  1670.          case 8:
  1671.         pixdata.apixels[pix + offs2] |= bpl8dat & 0x80; bpl8dat >>= 1;
  1672.          case 7:
  1673.         pixdata.apixels[pix + offs1] |= bpl7dat & 0x40; bpl7dat >>= 1;
  1674.          case 6:
  1675.         pixdata.apixels[pix + offs2] |= bpl6dat & 0x20; bpl6dat >>= 1;
  1676.          case 5:
  1677.         pixdata.apixels[pix + offs1] |= bpl5dat & 0x10; bpl5dat >>= 1;
  1678.          case 4:
  1679.         pixdata.apixels[pix + offs2] |= bpl4dat & 0x8; bpl4dat >>= 1;
  1680.          case 3:
  1681.         pixdata.apixels[pix + offs1] |= bpl3dat & 0x4; bpl3dat >>= 1;
  1682.          case 2:
  1683.         pixdata.apixels[pix + offs2] |= bpl2dat & 0x2; bpl2dat >>= 1;
  1684.          case 1:
  1685.         pixdata.apixels[pix + offs1] |= bpl1dat & 0x1; bpl1dat >>= 1;
  1686.         }
  1687.     }
  1688.     }    
  1689. }
  1690.  
  1691. ULONG hirestab_h[256][2];
  1692. ULONG lorestab_h[256][4];
  1693.  
  1694. ULONG hirestab_l[256][1];
  1695. ULONG lorestab_l[256][2];
  1696.  
  1697. static void gen_pfield_tables(void)
  1698. {
  1699.     int i;
  1700.     union {
  1701.     struct {
  1702.         UBYTE a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
  1703.     } foo;
  1704.     struct {
  1705.         ULONG a, b, c, d;
  1706.     } bar;
  1707.     } baz;
  1708.     
  1709.     for (i = 0; i < 256; i++) {
  1710.     /* We lose every second pixel in HiRes if UAE runs in a 320x200 screen. */
  1711.     baz.foo.a = i & 64 ? 1 : 0;
  1712.     baz.foo.b = i & 16 ? 1 : 0;
  1713.     baz.foo.c = i & 4 ? 1 : 0;
  1714.     baz.foo.d = i & 1 ? 1 : 0;
  1715.     hirestab_l[i][0] = baz.bar.a;
  1716.     
  1717.     baz.foo.a = i & 128 ? 1 : 0;
  1718.     baz.foo.b = i & 64 ? 1 : 0;
  1719.     baz.foo.c = i & 32 ? 1 : 0;
  1720.     baz.foo.d = i & 16 ? 1 : 0;
  1721.     baz.foo.e = i & 8 ? 1 : 0;
  1722.     baz.foo.f = i & 4 ? 1 : 0;
  1723.     baz.foo.g = i & 2 ? 1 : 0;
  1724.     baz.foo.h = i & 1 ? 1 : 0;
  1725.     lorestab_l[i][0] = baz.bar.a;
  1726.     lorestab_l[i][1] = baz.bar.b;
  1727.     }
  1728.     
  1729.     for (i = 0; i < 256; i++) {
  1730.     baz.foo.a = i & 128 ? 1 : 0;
  1731.     baz.foo.b = i & 64 ? 1 : 0;
  1732.     baz.foo.c = i & 32 ? 1 : 0;
  1733.     baz.foo.d = i & 16 ? 1 : 0;
  1734.     baz.foo.e = i & 8 ? 1 : 0;
  1735.     baz.foo.f = i & 4 ? 1 : 0;
  1736.     baz.foo.g = i & 2 ? 1 : 0;
  1737.     baz.foo.h = i & 1 ? 1 : 0;
  1738.     hirestab_h[i][0] = baz.bar.a;
  1739.     hirestab_h[i][1] = baz.bar.b;
  1740.     
  1741.     baz.foo.a = i & 128 ? 1 : 0;
  1742.     baz.foo.b = i & 128 ? 1 : 0;
  1743.     baz.foo.c = i & 64 ? 1 : 0;
  1744.     baz.foo.d = i & 64 ? 1 : 0;
  1745.     baz.foo.e = i & 32 ? 1 : 0;
  1746.     baz.foo.f = i & 32 ? 1 : 0;
  1747.     baz.foo.g = i & 16 ? 1 : 0;
  1748.     baz.foo.h = i & 16 ? 1 : 0;
  1749.     baz.foo.i = i & 8 ? 1 : 0;
  1750.     baz.foo.j = i & 8 ? 1 : 0;
  1751.     baz.foo.k = i & 4 ? 1 : 0;
  1752.     baz.foo.l = i & 4 ? 1 : 0;
  1753.     baz.foo.m = i & 2 ? 1 : 0;
  1754.     baz.foo.n = i & 2 ? 1 : 0;
  1755.     baz.foo.o = i & 1 ? 1 : 0;
  1756.     baz.foo.p = i & 1 ? 1 : 0;
  1757.     lorestab_h[i][0] = baz.bar.a;
  1758.     lorestab_h[i][1] = baz.bar.b;
  1759.     lorestab_h[i][2] = baz.bar.c;
  1760.     lorestab_h[i][3] = baz.bar.d;
  1761.     }
  1762. }
  1763.  
  1764. static __inline__ void pfield_orword_hires_h(int data, unsigned char *dp, int bit)
  1765. {
  1766.     ULONG *pixptr = (ULONG *)dp;
  1767.  
  1768.     *pixptr |= hirestab_h[data >> 8][0] << bit;
  1769.     *(pixptr+1) |= hirestab_h[data >> 8][1] << bit;
  1770.     *(pixptr+2) |= hirestab_h[data & 255][0] << bit;
  1771.     *(pixptr+3) |= hirestab_h[data & 255][1] << bit;
  1772. }
  1773.  
  1774. static __inline__ void pfield_orword_lores_h(int data, unsigned char *dp, int bit)
  1775. {
  1776.     ULONG *pixptr = (ULONG *)dp;
  1777.  
  1778.     *pixptr |= lorestab_h[data >> 8][0] << bit;
  1779.     *(pixptr+1) |= lorestab_h[data >> 8][1] << bit;
  1780.     *(pixptr+2) |= lorestab_h[data >> 8][2] << bit;
  1781.     *(pixptr+3) |= lorestab_h[data >> 8][3] << bit;
  1782.     *(pixptr+4) |= lorestab_h[data & 255][0] << bit;
  1783.     *(pixptr+5) |= lorestab_h[data & 255][1] << bit;
  1784.     *(pixptr+6) |= lorestab_h[data & 255][2] << bit;
  1785.     *(pixptr+7) |= lorestab_h[data & 255][3] << bit;
  1786. }
  1787.  
  1788. static __inline__ void pfield_setword_hires_h(int data, unsigned char *dp, int bit)
  1789. {
  1790.     ULONG *pixptr = (ULONG *)dp;
  1791.  
  1792.     *pixptr = hirestab_h[data >> 8][0] << bit;
  1793.     *(pixptr+1) = hirestab_h[data >> 8][1] << bit;
  1794.     *(pixptr+2) = hirestab_h[data & 255][0] << bit;
  1795.     *(pixptr+3) = hirestab_h[data & 255][1] << bit;
  1796. }
  1797.  
  1798. static __inline__ void pfield_setword_lores_h(int data, unsigned char *dp, int bit)
  1799. {
  1800.     ULONG *pixptr = (ULONG *)dp;
  1801.  
  1802.     *pixptr = lorestab_h[data >> 8][0] << bit;
  1803.     *(pixptr+1) = lorestab_h[data >> 8][1] << bit;
  1804.     *(pixptr+2) = lorestab_h[data >> 8][2] << bit;
  1805.     *(pixptr+3) = lorestab_h[data >> 8][3] << bit;
  1806.     *(pixptr+4) = lorestab_h[data & 255][0] << bit;
  1807.     *(pixptr+5) = lorestab_h[data & 255][1] << bit;
  1808.     *(pixptr+6) = lorestab_h[data & 255][2] << bit;
  1809.     *(pixptr+7) = lorestab_h[data & 255][3] << bit;
  1810. }
  1811.  
  1812. static __inline__ void pfield_orword_hires_l(int data, unsigned char *dp, int bit)
  1813. {
  1814.     ULONG *pixptr = (ULONG *)dp;
  1815.  
  1816.     *pixptr |= hirestab_l[data >> 8][0] << bit;
  1817.     *(pixptr+1) |= hirestab_l[data & 255][0] << bit;
  1818. }
  1819.  
  1820. static __inline__ void pfield_orword_lores_l(int data, unsigned char *dp, int bit)
  1821. {
  1822.     ULONG *pixptr = (ULONG *)dp;
  1823.  
  1824.     *pixptr |= lorestab_l[data >> 8][0] << bit;
  1825.     *(pixptr+1) |= lorestab_l[data >> 8][1] << bit;
  1826.     *(pixptr+2) |= lorestab_l[data & 255][0] << bit;
  1827.     *(pixptr+3) |= lorestab_l[data & 255][1] << bit;
  1828. }
  1829.  
  1830. static __inline__ void pfield_setword_hires_l(int data, unsigned char *dp, int bit)
  1831. {
  1832.     ULONG *pixptr = (ULONG *)dp;
  1833.  
  1834.     *pixptr = hirestab_l[data >> 8][0] << bit;
  1835.     *(pixptr+1) = hirestab_l[data & 255][0] << bit;
  1836. }
  1837.  
  1838. static __inline__ void pfield_setword_lores_l(int data, unsigned char *dp, int bit)
  1839. {
  1840.     ULONG *pixptr = (ULONG *)dp;
  1841.  
  1842.     *pixptr = lorestab_l[data >> 8][0] << bit;
  1843.     *(pixptr+1) = lorestab_l[data >> 8][1] << bit;
  1844.     *(pixptr+2) = lorestab_l[data & 255][0] << bit;
  1845.     *(pixptr+3) = lorestab_l[data & 255][1] << bit;
  1846. }
  1847.  
  1848. #define DO_ONE_PLANE(POINTER, MULT, FUNC, DELAY, LL_SUB, P_ADD) { \
  1849.     int i; \
  1850.     unsigned int bpldat1; \
  1851.     UWORD data; \
  1852.     unsigned int bpldat2 = 0; \
  1853.     for (i = plflinelen; i > 0; i -= LL_SUB) { \
  1854.         bpldat1 = bpldat2; \
  1855.     bpldat2 = *POINTER++; \
  1856.     data = (bpldat1 << (16 - DELAY)) | (bpldat2 >> DELAY); \
  1857.     FUNC(data, app, MULT); \
  1858.     app += P_ADD; \
  1859.     } \
  1860.     data = bpldat2 << (16 - DELAY); \
  1861.     FUNC(data, app, MULT); \
  1862. }
  1863.  
  1864. #define DO_ONE_PLANE_B_LORES_H(NUM, FETCH) \
  1865.         if (bplplanecnt > NUM) { \
  1866.                     if (FETCH != 0) { \
  1867.             plfd[NUM] <<= 16; \
  1868.             if (FETCH == 1) \
  1869.                 plfd[NUM] |= *(r_bplpt[NUM])++ << delay[NUM & 1]; \
  1870.             d = plfd[NUM] >> 24; \
  1871.                     } else {\
  1872.             d = (plfd[NUM] >> 16) & 255; \
  1873.             }\
  1874.             if (NUM == 0) { \
  1875.             data1 = lorestab_h[d][0] << NUM;\
  1876.             data2 = lorestab_h[d][1] << NUM;\
  1877.             data3 = lorestab_h[d][2] << NUM;\
  1878.             data4 = lorestab_h[d][3] << NUM;\
  1879.             } else { \
  1880.             data1 |= lorestab_h[d][0] << NUM;\
  1881.             data2 |= lorestab_h[d][1] << NUM;\
  1882.             data3 |= lorestab_h[d][2] << NUM;\
  1883.             data4 |= lorestab_h[d][3] << NUM;\
  1884.             } \
  1885.         }
  1886.  
  1887. #if 1
  1888. static void pfield_doline_h(void)
  1889. {
  1890.     int xpos = plfstrt * 4 - 0x60;
  1891.     int spr, sprites_seen;
  1892.  
  1893.     if (bplhires) {
  1894.     if (bplplanecnt > 0) {
  1895.         int xpos1 = xpos + 16 + (bpldelay1 >= 8 ? 16 : 0);
  1896.         int xpos2 = xpos + 16 + (bpldelay2 >= 8 ? 16 : 0);
  1897.         int delay1 = 2*(bpldelay1 & 7);
  1898.         int delay2 = 2*(bpldelay2 & 7);
  1899.         unsigned char *app = pixdata.apixels + xpos1;
  1900.  
  1901.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_hires_h, delay1, 4, 16);
  1902.         if (bplplanecnt > 2) {
  1903.         app = pixdata.apixels + xpos1;
  1904.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_hires_h, delay1, 4, 16);
  1905.         }
  1906. #if AGA_CHIPSET == 1
  1907.         if (bplplanecnt > 4) {
  1908.         app = pixdata.apixels + xpos1;
  1909.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_hires_h, delay1, 4, 16);
  1910.         }
  1911.         if (bplplanecnt > 6) {
  1912.         app = pixdata.apixels + xpos1;
  1913.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_hires_h, delay1, 4, 16);
  1914.         }
  1915. #endif
  1916.         if (bplplanecnt > 1) {
  1917.         app = pixdata.apixels + xpos2;
  1918.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_hires_h, delay2, 4, 16);
  1919.         }
  1920.         if (bplplanecnt > 3) {
  1921.         app = pixdata.apixels + xpos2;
  1922.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_hires_h, delay2, 4, 16);
  1923.         }
  1924. #if AGA_CHIPSET == 1
  1925.         if (bplplanecnt > 5) {
  1926.         app = pixdata.apixels + xpos2;
  1927.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_hires_h, delay2, 4, 16);
  1928.         }
  1929.         if (bplplanecnt > 7) {
  1930.         app = pixdata.apixels + xpos2;
  1931.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_hires_h, delay2, 4, 16);
  1932.         }
  1933. #endif
  1934.     } else {
  1935.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  1936.     }
  1937.     } else {
  1938.     if (bplplanecnt > 0) {
  1939.         int x = xpos + 32;
  1940.         unsigned char *app = pixdata.apixels + x;
  1941. #if 0 /* Fun things to do in the future */
  1942.         int delay[2];
  1943.         int len;
  1944.         ULONG plfd[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
  1945.         ULONG *ptr = (ULONG *)app;
  1946.         ULONG d;
  1947.         ULONG data, data1, data2, data3, data4;
  1948.         delay[0] = 16 - bpldelay1; delay[1] = 16 - bpldelay2;
  1949.  
  1950.         for (len = plflinelen; len > 0; len -= 8, ptr+=8) {
  1951.         DO_ONE_PLANE_B_LORES_H(0,1);
  1952.         DO_ONE_PLANE_B_LORES_H(1,1);
  1953.         DO_ONE_PLANE_B_LORES_H(2,1);
  1954.         DO_ONE_PLANE_B_LORES_H(3,1);
  1955.         DO_ONE_PLANE_B_LORES_H(4,1);
  1956.         DO_ONE_PLANE_B_LORES_H(5,1);
  1957.         *ptr = data1; *(ptr+1) = data2; *(ptr+2) = data3; *(ptr+3) = data4;
  1958.         
  1959.         DO_ONE_PLANE_B_LORES_H(0,0);
  1960.         DO_ONE_PLANE_B_LORES_H(1,0);
  1961.         DO_ONE_PLANE_B_LORES_H(2,0);
  1962.         DO_ONE_PLANE_B_LORES_H(3,0);
  1963.         DO_ONE_PLANE_B_LORES_H(4,0);
  1964.         DO_ONE_PLANE_B_LORES_H(5,0);
  1965.         *(ptr+4) = data1; *(ptr+5) = data2; *(ptr+6) = data3; *(ptr+7) = data4;
  1966.         }
  1967.         DO_ONE_PLANE_B_LORES_H(0,2);
  1968.         DO_ONE_PLANE_B_LORES_H(1,2);
  1969.         DO_ONE_PLANE_B_LORES_H(2,2);
  1970.         DO_ONE_PLANE_B_LORES_H(3,2);
  1971.         DO_ONE_PLANE_B_LORES_H(4,2);
  1972.         DO_ONE_PLANE_B_LORES_H(5,2);
  1973.         *ptr = data1; *(ptr+1) = data2; *(ptr+2) = data3; *(ptr+3) = data4;
  1974.         
  1975.         DO_ONE_PLANE_B_LORES_H(0,0);
  1976.         DO_ONE_PLANE_B_LORES_H(1,0);
  1977.         DO_ONE_PLANE_B_LORES_H(2,0);
  1978.         DO_ONE_PLANE_B_LORES_H(3,0);
  1979.         DO_ONE_PLANE_B_LORES_H(4,0);
  1980.         DO_ONE_PLANE_B_LORES_H(5,0);
  1981.         *(ptr+4) = data1; *(ptr+5) = data2; *(ptr+6) = data3; *(ptr+7) = data4;
  1982. #else
  1983.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_lores_h, bpldelay1, 8, 32);
  1984.         if (bplplanecnt > 2) {
  1985.         app = pixdata.apixels + x;
  1986.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_lores_h, bpldelay1, 8, 32);
  1987.         }
  1988.         if (bplplanecnt > 4) {
  1989.         app = pixdata.apixels + x;
  1990.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_lores_h, bpldelay1, 8, 32);
  1991.         }
  1992. #if AGA_CHIPSET == 1
  1993.         if (bplplanecnt > 6) {
  1994.         app = pixdata.apixels + x;
  1995.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_lores_h, bpldelay1, 8, 32);
  1996.         }
  1997. #endif
  1998.         if (bplplanecnt > 1) {
  1999.         app = pixdata.apixels + x;
  2000.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_lores_h, bpldelay2, 8, 32);
  2001.         }
  2002.         if (bplplanecnt > 3) {
  2003.         app = pixdata.apixels + x;
  2004.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_lores_h, bpldelay2, 8, 32);
  2005.         }
  2006.         if (bplplanecnt > 5) {
  2007.         app = pixdata.apixels + x;
  2008.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_lores_h, bpldelay2, 8, 32);
  2009.         }
  2010. #if AGA_CHIPSET == 1
  2011.         if (bplplanecnt > 7) {
  2012.         app = pixdata.apixels + x;
  2013.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_lores_h, bpldelay2, 8, 32);
  2014.         }
  2015. #endif
  2016. #endif
  2017.     } else {
  2018.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  2019.     }
  2020.     }
  2021.     
  2022.     decode_ham6 (16,812);
  2023.         
  2024.     linetoscreen = 1;
  2025.     sprites_seen = 0;
  2026.     
  2027.     for(spr = 7; spr >= 0; spr--) {
  2028.     if (bpl_info.sprarmed[spr]) {
  2029.         int sprxp = ((bpl_info.sprpos[spr] & 0xFF) * 4) - 0x60 + (bpl_info.sprctl[spr] & 1)*2;
  2030.         int i;
  2031.         /* Ugh. Nasty bug. Let's rather lose some sprites than trash
  2032.          * memory. */
  2033.         if (sprxp >= 0) {
  2034.         if (!sprites_seen) {
  2035.             sprites_seen = 1;
  2036.             memset(spixstate,0,sizeof spixstate);
  2037.         }
  2038.         pfield_sprite (spr, sprxp, bpl_info.sprdata[spr], bpl_info.sprdatb[spr], 0);
  2039.         }
  2040.     }
  2041.     }
  2042. }
  2043. #endif
  2044. static void pfield_doline_l(void)
  2045. {
  2046.     int xpos = plfstrt * 2 - 0x30;
  2047.     int spr;
  2048.     int sprites_seen;
  2049.         
  2050.     if (bplhires) {
  2051.     if (bplplanecnt > 0) {
  2052.         int xpos1 = xpos + 8 + (bpldelay1 >= 8 ? 8 : 0);
  2053.         int xpos2 = xpos + 8 + (bpldelay2 >= 8 ? 8 : 0);
  2054.         int delay1 = (bpldelay1 & 7) * 2;
  2055.         int delay2 = (bpldelay2 & 7) * 2;
  2056.         unsigned char *app = pixdata.apixels + xpos1;
  2057.         
  2058.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_hires_l, delay1, 4, 8);
  2059.         if (bplplanecnt > 2) {
  2060.         app = pixdata.apixels + xpos1;
  2061.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_hires_l, delay1, 4, 8);
  2062.         }
  2063. #if AGA_CHIPSET == 1
  2064.         if (bplplanecnt > 4) {
  2065.         app = pixdata.apixels + xpos1;
  2066.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_hires_l, delay1, 4, 8);
  2067.         }
  2068.         if (bplplanecnt > 6) {
  2069.         app = pixdata.apixels + xpos1;
  2070.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_hires_l, delay1, 4, 8);
  2071.         }
  2072. #endif
  2073.         if (bplplanecnt > 1) {
  2074.         app = pixdata.apixels + xpos2;
  2075.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_hires_l, delay2, 4, 8);
  2076.         }
  2077.         if (bplplanecnt > 3) {
  2078.         app = pixdata.apixels + xpos2;
  2079.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_hires_l, delay2, 4, 8);
  2080.         }
  2081. #if AGA_CHIPSET == 1
  2082.         if (bplplanecnt > 5) {
  2083.         app = pixdata.apixels + xpos2;
  2084.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_hires_l, delay2, 4, 8);
  2085.         }
  2086.         if (bplplanecnt > 7) {
  2087.         app = pixdata.apixels + xpos2;
  2088.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_hires_l, delay2, 4, 8);
  2089.         }
  2090. #endif
  2091.     } else {
  2092.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  2093.     }
  2094.     } else {
  2095.     if (bplplanecnt > 0) {
  2096.         int x = xpos + 16;
  2097.         int delay1 = bpldelay1;
  2098.         int delay2 = bpldelay2;
  2099.         unsigned char *app = pixdata.apixels + x;
  2100.         DO_ONE_PLANE(r_bplpt[0], 0, pfield_setword_lores_l, delay1, 8, 16);
  2101.         if (bplplanecnt > 2) {
  2102.         app = pixdata.apixels + x;
  2103.         DO_ONE_PLANE(r_bplpt[2], 2, pfield_orword_lores_l, delay1, 8, 16);
  2104.         }
  2105.         if (bplplanecnt > 4) {
  2106.         app = pixdata.apixels + x;
  2107.         DO_ONE_PLANE(r_bplpt[4], 4, pfield_orword_lores_l, delay1, 8, 16);
  2108.         }
  2109. #if AGA_CHIPSET == 1
  2110.         if (bplplanecnt > 6) {
  2111.         app = pixdata.apixels + x;
  2112.         DO_ONE_PLANE(r_bplpt[6], 6, pfield_orword_lores_l, delay1, 8, 16);
  2113.         }
  2114. #endif
  2115.         if (bplplanecnt > 1) {
  2116.         app = pixdata.apixels + x;
  2117.         DO_ONE_PLANE(r_bplpt[1], 1, pfield_orword_lores_l, delay2, 8, 16);
  2118.         }
  2119.         if (bplplanecnt > 3) {
  2120.         app = pixdata.apixels + x;
  2121.         DO_ONE_PLANE(r_bplpt[3], 3, pfield_orword_lores_l, delay2, 8, 16);
  2122.         }
  2123.         if (bplplanecnt > 5) {
  2124.         app = pixdata.apixels + x;
  2125.         DO_ONE_PLANE(r_bplpt[5], 5, pfield_orword_lores_l, delay2, 8, 16);
  2126.         }
  2127. #if AGA_CHIPSET == 1
  2128.         if (bplplanecnt > 7) {
  2129.         app = pixdata.apixels + x;
  2130.         DO_ONE_PLANE(r_bplpt[7], 7, pfield_orword_lores_l, delay2, 8, 16);
  2131.         }
  2132. #endif
  2133.     } else {
  2134.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  2135.     }
  2136.     }
  2137.  
  2138.     decode_ham6 (8,406);
  2139.  
  2140.     linetoscreen = 1;
  2141.     sprites_seen = 0;
  2142.  
  2143.     for(spr = 7; spr >= 0; spr--) {
  2144.     if (bpl_info.sprarmed[spr]) {
  2145.         int sprxp = ((bpl_info.sprpos[spr] & 0xFF) * 2) - 0x30 + (bpl_info.sprctl[spr] & 1);
  2146.         int i;
  2147.         /* Ugh. Nasty bug. Let's rather lose some sprites than trash
  2148.          * memory. */
  2149.         if (sprxp >= 0) {
  2150.         if (!sprites_seen) {
  2151.             sprites_seen = 1;
  2152.             memset(spixstate,0,sizeof spixstate);
  2153.         }
  2154.             pfield_sprite (spr, sprxp, bpl_info.sprdata[spr], bpl_info.sprdatb[spr], 1);
  2155.         }
  2156.     }
  2157.     }
  2158. }
  2159.  
  2160. static int bpl_data_differs(UWORD *data, UWORD *r_addr, int nbytes)
  2161. {
  2162.     return memcmpy(data, r_addr, nbytes);
  2163. }
  2164.  
  2165. static __inline__ int bplinfo_differs(struct bplinfo *a, struct bplinfo *b)
  2166. {
  2167.     int ncolors;
  2168.     int i;
  2169.     if (a->bplcon0 != b->bplcon0
  2170.     || a->bplcon1 != b->bplcon1
  2171.     || a->bplcon2 != b->bplcon2
  2172.     || a->bplcon3 != b->bplcon3
  2173.     || a->bplcon4 != b->bplcon4
  2174.     || a->diwstrt != b->diwstrt
  2175.     || a->diwstop != b->diwstop
  2176.     || a->ddfstrt != b->ddfstrt
  2177.     || a->ddfstop != b->ddfstop)
  2178.     return 1;
  2179.  
  2180. #if 1
  2181.     /* This sometimes loses for sprite colors */
  2182.     ncolors = 1 << ((a->bplcon0 & 0x7000) >> 12);
  2183.     if (ncolors == 64)
  2184.     ncolors = (a->bplcon0 & 0x800) ? 16 : 32;
  2185.     for (i = 0; i < ncolors; i++)
  2186.     if (a->color_regs[i] != b->color_regs[i])
  2187.         return 1;
  2188. #else
  2189.     /* ... and this will lose badly on few-color screens when we implement 
  2190.      * AGA.
  2191.      */
  2192.     if (memcmp(a->color_regs, b->color_regs, sizeof a->color_regs) != 0)
  2193.     return 1;
  2194. #endif
  2195.     for (i = 0; i < 8; i++) {
  2196.     if (a->sprarmed[i] != b->sprarmed[i])
  2197.         return 1;
  2198.     if (a->sprarmed[i]
  2199.         && (a->sprctl[i] != b->sprctl[i]
  2200.         || a->sprpos[i] != b->sprpos[i]
  2201.         || a->sprdata[i] != b->sprdata[i]
  2202.         || a->sprdatb[i] != b->sprdatb[i]))
  2203.         return 1;
  2204.     }
  2205.     return 0;
  2206. }
  2207.  
  2208. static void pfield_doline(void)
  2209. {
  2210.     int bytecount = plflinelen / (bplhires ? 4 : 8) * 2;
  2211.     int drawit = 0;
  2212.     int i;
  2213.     
  2214.     if (vpos < plffirstline || vpos >= plflastline) 
  2215.         return;
  2216.  
  2217.     if (!dmaen(0x100) || !pfield_linedmaon) {
  2218.     line_in_border = 1;
  2219.     return;
  2220.     }
  2221.     
  2222.     for (i = 0; i < bplplanecnt; i++) {
  2223.     r_bplpt[i] = pfield_xlateptr(bplpt[i], bytecount);
  2224.     if (r_bplpt[i] == NULL)
  2225.         return;
  2226.     }
  2227.     
  2228. #if SMART_UPDATE == 1
  2229.     drawit = bplinfo_differs(&bpl_info, &linedescr[next_lineno].bpl_info);
  2230.     if (drawit) {
  2231.     linedescr[next_lineno].bpl_info = bpl_info;
  2232.     }
  2233.     drawit |= !linedescr[next_lineno].linedata_valid | frame_redraw_necessary;
  2234.     
  2235.     if (bytecount <= MAX_WORDS_PER_LINE * 2) {
  2236.     linedescr[next_lineno].linedata_valid = 1;
  2237.     for (i = 0; i < bplplanecnt; i++)
  2238.         drawit |= bpl_data_differs(line_data[next_lineno][i],r_bplpt[i],
  2239.                        bytecount);
  2240.     
  2241.     } else {
  2242.     linedescr[next_lineno].linedata_valid = 0;
  2243.     }
  2244. #endif
  2245.  
  2246.     pfield_modulos(bytecount);
  2247.  
  2248. #if SMART_UPDATE != 0
  2249.     if (!drawit)
  2250.     return;
  2251. #endif    
  2252.  
  2253.     if (use_lores)
  2254.     pfield_doline_l();
  2255.     else
  2256.     pfield_doline_h();
  2257. }
  2258.  
  2259. static void pfield_doline_slow(int currhp)
  2260. {
  2261.     int xpos = PIXEL_XPOS(currhp);
  2262.  
  2263.     if (vpos < plffirstline || vpos >= plflastline) 
  2264.         return;
  2265.     
  2266.     if (currhp == plfstrt)
  2267.     slowline_nextpos = currhp;
  2268.  
  2269.     if (currhp == slowline_nextpos) {    
  2270.     if (slowline_linepos >= plflinelen) {
  2271.         /* The modulos must get added at exactly this point. */
  2272.         pfield_modulos(0);
  2273.         slowline_nextpos = -1;
  2274.     } else {
  2275.         slowline_nextpos += bplhires ? 4 : 8;
  2276.         slowline_linepos += bplhires ? 4 : 8;
  2277.  
  2278.         /* Hmmmm.....
  2279.          * In theory, we could use the fast pfield_doline functions even
  2280.          * in this case. We only need to do sprites, ham decoding and
  2281.          * the line_to_scr stuff cycle-per-cycle. However, we would no
  2282.          * longer be able to emulate tricks that switch lores/hires in
  2283.          * the middle of a line, but I'm not sure whether this sort of
  2284.          * thing actually works currently and whether it's worthwhile.
  2285.          */
  2286.                      
  2287.         pfield_fetchdata();
  2288.  
  2289.         if (use_lores)
  2290.         pfield_doline_slow_l (currhp);
  2291.         else
  2292.         pfield_doline_slow_h (currhp);
  2293.         /* @@@ need to test this */
  2294.         decode_ham6 (xpos, PIXEL_XPOS(slowline_nextpos));
  2295.     }
  2296.     }
  2297.     if (currhp > 48) {
  2298.     int spr;
  2299.     for(spr = 7; spr >= 0; spr--) {
  2300.         if (bpl_info.sprarmed[spr] && currhp == (bpl_info.sprpos[spr] & 0xFF)) {
  2301.         int sprxp = xpos + (bpl_info.sprctl[spr] & 1) * (use_lores ? 1 : 2);
  2302.         pfield_sprite (spr, sprxp, bpl_info.sprdata[spr], bpl_info.sprdatb[spr], use_lores);
  2303.         }
  2304.     }
  2305.     }    
  2306. }
  2307.  
  2308. static int first_drawn_line, last_drawn_line;
  2309. static int first_block_line, last_block_line;
  2310.  
  2311. static void init_frame (void)
  2312. {
  2313.     int i;
  2314.     int maxpos = use_lores ? 400 : 800;
  2315.     int old_pmds = prev_max_diwstop;
  2316.     
  2317.     if (max_diwstop == 0)
  2318.     max_diwstop = diwlastword;
  2319.     
  2320.     if (max_diwstop < (use_lores ? 320 : 640) || max_diwstop > maxpos)
  2321.     prev_max_diwstop = maxpos;
  2322.     else
  2323.     prev_max_diwstop = max_diwstop;
  2324.  
  2325.     max_diwstop = 0;
  2326.  
  2327.     memset(spron, 0, sizeof spron);
  2328.     memset(bpl_info.sprpos, 0, sizeof bpl_info.sprpos);
  2329.     memset(bpl_info.sprctl, 0, sizeof bpl_info.sprctl);
  2330.     last_drawn_line = 0;
  2331.     first_drawn_line = 32767;
  2332.  
  2333.     first_block_line = last_block_line = -2;
  2334.     calc_adjustment();
  2335.     if (frame_redraw_necessary)
  2336.     frame_redraw_necessary--;
  2337.     
  2338.     if (old_pmds != prev_max_diwstop) {
  2339.     frame_redraw_necessary |= (bpl_info.bplcon0 & 4 ? 2 : 1);
  2340.     }
  2341. }
  2342.  
  2343. /*
  2344.  * A raster line has been built in the graphics buffer. Tell the graphics code
  2345.  * to do anything necessary to display it.
  2346.  */
  2347.  
  2348. static void do_flush_line (int lineno)
  2349. {
  2350.     if (lineno < first_drawn_line)
  2351.     first_drawn_line = lineno;
  2352.     if (lineno > last_drawn_line)
  2353.     last_drawn_line = lineno;
  2354.  
  2355.     if (gfxvidinfo.maxblocklines == 0)
  2356.     flush_line(lineno);
  2357.     else {
  2358.     if ((last_block_line+1) != lineno) {
  2359.         if (first_block_line != -2)
  2360.         flush_block (first_block_line, last_block_line);
  2361.         first_block_line = lineno;
  2362.     }
  2363.     last_block_line = lineno;
  2364.     if (last_block_line - first_block_line >= gfxvidinfo.maxblocklines) {
  2365.         flush_block (first_block_line, last_block_line);
  2366.         first_block_line = last_block_line = -2;
  2367.     }
  2368.     }
  2369. }
  2370.  
  2371. /*
  2372.  * One Amiga frame has been finished. Tell the graphics code about it.
  2373.  * Note that the actual flush_scren() call is a no-op for all reasonable
  2374.  * systems.
  2375.  */
  2376.  
  2377. static void do_flush_screen (int start, int stop)
  2378. {
  2379.     if (gfxvidinfo.maxblocklines != 0 && first_block_line != -2) {
  2380.     flush_block (first_block_line, last_block_line);
  2381.     }
  2382.     if (start <= stop)
  2383.     flush_screen (start, stop);
  2384. }
  2385.  
  2386. static void setdontcare(void)
  2387. {
  2388.     fprintf(stderr, "Don't care mouse mode set\n");
  2389.     mousestate=dont_care_mouse;
  2390.     lastspr0x=lastmx; lastspr0y=lastmy;
  2391.     mstepx=defstepx; mstepy=defstepy;
  2392. }
  2393.  
  2394. static void setfollow(void)
  2395. {
  2396.     fprintf(stderr, "Follow sprite mode set\n");
  2397.     mousestate=follow_mouse;
  2398.     lastdiffx=lastdiffy=0;
  2399.     sprvbfl=0;
  2400.     spr0ctl=spr0pos=0;
  2401.     mstepx=defstepx; mstepy=defstepy;
  2402. }
  2403.  
  2404. void togglemouse(void)
  2405. {
  2406.     switch(mousestate) {
  2407.      case dont_care_mouse: setfollow(); break;
  2408.      case follow_mouse: setdontcare(); break;
  2409.      default: break; /* Nnnnnghh! */
  2410.     }
  2411. }        
  2412.  
  2413. static __inline__ int adjust(int val)
  2414. {
  2415.     if (val>127)
  2416.     return 127; 
  2417.     else if (val<-127)
  2418.     return -127;
  2419.     return val;
  2420. }
  2421.  
  2422. static void do_mouse_hack(void)
  2423. {
  2424.     int spr0x = ((spr0pos & 0xff) << 2) | ((spr0ctl & 1) << 1);
  2425.     int spr0y = ((spr0pos >> 8) | ((spr0ctl & 4) << 6)) << 1;
  2426.     int diffx, diffy;
  2427.     
  2428.     switch (mousestate) {
  2429.      case normal_mouse:
  2430.     diffx = lastmx - lastsampledmx;
  2431.     diffy = lastmy - lastsampledmy;
  2432.     if (!newmousecounters) {    
  2433.         if (diffx > 127) diffx = 127;
  2434.         if (diffx < -127) diffx = -127;
  2435.         joy0x += diffx;
  2436.         if (diffy > 127) diffy = 127;
  2437.         if (diffy < -127) diffy = -127;
  2438.         joy0y += diffy;
  2439.     }
  2440.     lastsampledmx += diffx; lastsampledmy += diffy;
  2441.     break;
  2442.  
  2443.      case dont_care_mouse:
  2444.     diffx = adjust (((lastmx-lastspr0x) * mstepx) >> 16);
  2445.     diffy = adjust (((lastmy-lastspr0y) * mstepy) >> 16);
  2446.     lastspr0x=lastmx; lastspr0y=lastmy;
  2447.     joy0x+=diffx; joy0y+=diffy;
  2448.     break;
  2449.     
  2450.      case follow_mouse:
  2451.     if (sprvbfl && sprvbfl-- >1) {
  2452.         int mousexpos, mouseypos;
  2453.         
  2454.         if ((lastdiffx > docal || lastdiffx < -docal) && lastspr0x != spr0x 
  2455.         && spr0x > plfstrt*4 + 34 + xcaloff && spr0x < plfstop*4 - xcaloff)
  2456.         {  
  2457.         int val = (lastdiffx << 16) / (spr0x - lastspr0x);
  2458.         if (val>=0x8000) mstepx=(mstepx*(calweight-1)+val)/calweight;
  2459.         }
  2460.         if ((lastdiffy > docal || lastdiffy < -docal) && lastspr0y != spr0y
  2461.         && spr0y>plffirstline+ycaloff && spr0y<plflastline-ycaloff) 
  2462.         { 
  2463.         int val = (lastdiffy<<16) / (spr0y-lastspr0y);
  2464.         if (val>=0x8000) mstepy=(mstepy*(calweight-1)+val)/calweight;
  2465.         }
  2466.         mousexpos = lastmx;
  2467.         if (gfxvidinfo.x_adjust)
  2468.         mousexpos += gfxvidinfo.x_adjust;
  2469.         mouseypos = lastmy;
  2470.         
  2471.         if(!correct_aspect)
  2472.             mouseypos *= 2;
  2473.         if(use_lores)
  2474.             mousexpos *= 2;
  2475.         if (gfxvidinfo.x_adjust)
  2476.         mousexpos -= 16;
  2477.  
  2478.         diffx = adjust ((((mousexpos + 0x70 + xoffs - spr0x) & ~1) * mstepx) >> 16);
  2479.         diffy = adjust ((((mouseypos + yoffs - spr0y+minfirstline*2) & ~1) * mstepy) >> 16);
  2480.         lastspr0x=spr0x; lastspr0y=spr0y;
  2481.         lastdiffx=diffx; lastdiffy=diffy;
  2482.         joy0x+=diffx; joy0y+=diffy; 
  2483.     }
  2484.     break;
  2485.     }
  2486. }
  2487.  
  2488. static void vsync_handler(void)
  2489. {
  2490.     UWORD dir;
  2491.     int button;
  2492.  
  2493.     handle_events();
  2494.     getjoystate(&joy0dir, &joy0button);
  2495.  
  2496.     do_mouse_hack();
  2497.     
  2498.     INTREQ(0x8020);
  2499.     if (bpl_info.bplcon0 & 4) lof ^= 0x8000;
  2500.     COPJMP1(0);
  2501.     
  2502.     if (framecnt == 0)
  2503.         do_flush_screen (first_drawn_line, last_drawn_line);
  2504.  
  2505.     count_frame();
  2506.     init_frame();
  2507. #ifdef HAVE_GETTIMEOFDAY
  2508.     {
  2509.     struct timeval tv;
  2510.     unsigned long int newtime;
  2511.     
  2512.     gettimeofday(&tv,NULL);    
  2513.     newtime = (tv.tv_sec-seconds_base) * 1000 + tv.tv_usec / 1000;
  2514.     
  2515.     if (!bogusframe) {    
  2516.         frametime += newtime - msecs;
  2517.         timeframes++;
  2518.     }
  2519.     msecs = newtime;
  2520.     bogusframe = 0;
  2521.     }
  2522. #endif
  2523.     CIA_vsync_handler();
  2524. }
  2525.  
  2526. static void hsync_handler(void)
  2527. {
  2528.     int lineno = vpos - minfirstline;
  2529.     int lineisdouble = 0;
  2530.     int line_was_doubled = 0;
  2531.     
  2532.     do_sprites(vpos, maxhpos);
  2533.     last_sprite = 0;
  2534.     
  2535.     if (correct_aspect) {
  2536.     lineno *= 2;
  2537.     if (bpl_info.bplcon0 & 4) {
  2538.         if(!lof) {
  2539.         lineno++;
  2540.         }
  2541.     } else {
  2542.         lineisdouble = 1;
  2543.     }
  2544.     }
  2545.  
  2546.     eventtab[ev_hsync].oldcycles = cycles;
  2547.     CIA_hsync_handler();
  2548.     
  2549.     if (produce_sound)
  2550.     do_sound ();
  2551.  
  2552.     if (framecnt == 0 && vpos >= minfirstline && lineno < gfxvidinfo.maxline) {
  2553.     if (vpos >= plffirstline && vpos < plflastline)
  2554.     {
  2555.         /* Finish the line, if we started doing it with the slow update.
  2556.          * Otherwise, draw it entirely. */
  2557.         if (pfield_fullline) {        
  2558.         if (!pfield_linedone) {
  2559.             /* This can turn on line_in_border if DMA is off */
  2560.             pfield_doline();
  2561.         }
  2562.         if (linetoscreen)
  2563.             pfield_do_linetoscr_full (line_was_doubled = lineisdouble);
  2564.         } else {
  2565.         int i;
  2566.         for(i = pfield_lastpart_hpos; i < maxhpos; i++)
  2567.             pfield_doline_slow(i);
  2568.         pfield_do_linetoscr(slowline_lasttoscr, maxhpos);
  2569.         /* The COLOR routine masks off the high nibble. This means
  2570.          * that there will never be 0xFFFF in color_regs[0], and this
  2571.          * means that the line will be drawn completely the next time
  2572.          * we get into pfield_doline()
  2573.          */
  2574.         linedescr[lineno].bpl_info.color_regs[0] = 0xFFFF;
  2575.         linetoscreen = 1;
  2576.         }
  2577.     } else
  2578.         line_in_border = 1;
  2579.     
  2580.     if (line_in_border && 
  2581.         (!linedescr[lineno].inborder 
  2582.          || linedescr[lineno].bordercol != acolors[0]))
  2583.     {
  2584.         linedescr[lineno].bordercol = acolors[0];
  2585.         linedescr[lineno].linedata_valid = 0;
  2586.         
  2587.         fill_line (lineno);
  2588.         linetoscreen = 1;
  2589.     }
  2590.         
  2591.     linedescr[lineno].inborder = line_in_border;
  2592.     
  2593.     if (linetoscreen) {
  2594. #if AGA_CHIPSET == 1
  2595.         switch (gfxvidinfo.pixbytes) {
  2596.          case 1: aga_translate8 (0, aga_lbufptr-aga_linebuf); break;
  2597.          case 2: aga_translate16 (0, aga_lbufptr-aga_linebuf); break;
  2598.          case 4: aga_translate32 (0, aga_lbufptr-aga_linebuf); break;
  2599.         }
  2600. #endif
  2601.         do_flush_line (lineno);
  2602.     }
  2603.     if (lineisdouble) {
  2604.         int drawit = 0;
  2605.         
  2606.         if (linedescr[lineno].inborder != linedescr[lineno+1].inborder
  2607.         || (linedescr[lineno].inborder == 1
  2608.             && linedescr[lineno].bordercol != linedescr[lineno+1].bordercol)) {
  2609.         drawit = 1;
  2610.         
  2611.         } else if (linedescr[lineno].inborder == 0 
  2612.                && (linetoscreen 
  2613.                || (bplinfo_differs(&linedescr[lineno].bpl_info, 
  2614.                            &linedescr[lineno+1].bpl_info)))) {
  2615.         drawit = 1;
  2616.         }
  2617.         
  2618.         if (drawit) {
  2619.         linedescr[lineno+1].inborder = linedescr[lineno].inborder;
  2620.         linedescr[lineno+1].bordercol = linedescr[lineno].bordercol;
  2621. #if SMART_UPDATE != 0
  2622.         linedescr[lineno+1].bpl_info = linedescr[lineno].bpl_info;
  2623. #endif
  2624.         if (!line_was_doubled) {
  2625.             if (line_in_border)
  2626.             fill_line (lineno+1);
  2627.             else
  2628.             memcpy (gfxvidinfo.bufmem + (lineno+1)*gfxvidinfo.rowbytes,
  2629.                 gfxvidinfo.bufmem + lineno*gfxvidinfo.rowbytes,
  2630.                 gfxvidinfo.rowbytes);
  2631.         }
  2632.         do_flush_line (lineno+1);
  2633.         }
  2634.     }
  2635.     }
  2636.  
  2637.     pfield_calclinedma();
  2638.  
  2639.     if (++vpos == (maxvpos + (lof != 0))) {
  2640.     vpos = 0;
  2641.     vsync_handler();
  2642.     }
  2643.     
  2644.     if (framecnt == 0) 
  2645.     {
  2646.     lineno = vpos - minfirstline;
  2647.     
  2648.     if (correct_aspect) {
  2649.         lineno *= 2;
  2650.         if ((bpl_info.bplcon0 & 4) && !lof) {
  2651.         lineno++;
  2652.         }
  2653.     }
  2654.     xlinebuffer = gfxvidinfo.bufmem + gfxvidinfo.rowbytes * lineno;
  2655.     aga_lbufptr = aga_linebuf;
  2656.     next_lineno = lineno;
  2657.     linetoscreen = 0;
  2658.     line_in_border = 0;
  2659.     pfield_fullline = 1;
  2660.     pfield_linedone = 0;
  2661.     pfield_lastpart_hpos = 0;
  2662.     }
  2663.  
  2664. }
  2665.  
  2666. void customreset(void)
  2667. {
  2668.     int i;
  2669. #ifdef HAVE_GETTIMEOFDAY
  2670.     struct timeval tv;
  2671. #endif
  2672.     inhibit_frame = 0;
  2673.     expamem_reset();
  2674.     CIA_reset();
  2675.     cycles = 0; 
  2676.     specialflags = 0;
  2677.     
  2678.     last_sprite = 0;
  2679.     vpos = 0; 
  2680.     lof = 0;
  2681.     next_lineno = 0;
  2682.     max_diwstop = 0;
  2683.     
  2684.     if (needmousehack()) {
  2685.         if (mousestate != follow_mouse) setfollow();
  2686.     } else {
  2687.     mousestate = normal_mouse;
  2688.     }
  2689.  
  2690.     memset(spixstate, 0, sizeof(spixstate));
  2691.     
  2692.     /*memset(blitcount, 0, sizeof(blitcount));  blitter debug */
  2693.     
  2694.     for (i = 0; i < numscrlines*2; i++) {
  2695.     linedescr[i].mnn = NULL;
  2696.     linedescr[i].linedata_valid = 0;
  2697.     linedescr[i].bpl_info.color_regs[0] = 0xFFFF;
  2698.     linedescr[i].bplpt[0] = (CPTR)-1;
  2699.     }
  2700.     
  2701.     xlinebuffer = gfxvidinfo.bufmem;
  2702.  
  2703.     dmacon = intena = 0;
  2704.     bltstate = BLT_done;
  2705.     copstate = COP_stop;
  2706.     copcon = 0;
  2707.     dskdmaen = 0;
  2708.     cycles = 0;
  2709.     bpl_info.bplcon4 = 0x11; /* Get AGA chipset into ECS compatibility mode */
  2710.     bpl_info.bplcon3 = 0xC00;
  2711.     for(i = 0; i < ev_max; i++) {
  2712.     eventtab[i].active = 0;
  2713.     eventtab[i].oldcycles = 0;
  2714.     }
  2715.     copper_active = 0;
  2716.     eventtab[ev_cia].handler = CIA_handler;
  2717.     eventtab[ev_copper].handler = do_copper;
  2718.     eventtab[ev_hsync].handler = hsync_handler;
  2719.     eventtab[ev_hsync].evtime = maxhpos;
  2720.     eventtab[ev_hsync].active = 1;
  2721.  
  2722.     eventtab[ev_blitter].handler = blitter_handler;
  2723.     eventtab[ev_blitter].active = 0;
  2724.     eventtab[ev_diskblk].handler = diskblk_handler;
  2725.     eventtab[ev_diskblk].active = 0;
  2726.     eventtab[ev_diskindex].handler = diskindex_handler;
  2727.     eventtab[ev_diskindex].active = 0;
  2728.  
  2729.     events_schedule();
  2730.     
  2731.     init_frame();
  2732. #ifdef HAVE_GETTIMEOFDAY
  2733.     gettimeofday(&tv,NULL);
  2734.     seconds_base = tv.tv_sec;
  2735.     bogusframe = 1;
  2736. #endif
  2737. }
  2738.  
  2739. void dumpcustom(void)
  2740. {
  2741.     int i;
  2742.     fprintf(stderr, "DMACON: %x INTENA: %x INTREQ: %x VPOS: %x HPOS: %x\n", DMACONR(),
  2743.        intena, intreq, vpos, current_hpos());
  2744.     if (timeframes) { 
  2745.     fprintf(stderr, "Average frame time: %d ms [frames: %d time: %d]\n", 
  2746.            frametime/timeframes, timeframes, frametime);
  2747.     }
  2748.     /*for (i=0; i<256; i++) if (blitcount[i]) fprintf(stderr, "minterm %x = %d\n",i,blitcount[i]);  blitter debug */
  2749. }
  2750.  
  2751. int intlev(void)
  2752. {
  2753.     UWORD imask = intreq & intena;
  2754.     if (imask && (intena & 0x4000)){
  2755.     if (imask & 0x2000) return 6;
  2756.     if (imask & 0x1800) return 5;
  2757.     if (imask & 0x0780) return 4;
  2758.     if (imask & 0x0070) return 3;
  2759.     if (imask & 0x0008) return 2;
  2760.     if (imask & 0x0007) return 1;
  2761.     }
  2762.     return -1;
  2763. }
  2764.  
  2765. void custom_init(void)
  2766. {
  2767.     int num;
  2768.     if (needmousehack())
  2769.     setfollow();
  2770.     customreset();
  2771.     for (num = 0; num < 256; num++) {    
  2772.     int plane1 = (num & 1) | ((num >> 1) & 2) | ((num >> 2) & 4) | ((num >> 3) & 8);
  2773.     int plane2 = ((num >> 1) & 1) | ((num >> 2) & 2) | ((num >> 3) & 4) | ((num >> 4) & 8);
  2774.     dblpf_2nd1[num] = plane1 == 0 ? (plane2 == 0 ? 0 : 2) : 1;
  2775.     dblpf_2nd2[num] = plane2 == 0 ? (plane1 == 0 ? 0 : 1) : 2;
  2776.     dblpf_aga1[num] = plane1 == 0 ? plane2 : plane1;
  2777.     dblpf_aga2[num] = plane2 == 0 ? plane1 : plane2;
  2778.     if (plane2 > 0) plane2 += 8;
  2779.     dblpf_ind1[num] = plane1 == 0 ? plane2 : plane1;
  2780.     dblpf_ind2[num] = plane2 == 0 ? plane1 : plane2;
  2781.     
  2782.     lots_of_twos[num] = num == 0 ? 0 : 2;
  2783.     linear_map_256[num] = num;
  2784.     }
  2785.     build_blitfilltable();
  2786.     gen_pfield_tables();
  2787. }
  2788.  
  2789. /* Custom chip memory bank */
  2790.  
  2791. static ULONG custom_lget(CPTR) REGPARAM;
  2792. static UWORD custom_wget(CPTR) REGPARAM;
  2793. static UBYTE custom_bget(CPTR) REGPARAM;
  2794. static void  custom_lput(CPTR, ULONG) REGPARAM;
  2795. static void  custom_wput(CPTR, UWORD) REGPARAM;
  2796. static void  custom_bput(CPTR, UBYTE) REGPARAM;
  2797.  
  2798. addrbank custom_bank = {
  2799.     custom_lget, custom_wget, custom_bget,
  2800.     custom_lput, custom_wput, custom_bput,
  2801.     default_xlate, default_check
  2802. };
  2803.  
  2804. UWORD custom_wget(CPTR addr)
  2805. {
  2806.     switch(addr & 0x1FE) {
  2807.      case 0x002: return DMACONR();
  2808.      case 0x004: return VPOSR();
  2809.      case 0x006: return VHPOSR();
  2810.     
  2811.      case 0x008: return DSKDATR();
  2812.      case 0x012: return POT0DAT();
  2813.      case 0x016: return POTGOR();
  2814.      case 0x018: return SERDATR();
  2815.      case 0x01A: return DSKBYTR();
  2816.      case 0x01C: return INTENAR();
  2817.      case 0x01E: return INTREQR();
  2818.      case 0x010: return ADKCONR();
  2819.      case 0x00A: return JOY0DAT();
  2820.      case 0x00C: return JOY1DAT();
  2821. #if AGA_CHIPSET == 1
  2822.      case 0x07C: return 0xF8;
  2823. #elif defined ECS_DENISE
  2824.      case 0x07C: return 0xFC;
  2825. #endif
  2826.      default:
  2827.     custom_wput(addr,0);
  2828.     return 0xffff;
  2829.     }
  2830. }
  2831.  
  2832. UBYTE custom_bget(CPTR addr)
  2833. {
  2834.     return custom_wget(addr & 0xfffe) >> (addr & 1 ? 0 : 8);
  2835. }
  2836.  
  2837. ULONG custom_lget(CPTR addr)
  2838. {
  2839.     return ((ULONG)custom_wget(addr & 0xfffe) << 16) | custom_wget((addr+2) & 0xfffe);
  2840. }
  2841.  
  2842. void custom_wput(CPTR addr, UWORD value)
  2843. {
  2844.     addr &= 0x1FE;
  2845.     cregs[addr>>1] = value;
  2846.     switch(addr) {    
  2847.      case 0x020: DSKPTH(value); break;
  2848.      case 0x022: DSKPTL(value); break;
  2849.      case 0x024: DSKLEN(value); break;
  2850.      case 0x026: DSKDAT(value); break;
  2851.     
  2852.      case 0x02A: VPOSW(value); break;
  2853.     
  2854.      case 0x040: BLTCON0(value); break;
  2855.      case 0x042: BLTCON1(value); break;
  2856.     
  2857.      case 0x044: BLTAFWM(value); break;
  2858.      case 0x046: BLTALWM(value); break;
  2859.     
  2860.      case 0x050: BLTAPTH(value); break;
  2861.      case 0x052: BLTAPTL(value); break;
  2862.      case 0x04C: BLTBPTH(value); break;
  2863.      case 0x04E: BLTBPTL(value); break;
  2864.      case 0x048: BLTCPTH(value); break;
  2865.      case 0x04A: BLTCPTL(value); break;
  2866.      case 0x054: BLTDPTH(value); break;
  2867.      case 0x056: BLTDPTL(value); break;
  2868.     
  2869.      case 0x058: BLTSIZE(value); break;
  2870.     
  2871.      case 0x064: BLTAMOD(value); break;
  2872.      case 0x062: BLTBMOD(value); break;
  2873.      case 0x060: BLTCMOD(value); break;
  2874.      case 0x066: BLTDMOD(value); break;
  2875.     
  2876.      case 0x070: BLTCDAT(value); break;
  2877.      case 0x072: BLTBDAT(value); break;
  2878.      case 0x074: BLTADAT(value); break;
  2879.             
  2880.      case 0x07E: DSKSYNC(value); break;
  2881.  
  2882.      case 0x080: COP1LCH(value); break;
  2883.      case 0x082: COP1LCL(value); break;
  2884.      case 0x084: COP2LCH(value); break;
  2885.      case 0x086: COP2LCL(value); break;
  2886.     
  2887.      case 0x088: COPJMP1(value); break;
  2888.      case 0x08A: COPJMP2(value); break;
  2889.     
  2890.      case 0x08E: DIWSTRT(value); break;
  2891.      case 0x090: DIWSTOP(value); break;
  2892.      case 0x092: DDFSTRT(value); break;
  2893.      case 0x094: DDFSTOP(value); break;
  2894.     
  2895.      case 0x096: DMACON(value); break;
  2896.      case 0x09A: INTENA(value); break;
  2897.      case 0x09C: INTREQ(value); break;
  2898.      case 0x09E: ADKCON(value); break;
  2899.     
  2900.      case 0x0A0: AUD0LCH(value); break;
  2901.      case 0x0A2: AUD0LCL(value); break;
  2902.      case 0x0A4: AUD0LEN(value); break;
  2903.      case 0x0A6: AUD0PER(value); break;
  2904.      case 0x0A8: AUD0VOL(value); break;
  2905.     
  2906.      case 0x0B0: AUD1LCH(value); break;
  2907.      case 0x0B2: AUD1LCL(value); break;
  2908.      case 0x0B4: AUD1LEN(value); break;
  2909.      case 0x0B6: AUD1PER(value); break;
  2910.      case 0x0B8: AUD1VOL(value); break;
  2911.     
  2912.      case 0x0C0: AUD2LCH(value); break;
  2913.      case 0x0C2: AUD2LCL(value); break;
  2914.      case 0x0C4: AUD2LEN(value); break;
  2915.      case 0x0C6: AUD2PER(value); break;
  2916.      case 0x0C8: AUD2VOL(value); break;
  2917.     
  2918.      case 0x0D0: AUD3LCH(value); break;
  2919.      case 0x0D2: AUD3LCL(value); break;
  2920.      case 0x0D4: AUD3LEN(value); break;
  2921.      case 0x0D6: AUD3PER(value); break;
  2922.      case 0x0D8: AUD3VOL(value); break;
  2923.     
  2924.      case 0x0E0: BPLPTH(value, 0); break;
  2925.      case 0x0E2: BPLPTL(value, 0); break;
  2926.      case 0x0E4: BPLPTH(value, 1); break;
  2927.      case 0x0E6: BPLPTL(value, 1); break;
  2928.      case 0x0E8: BPLPTH(value, 2); break;
  2929.      case 0x0EA: BPLPTL(value, 2); break;
  2930.      case 0x0EC: BPLPTH(value, 3); break;
  2931.      case 0x0EE: BPLPTL(value, 3); break;
  2932.      case 0x0F0: BPLPTH(value, 4); break;
  2933.      case 0x0F2: BPLPTL(value, 4); break;
  2934.      case 0x0F4: BPLPTH(value, 5); break;
  2935.      case 0x0F6: BPLPTL(value, 5); break;
  2936.     
  2937.      case 0x100: BPLCON0(value); break;
  2938.      case 0x102: BPLCON1(value); break;
  2939.      case 0x104: BPLCON2(value); break;
  2940.      case 0x106: BPLCON3(value); break;
  2941.     
  2942.      case 0x108: BPL1MOD(value); break;
  2943.      case 0x10A: BPL2MOD(value); break;
  2944.  
  2945.      case 0x110: BPL1DAT(value); break;
  2946.      case 0x112: BPL2DAT(value); break;
  2947.      case 0x114: BPL3DAT(value); break;
  2948.      case 0x116: BPL4DAT(value); break;
  2949.      case 0x118: BPL5DAT(value); break;
  2950.      case 0x11A: BPL6DAT(value); break;
  2951.     
  2952.      case 0x180: case 0x182: case 0x184: case 0x186: case 0x188: case 0x18A:
  2953.      case 0x18C: case 0x18E: case 0x190: case 0x192: case 0x194: case 0x196:
  2954.      case 0x198: case 0x19A: case 0x19C: case 0x19E: case 0x1A0: case 0x1A2:
  2955.      case 0x1A4: case 0x1A6: case 0x1A8: case 0x1AA: case 0x1AC: case 0x1AE:
  2956.      case 0x1B0: case 0x1B2: case 0x1B4: case 0x1B6: case 0x1B8: case 0x1BA:
  2957.      case 0x1BC: case 0x1BE: 
  2958.     COLOR(value & 0xFFF, (addr & 0x3E) / 2);
  2959.     break;    
  2960.      case 0x120: case 0x124: case 0x128: case 0x12C: 
  2961.      case 0x130: case 0x134: case 0x138: case 0x13C:
  2962.     SPRxPTH(value, (addr - 0x120) / 4);
  2963.     break;
  2964.      case 0x122: case 0x126: case 0x12A: case 0x12E: 
  2965.      case 0x132: case 0x136: case 0x13A: case 0x13E:
  2966.     SPRxPTL(value, (addr - 0x122) / 4);
  2967.     break;
  2968.      case 0x140: case 0x148: case 0x150: case 0x158: 
  2969.      case 0x160: case 0x168: case 0x170: case 0x178:
  2970.     SPRxPOS(value, (addr - 0x140) / 8);
  2971.     break;
  2972.      case 0x142: case 0x14A: case 0x152: case 0x15A: 
  2973.      case 0x162: case 0x16A: case 0x172: case 0x17A:
  2974.     SPRxCTL(value, (addr - 0x142) / 8);
  2975.     break;
  2976.      case 0x144: case 0x14C: case 0x154: case 0x15C:
  2977.      case 0x164: case 0x16C: case 0x174: case 0x17C:
  2978.     SPRxDATA(value, (addr - 0x144) / 8);
  2979.     break;
  2980.      case 0x146: case 0x14E: case 0x156: case 0x15E: 
  2981.      case 0x166: case 0x16E: case 0x176: case 0x17E:
  2982.     SPRxDATB(value, (addr - 0x146) / 8);
  2983.     break;
  2984.     
  2985.      case 0x36: JOYTEST(value); break;
  2986. #if defined(ECS_AGNUS) || (AGA_CHIPSET == 1)
  2987.      case 0x5A: BLTCON0L(value); break;
  2988.      case 0x5C: BLTSIZV(value); break;
  2989.      case 0x5E: BLTSIZH(value); break;
  2990. #endif
  2991. #if AGA_CHIPSET == 1
  2992.      case 0x10C: BPLCON4(value); break;
  2993. #endif
  2994.     }
  2995. }
  2996.  
  2997. void custom_bput(CPTR addr, UBYTE value)
  2998. {
  2999.     /* Yes, there are programs that do this. The programmers should be shot.
  3000.      * This might actually work sometimes. */
  3001.     UWORD rval = value;
  3002.     CPTR raddr = addr & 0x1FE;
  3003.     if (addr & 1) {
  3004.     rval |= cregs[raddr >> 1] & 0xFF00;
  3005.     } else {
  3006.     rval <<= 8;
  3007.     rval |= cregs[raddr >> 1] & 0xFF;
  3008.     }
  3009.     custom_wput(raddr, rval);
  3010. }
  3011.  
  3012. void custom_lput(CPTR addr, ULONG value)
  3013. {
  3014.     custom_wput(addr & 0xfffe, value >> 16);
  3015.     custom_wput((addr+2) & 0xfffe, (UWORD)value);
  3016. }
  3017.  
  3018.