home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / atari / atari800-0.8.6 / antic.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-10  |  36.0 KB  |  1,683 lines

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. #ifndef AMIGA
  5. #include "config.h"
  6. #endif
  7.  
  8. #include "atari.h"
  9. #include "rt-config.h"
  10. #include "cpu.h"
  11. #include "gtia.h"
  12. #include "antic.h"
  13.  
  14. #define FALSE 0
  15. #define TRUE 1
  16.  
  17. static char *rcsid = "$Id: antic.c,v 1.20 1998/02/21 15:16:41 david Exp $";
  18.  
  19. UBYTE CHACTL;
  20. UBYTE CHBASE;
  21. UBYTE DLISTH;
  22. UBYTE DLISTL;
  23. UBYTE DMACTL;
  24. UBYTE HSCROL;
  25. UBYTE NMIEN;
  26. UBYTE NMIST;
  27. UBYTE PMBASE;
  28. UBYTE VSCROL;
  29.  
  30. /*
  31.  * These are defined for Word (2 Byte) memory accesses. I have not
  32.  * defined Longword (4 Byte) values since the Sparc architecture
  33.  * requires that Longword are on a longword boundry.
  34.  *
  35.  * Words accesses don't appear to be a problem because the first
  36.  * pixel plotted on a line will always be at an even offset, and
  37.  * hence on a word boundry.
  38.  *
  39.  * Note: HSCROL is in colour clocks whereas the pixels are emulated
  40.  *       down to a half colour clock - the first pixel plotted is
  41.  *       moved across by 2*HSCROL
  42.  */
  43.  
  44. #define PF2_COLPF0 0x0404
  45. #define PF2_COLPF1 0x0505
  46. #define PF2_COLPF2 0x0606
  47. #define PF2_COLPF3 0x0707
  48. #define PF2_COLBK 0x0808
  49.  
  50. #define PF4_COLPF0 0x04040404
  51. #define PF4_COLPF1 0x05050505
  52. #define PF4_COLPF2 0x06060606
  53. #define PF4_COLPF3 0x07070707
  54. #define PF4_COLBK 0x08080808
  55.  
  56. int ypos;
  57.  
  58. /*
  59.  * Pre-computed values for improved performance
  60.  */
  61.  
  62. static UWORD chbase_40;            /* CHBASE for 40 character mode */
  63. static UWORD chbase_20;            /* CHBASE for 20 character mode */
  64. static int scroll_offset;
  65. static UBYTE singleline;
  66. static UBYTE player_dma_enabled;
  67. static UBYTE missile_dma_enabled;
  68. static UWORD maddr_s;            /* Address of Missiles - Single Line Resolution */
  69. static UWORD p0addr_s;            /* Address of Player0 - Single Line Resolution */
  70. static UWORD p1addr_s;            /* Address of Player1 - Single Line Resolution */
  71. static UWORD p2addr_s;            /* Address of Player2 - Single Line Resolution */
  72. static UWORD p3addr_s;            /* Address of Player3 - Single Line Resolution */
  73. static UWORD maddr_d;            /* Address of Missiles - Double Line Resolution */
  74. static UWORD p0addr_d;            /* Address of Player0 - Double Line Resolution */
  75. static UWORD p1addr_d;            /* Address of Player1 - Double Line Resolution */
  76. static UWORD p2addr_d;            /* Address of Player2 - Double Line Resolution */
  77. static UWORD p3addr_d;            /* Address of Player3 - Double Line Resolution */
  78.  
  79. int wsync_halt = 0;
  80.  
  81. /*
  82.    =============================================================
  83.    Define screen as ULONG to ensure that it is Longword aligned.
  84.    This allows special optimisations under certain conditions.
  85.    -------------------------------------------------------------
  86.    The extra 16 scanlines is used as an overflow buffer and has
  87.    enough room for any extra mode line. It is needed on the
  88.    occasions that a valid JVB instruction is not found in the
  89.    display list - An automatic break out will occur when ypos
  90.    is greater than the ATARI_HEIGHT, if its one less than this
  91.    there must be enough space for another mode line.
  92.    =============================================================
  93.  */
  94.  
  95. ULONG *atari_screen = NULL;
  96. UBYTE *scrn_ptr;
  97.  
  98. void ANTIC_Initialise(int *argc, char *argv[])
  99. {
  100.     int i;
  101.     int j;
  102.  
  103.     for (i = j = 1; i < *argc; i++) {
  104.         if (strcmp(argv[i], "-xcolpf1") == 0)
  105.             enable_xcolpf1 = TRUE;
  106.         else
  107.             argv[j++] = argv[i];
  108.     }
  109.  
  110.     *argc = j;
  111. }
  112.  
  113. /*
  114.    *****************************************************************
  115.    *                                *
  116.    *    Section         :   Antic Display Modes *
  117.    *    Original Author     :   David Firth     *
  118.    *    Date Written        :   28th May 1995       *
  119.    *    Version         :   1.0         *
  120.    *                                *
  121.    *                                *
  122.    *   Description                          *
  123.    *   -----------                          *
  124.    *                                *
  125.    *   Section that handles Antic display modes. Not required   *
  126.    *   for BASIC version.                       *
  127.    *                                *
  128.    *****************************************************************
  129.  */
  130.  
  131. int xmin;
  132. int xmax;
  133.  
  134. int dmactl_xmin_noscroll;
  135. int dmactl_xmax_noscroll;
  136. static int dmactl_xmin_scroll;
  137. static int dmactl_xmax_scroll;
  138. static int char_delta;
  139. static int char_offset;
  140. static int invert_mask;
  141. static int blank_mask;
  142.  
  143. static UWORD screenaddr;
  144.  
  145. static UWORD lookup1[256];
  146. static UWORD lookup2[256];
  147.  
  148. void antic_blank(int nlines)
  149. {
  150.     if (nlines > 0) {
  151.         int nbytes;
  152.  
  153.         nbytes = nlines * ATARI_WIDTH;
  154.  
  155. #ifdef DIRECT_VIDEO
  156.         memset(scrn_ptr, colour_lookup[8], nbytes);
  157. #else
  158.         memset(scrn_ptr, PF_COLBK, nbytes);
  159. #endif
  160.     }
  161. }
  162.  
  163. static int vskipbefore = 0;
  164. static int vskipafter = 0;
  165.  
  166. void antic_2()
  167. {
  168.     UWORD t_screenaddr = screenaddr;
  169.     char *t_scrn_ptr = &scrn_ptr[xmin + scroll_offset];
  170.     int nchars = (xmax - xmin) >> 3;
  171.     int i;
  172.  
  173. #ifdef DIRECT_VIDEO
  174.     lookup1[0x00] = colour_lookup[6];
  175.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] =
  176.         lookup1[0x10] = lookup1[0x08] = lookup1[0x04] =
  177.         lookup1[0x02] = lookup1[0x01] = colour_lookup[5];
  178. #else
  179.     lookup1[0x00] = PF_COLPF2;
  180.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] =
  181.         lookup1[0x10] = lookup1[0x08] = lookup1[0x04] =
  182.         lookup1[0x02] = lookup1[0x01] = PF_COLPF1;
  183. #endif
  184.  
  185.     for (i = 0; i < nchars; i++) {
  186.         UBYTE screendata = memory[t_screenaddr++];
  187.         UWORD chaddr;
  188.         UBYTE invert;
  189.         UBYTE blank;
  190.         char *ptr = t_scrn_ptr;
  191.         int j;
  192.  
  193.         chaddr = chbase_40 + char_offset + ((UWORD) (screendata & 0x7f) << 3);
  194.  
  195.         if (screendata & invert_mask)
  196.             invert = 0xff;
  197.         else
  198.             invert = 0x00;
  199.  
  200.         if (screendata & blank_mask)
  201.             blank = 0x00;
  202.         else
  203.             blank = 0xff;
  204.  
  205.         for (j = 0; j < 8; j++) {
  206.             UBYTE chdata;
  207.  
  208.             chdata = (memory[chaddr] ^ invert) & blank;
  209.             chaddr += char_delta;
  210.  
  211.             if ((j >= vskipbefore) && (j <= vskipafter)) {
  212.                 if (chdata) {
  213.                     *ptr++ = lookup1[chdata & 0x80];
  214.                     *ptr++ = lookup1[chdata & 0x40];
  215.                     *ptr++ = lookup1[chdata & 0x20];
  216.                     *ptr++ = lookup1[chdata & 0x10];
  217.                     *ptr++ = lookup1[chdata & 0x08];
  218.                     *ptr++ = lookup1[chdata & 0x04];
  219.                     *ptr++ = lookup1[chdata & 0x02];
  220.                     *ptr++ = lookup1[chdata & 0x01];
  221.                 }
  222.                 else {
  223. #ifdef DIRECT_VIDEO
  224.                     *ptr++ = lookup1[0];
  225.                     *ptr++ = lookup1[0];
  226.                     *ptr++ = lookup1[0];
  227.                     *ptr++ = lookup1[0];
  228.                     *ptr++ = lookup1[0];
  229.                     *ptr++ = lookup1[0];
  230.                     *ptr++ = lookup1[0];
  231.                     *ptr++ = lookup1[0];
  232. #else
  233. #ifdef UNALIGNED_LONG_OK
  234.                     ULONG *l_ptr = (ULONG *) ptr;
  235.  
  236.                     *l_ptr++ = PF4_COLPF2;
  237.                     *l_ptr++ = PF4_COLPF2;
  238.  
  239.                     ptr = (UBYTE *) l_ptr;
  240. #else
  241.                     UWORD *w_ptr = (UWORD *) ptr;
  242.  
  243.                     *w_ptr++ = PF2_COLPF2;
  244.                     *w_ptr++ = PF2_COLPF2;
  245.                     *w_ptr++ = PF2_COLPF2;
  246.                     *w_ptr++ = PF2_COLPF2;
  247.  
  248.                     ptr = (UBYTE *) w_ptr;
  249. #endif
  250. #endif
  251.                 }
  252.  
  253.                 ptr += (ATARI_WIDTH - 8);
  254.             }
  255.         }
  256.  
  257.         t_scrn_ptr += 8;
  258.     }
  259.  
  260.     screenaddr = t_screenaddr;
  261. }
  262.  
  263. /*
  264.  * Function to display Antic Mode 3
  265.  */
  266.  
  267. void antic_3()
  268. {
  269.     char *t_scrn_ptr = &scrn_ptr[xmin + scroll_offset];
  270.     int nchars = (xmax - xmin) >> 3;
  271.     int i;
  272.  
  273. #ifdef DIRECT_VIDEO
  274.     lookup1[0x00] = colour_lookup[6];
  275.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] =
  276.         lookup1[0x10] = lookup1[0x08] = lookup1[0x04] =
  277.         lookup1[0x02] = lookup1[0x01] = colour_lookup[5];
  278. #else
  279.     lookup1[0x00] = PF_COLPF2;
  280.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] =
  281.         lookup1[0x10] = lookup1[0x08] = lookup1[0x04] =
  282.         lookup1[0x02] = lookup1[0x01] = PF_COLPF1;
  283. #endif
  284.  
  285.     for (i = 0; i < nchars; i++) {
  286.         UBYTE screendata = memory[screenaddr++];
  287.         UWORD chaddr;
  288.         UBYTE invert;
  289.         UBYTE blank;
  290.         UBYTE lowercase;
  291.         UBYTE first;
  292.         UBYTE second;
  293.         char *ptr = t_scrn_ptr;
  294.         int j;
  295.  
  296.         chaddr = chbase_40 + ((UWORD) (screendata & 0x7f) << 3) + char_offset;
  297.  
  298.         if (screendata & invert_mask)
  299.             invert = 0xff;
  300.         else
  301.             invert = 0x00;
  302.  
  303.         if (screendata & blank_mask)
  304.             blank = 0x00;
  305.         else
  306.             blank = 0xff;
  307.  
  308.         if ((screendata & 0x60) == 0x60)
  309.             lowercase = TRUE;
  310.         else
  311.             lowercase = FALSE;
  312.  
  313.         for (j = 0; j < 10; j++) {
  314.             UBYTE chdata;
  315.  
  316.             if (lowercase) {
  317.                 switch (j) {
  318.                 case 0:
  319.                     first = memory[chaddr];
  320.                     chaddr += char_delta;
  321.                     chdata = 0;
  322.                     break;
  323.                 case 1:
  324.                     second = memory[chaddr];
  325.                     chaddr += char_delta;
  326.                     chdata = 0;
  327.                     break;
  328.                 case 8:
  329.                     chdata = first;
  330.                     break;
  331.                 case 9:
  332.                     chdata = second;
  333.                     break;
  334.                 default:
  335.                     chdata = memory[chaddr];
  336.                     chaddr += char_delta;
  337.                     break;
  338.                 }
  339.             }
  340.             else if (j < 8) {
  341.                 chdata = memory[chaddr];
  342.                 chaddr += char_delta;
  343.             }
  344.             else {
  345.                 chdata = 0;
  346.             }
  347.  
  348.             chdata = (chdata ^ invert) & blank;
  349.  
  350.             if (chdata) {
  351.                 *ptr++ = lookup1[chdata & 0x80];
  352.                 *ptr++ = lookup1[chdata & 0x40];
  353.                 *ptr++ = lookup1[chdata & 0x20];
  354.                 *ptr++ = lookup1[chdata & 0x10];
  355.                 *ptr++ = lookup1[chdata & 0x08];
  356.                 *ptr++ = lookup1[chdata & 0x04];
  357.                 *ptr++ = lookup1[chdata & 0x02];
  358.                 *ptr++ = lookup1[chdata & 0x01];
  359.             }
  360.             else {
  361. #ifdef DIRECT_VIDEO
  362.                 *ptr++ = lookup1[0];
  363.                 *ptr++ = lookup1[0];
  364.                 *ptr++ = lookup1[0];
  365.                 *ptr++ = lookup1[0];
  366.                 *ptr++ = lookup1[0];
  367.                 *ptr++ = lookup1[0];
  368.                 *ptr++ = lookup1[0];
  369.                 *ptr++ = lookup1[0];
  370. #else
  371.                 *ptr++ = PF_COLPF2;
  372.                 *ptr++ = PF_COLPF2;
  373.                 *ptr++ = PF_COLPF2;
  374.                 *ptr++ = PF_COLPF2;
  375.                 *ptr++ = PF_COLPF2;
  376.                 *ptr++ = PF_COLPF2;
  377.                 *ptr++ = PF_COLPF2;
  378.                 *ptr++ = PF_COLPF2;
  379. #endif
  380.             }
  381.  
  382.             ptr += (ATARI_WIDTH - 8);
  383.         }
  384.  
  385.         t_scrn_ptr += 8;
  386.     }
  387. }
  388.  
  389. /*
  390.  * Funtion to display Antic Mode 4
  391.  */
  392.  
  393. void antic_4()
  394. {
  395.     UWORD *t_scrn_ptr = (UWORD *) & scrn_ptr[xmin + scroll_offset];
  396.     int nchars = (xmax - xmin) >> 3;
  397.     int i;
  398.  
  399. /*
  400.    =================================
  401.    Pixel values when character < 128
  402.    =================================
  403.  */
  404. #ifdef DIRECT_VIDEO
  405.     lookup1[0x00] = (colour_lookup[8] << 8) | colour_lookup[8];
  406.     lookup1[0x40] = lookup1[0x10] = lookup1[0x04] =
  407.         lookup1[0x01] = (colour_lookup[4] << 8) | colour_lookup[4];
  408.     lookup1[0x80] = lookup1[0x20] = lookup1[0x08] =
  409.         lookup1[0x02] = (colour_lookup[5] << 8) | colour_lookup[5];
  410.     lookup1[0xc0] = lookup1[0x30] = lookup1[0x0c] =
  411.         lookup1[0x03] = (colour_lookup[7] << 8) | colour_lookup[6];
  412. #else
  413.     lookup1[0x00] = PF2_COLBK;
  414.     lookup1[0x40] = lookup1[0x10] = lookup1[0x04] =
  415.         lookup1[0x01] = PF2_COLPF0;
  416.     lookup1[0x80] = lookup1[0x20] = lookup1[0x08] =
  417.         lookup1[0x02] = PF2_COLPF1;
  418.     lookup1[0xc0] = lookup1[0x30] = lookup1[0x0c] =
  419.         lookup1[0x03] = PF2_COLPF2;
  420. #endif
  421. /*
  422.    ==================================
  423.    Pixel values when character >= 128
  424.    ==================================
  425.  */
  426. #ifdef DIRECT_VIDEO
  427.     lookup2[0x00] = (colour_lookup[8] << 8) | colour_lookup[8];
  428.     lookup2[0x40] = lookup2[0x10] = lookup2[0x04] =
  429.         lookup2[0x01] = (colour_lookup[4] << 8) | colour_lookup[4];
  430.     lookup2[0x80] = lookup2[0x20] = lookup2[0x08] =
  431.         lookup2[0x02] = (colour_lookup[6] << 8) | colour_lookup[5];
  432.     lookup2[0xc0] = lookup2[0x30] = lookup2[0x0c] =
  433.         lookup2[0x03] = (colour_lookup[7] << 8) | colour_lookup[7];
  434. #else
  435.     lookup2[0x00] = PF2_COLBK;
  436.     lookup2[0x40] = lookup2[0x10] = lookup2[0x04] =
  437.         lookup2[0x01] = PF2_COLPF0;
  438.     lookup2[0x80] = lookup2[0x20] = lookup2[0x08] =
  439.         lookup2[0x02] = PF2_COLPF1;
  440.     lookup2[0xc0] = lookup2[0x30] = lookup2[0x0c] =
  441.         lookup2[0x03] = PF2_COLPF3;
  442. #endif
  443.  
  444.     for (i = 0; i < nchars; i++) {
  445.         UBYTE screendata = memory[screenaddr++];
  446.         UWORD chaddr;
  447.         UWORD *lookup;
  448.         UWORD *ptr = t_scrn_ptr;
  449.         int j;
  450.  
  451.         chaddr = chbase_40 + ((UWORD) (screendata & 0x7f) << 3) + char_offset;
  452.  
  453.         if (screendata & 0x80)
  454.             lookup = lookup2;
  455.         else
  456.             lookup = lookup1;
  457.  
  458.         for (j = 0; j < 8; j++) {
  459.             UBYTE chdata;
  460.  
  461.             chdata = memory[chaddr];
  462.             chaddr += char_delta;
  463.  
  464.             if ((j >= vskipbefore) && (j <= vskipafter)) {
  465.                 if (chdata) {
  466.                     UWORD colour;
  467.  
  468.                     colour = lookup[chdata & 0xc0];
  469.                     *ptr++ = colour;
  470.  
  471.                     colour = lookup[chdata & 0x30];
  472.                     *ptr++ = colour;
  473.  
  474.                     colour = lookup[chdata & 0x0c];
  475.                     *ptr++ = colour;
  476.  
  477.                     colour = lookup[chdata & 0x03];
  478.                     *ptr++ = colour;
  479.                 }
  480.                 else {
  481. #ifdef DIRECT_VIDEO
  482.                     *ptr++ = lookup1[0];
  483.                     *ptr++ = lookup1[0];
  484.                     *ptr++ = lookup1[0];
  485.                     *ptr++ = lookup1[0];
  486. #else
  487.                     *ptr++ = PF2_COLBK;
  488.                     *ptr++ = PF2_COLBK;
  489.                     *ptr++ = PF2_COLBK;
  490.                     *ptr++ = PF2_COLBK;
  491. #endif
  492.                 }
  493.  
  494.                 ptr += ((ATARI_WIDTH - 8) >> 1);
  495.             }
  496.         }
  497.  
  498.         t_scrn_ptr += 4;
  499.     }
  500. }
  501.  
  502. /*
  503.  * Function to Display Antic Mode 5
  504.  */
  505.  
  506. void antic_5()
  507. {
  508.     UWORD *t_scrn_ptr1 = (UWORD *) & scrn_ptr[xmin + scroll_offset];
  509.     UWORD *t_scrn_ptr2 = (UWORD *) & scrn_ptr[xmin + ATARI_WIDTH + scroll_offset];
  510.     int nchars = nchars = (xmax - xmin) >> 3;
  511.     int i;
  512.  
  513. /*
  514.    =================================
  515.    Pixel values when character < 128
  516.    =================================
  517.  */
  518. #ifdef DIRECT_VIDEO
  519.     lookup1[0x00] = (colour_lookup[8] << 8) | colour_lookup[8];;
  520.     lookup1[0x40] = lookup1[0x10] = lookup1[0x04] =
  521.         lookup1[0x01] = (colour_lookup[4] << 8) | colour_lookup[4];
  522.     lookup1[0x80] = lookup1[0x20] = lookup1[0x08] =
  523.         lookup1[0x02] = (colour_lookup[5] << 8) | colour_lookup[5];
  524.     lookup1[0xc0] = lookup1[0x30] = lookup1[0x0c] =
  525.         lookup1[0x03] = (colour_lookup[7] << 8) | colour_lookup[6];
  526. #else
  527.     lookup1[0x00] = PF2_COLBK;
  528.     lookup1[0x40] = lookup1[0x10] = lookup1[0x04] =
  529.         lookup1[0x01] = PF2_COLPF0;
  530.     lookup1[0x80] = lookup1[0x20] = lookup1[0x08] =
  531.         lookup1[0x02] = PF2_COLPF1;
  532.     lookup1[0xc0] = lookup1[0x30] = lookup1[0x0c] =
  533.         lookup1[0x03] = PF2_COLPF2;
  534. #endif
  535. /*
  536.    ==================================
  537.    Pixel values when character >= 128
  538.    ==================================
  539.  */
  540. #ifdef DIRECT_VIDEO
  541.     lookup2[0x00] = (colour_lookup[8] << 8) | colour_lookup[8];
  542.     lookup2[0x40] = lookup2[0x10] = lookup2[0x04] =
  543.         lookup2[0x01] = (colour_lookup[4] << 8) | colour_lookup[4];
  544.     lookup2[0x80] = lookup2[0x20] = lookup2[0x08] =
  545.         lookup2[0x02] = (colour_lookup[6] << 8) | colour_lookup[5];
  546.     lookup2[0xc0] = lookup2[0x30] = lookup2[0x0c] =
  547.         lookup2[0x03] = (colour_lookup[7] << 8) | colour_lookup[7];
  548. #else
  549.     lookup2[0x00] = PF2_COLBK;
  550.     lookup2[0x40] = lookup2[0x10] = lookup2[0x04] =
  551.         lookup2[0x01] = PF2_COLPF0;
  552.     lookup2[0x80] = lookup2[0x20] = lookup2[0x08] =
  553.         lookup2[0x02] = PF2_COLPF1;
  554.     lookup2[0xc0] = lookup2[0x30] = lookup2[0x0c] =
  555.         lookup2[0x03] = PF2_COLPF3;
  556. #endif
  557.  
  558.     for (i = 0; i < nchars; i++) {
  559.         UBYTE screendata = memory[screenaddr++];
  560.         UWORD chaddr;
  561.         UWORD *lookup;
  562.         UWORD *ptr1 = t_scrn_ptr1;
  563.         UWORD *ptr2 = t_scrn_ptr2;
  564.         int j;
  565.  
  566.         chaddr = chbase_40 + ((UWORD) (screendata & 0x7f) << 3) + char_offset;
  567.  
  568.         if (screendata & 0x80)
  569.             lookup = lookup2;
  570.         else
  571.             lookup = lookup1;
  572.  
  573.         for (j = 0; j < 16; j += 2) {
  574.             UBYTE chdata;
  575.  
  576.             chdata = memory[chaddr];
  577.             chaddr += char_delta;
  578.  
  579.             if ((j >= vskipbefore) && (j <= vskipafter)) {
  580.                 if (chdata) {
  581.                     UWORD colour;
  582.  
  583.                     colour = lookup[chdata & 0xc0];
  584.                     *ptr1++ = colour;
  585.                     *ptr2++ = colour;
  586.  
  587.                     colour = lookup[chdata & 0x30];
  588.                     *ptr1++ = colour;
  589.                     *ptr2++ = colour;
  590.  
  591.                     colour = lookup[chdata & 0x0c];
  592.                     *ptr1++ = colour;
  593.                     *ptr2++ = colour;
  594.  
  595.                     colour = lookup[chdata & 0x03];
  596.                     *ptr1++ = colour;
  597.                     *ptr2++ = colour;
  598.                 }
  599.                 else {
  600. #ifdef DIRECT_VIDEO
  601.                     *ptr1++ = lookup1[0];
  602.                     *ptr1++ = lookup1[0];
  603.                     *ptr1++ = lookup1[0];
  604.                     *ptr1++ = lookup1[0];
  605.  
  606.                     *ptr2++ = lookup1[0];
  607.                     *ptr2++ = lookup1[0];
  608.                     *ptr2++ = lookup1[0];
  609.                     *ptr2++ = lookup1[0];
  610. #else
  611.                     *ptr1++ = PF2_COLBK;
  612.                     *ptr1++ = PF2_COLBK;
  613.                     *ptr1++ = PF2_COLBK;
  614.                     *ptr1++ = PF2_COLBK;
  615.  
  616.                     *ptr2++ = PF2_COLBK;
  617.                     *ptr2++ = PF2_COLBK;
  618.                     *ptr2++ = PF2_COLBK;
  619.                     *ptr2++ = PF2_COLBK;
  620. #endif
  621.                 }
  622.  
  623.                 ptr1 += ((ATARI_WIDTH + ATARI_WIDTH - 8) >> 1);
  624.                 ptr2 += ((ATARI_WIDTH + ATARI_WIDTH - 8) >> 1);
  625.             }
  626.         }
  627.  
  628.         t_scrn_ptr1 += (8 >> 1);
  629.         t_scrn_ptr2 += (8 >> 1);
  630.     }
  631. }
  632.  
  633. /*
  634.  * Function to Display Antic Mode 6
  635.  */
  636.  
  637. void antic_6()
  638. {
  639.     UWORD *t_scrn_ptr = (UWORD *) & scrn_ptr[xmin + scroll_offset];
  640.     int nchars = (xmax - xmin) >> 4;    /* Divide by 16 */
  641.     int i;
  642.  
  643.     for (i = 0; i < nchars; i++) {
  644.         UBYTE screendata = memory[screenaddr++];
  645.         UWORD chaddr;
  646.         UWORD *ptr = t_scrn_ptr;
  647.         UWORD colour;
  648.         int j;
  649.  
  650.         chaddr = chbase_20 + ((UWORD) (screendata & 0x3f) << 3) + char_offset;
  651.  
  652.         switch (screendata & 0xc0) {
  653.         case 0x00:
  654. #ifdef DIRECT_VIDEO
  655.             colour = (colour_lookup[4] << 8) | colour_lookup[4];
  656. #else
  657.             colour = PF2_COLPF0;
  658. #endif
  659.             break;
  660.         case 0x40:
  661. #ifdef DIRECT_VIDEO
  662.             colour = (colour_lookup[5] << 8) | colour_lookup[5];
  663. #else
  664.             colour = PF2_COLPF1;
  665. #endif
  666.             break;
  667.         case 0x80:
  668. #ifdef DIRECT_VIDEO
  669.             colour = (colour_lookup[6] << 8) | colour_lookup[6];
  670. #else
  671.             colour = PF2_COLPF2;
  672. #endif
  673.             break;
  674.         case 0xc0:
  675. #ifdef DIRECT_VIDEO
  676.             colour = (colour_lookup[7] << 8) | colour_lookup[7];
  677. #else
  678.             colour = PF2_COLPF3;
  679. #endif
  680.             break;
  681.         }
  682.  
  683.         for (j = 0; j < 8; j++) {
  684.             UBYTE chdata;
  685.             int k;
  686.  
  687.             chdata = memory[chaddr];
  688.             chaddr += char_delta;
  689.  
  690.             if ((j >= vskipbefore) && (j <= vskipafter)) {
  691.                 for (k = 0; k < 8; k++) {
  692.                     if (chdata & 0x80) {
  693.                         *ptr++ = colour;
  694.                     }
  695.                     else {
  696. #ifdef DIRECT_VIDEO
  697.                         *ptr++ = (colour_lookup[8] << 8) | colour_lookup[8];
  698. #else
  699.                         *ptr++ = PF2_COLBK;
  700. #endif
  701.                     }
  702.  
  703.                     chdata = chdata << 1;
  704.                 }
  705.  
  706.                 ptr += ((ATARI_WIDTH - 16) >> 1);
  707.             }
  708.         }
  709.  
  710.         t_scrn_ptr += (16 >> 1);
  711.     }
  712. }
  713.  
  714. /*
  715.  * Function to Display Antic Mode 7
  716.  */
  717.  
  718. void antic_7()
  719. {
  720.     UWORD *t_scrn_ptr1 = (UWORD *) & scrn_ptr[xmin + scroll_offset];
  721.     UWORD *t_scrn_ptr2 = (UWORD *) & scrn_ptr[xmin + ATARI_WIDTH + scroll_offset];
  722.     int nchars = (xmax - xmin) >> 4;    /* Divide by 16 */
  723.     int i;
  724.  
  725.     for (i = 0; i < nchars; i++) {
  726.         UBYTE screendata = memory[screenaddr++];
  727.         UWORD chaddr;
  728.         UWORD *ptr1 = t_scrn_ptr1;
  729.         UWORD *ptr2 = t_scrn_ptr2;
  730.         UWORD colour;
  731.         int j;
  732.  
  733.         chaddr = chbase_20 + ((UWORD) (screendata & 0x3f) << 3) + char_offset;
  734.  
  735.         switch (screendata & 0xc0) {
  736.         case 0x00:
  737. #ifdef DIRECT_VIDEO
  738.             colour = (colour_lookup[4] << 8) | colour_lookup[4];
  739. #else
  740.             colour = PF2_COLPF0;
  741. #endif
  742.             break;
  743.         case 0x40:
  744. #ifdef DIRECT_VIDEO
  745.             colour = (colour_lookup[5] << 8) | colour_lookup[5];
  746. #else
  747.             colour = PF2_COLPF1;
  748. #endif
  749.             break;
  750.         case 0x80:
  751. #ifdef DIRECT_VIDEO
  752.             colour = (colour_lookup[6] << 8) | colour_lookup[6];
  753. #else
  754.             colour = PF2_COLPF2;
  755. #endif
  756.             break;
  757.         case 0xc0:
  758. #ifdef DIRECT_VIDEO
  759.             colour = (colour_lookup[7] << 8) | colour_lookup[7];
  760. #else
  761.             colour = PF2_COLPF3;
  762. #endif
  763.             break;
  764.         }
  765.  
  766.         for (j = 0; j < 8; j++) {
  767.             UBYTE chdata;
  768.             int k;
  769.  
  770.             chdata = memory[chaddr];
  771.             chaddr += char_delta;
  772.  
  773.             if ((j >= vskipbefore) && (j <= vskipafter)) {
  774.                 for (k = 0; k < 8; k++) {
  775.                     if (chdata & 0x80) {
  776.                         *ptr1++ = colour;
  777.                         *ptr2++ = colour;
  778.                     }
  779.                     else {
  780. #ifdef DIRECT_VIDEO
  781.                         *ptr1++ = (colour_lookup[8] << 8) | colour_lookup[8];
  782.                         *ptr2++ = (colour_lookup[8] << 8) | colour_lookup[8];
  783. #else
  784.                         *ptr1++ = PF2_COLBK;
  785.                         *ptr2++ = PF2_COLBK;
  786. #endif
  787.                     }
  788.  
  789.                     chdata = chdata << 1;
  790.                 }
  791.  
  792.                 ptr1 += ((ATARI_WIDTH + ATARI_WIDTH - 16) >> 1);
  793.                 ptr2 += ((ATARI_WIDTH + ATARI_WIDTH - 16) >> 1);
  794.             }
  795.         }
  796.  
  797.         t_scrn_ptr1 += (16 >> 1);
  798.         t_scrn_ptr2 += (16 >> 1);
  799.     }
  800. }
  801.  
  802. /*
  803.  * Function to Display Antic Mode 8
  804.  */
  805.  
  806. void antic_8()
  807. {
  808.     char *t_scrn_ptr = &scrn_ptr[xmin + scroll_offset];
  809.     int nbytes = (xmax - xmin) >> 5;    /* Divide by 32 */
  810.     int i;
  811.  
  812. #ifdef DIRECT_VIDEO
  813.     lookup1[0x00] = colour_lookup[8];
  814.     lookup1[0x40] = colour_lookup[4];
  815.     lookup1[0x80] = colour_lookup[5];
  816.     lookup1[0xc0] = colour_lookup[6];
  817. #else
  818.     lookup1[0x00] = PF_COLBK;
  819.     lookup1[0x40] = PF_COLPF0;
  820.     lookup1[0x80] = PF_COLPF1;
  821.     lookup1[0xc0] = PF_COLPF2;
  822. #endif
  823.  
  824.     for (i = 0; i < nbytes; i++) {
  825.         UBYTE screendata = memory[screenaddr++];
  826.         int j;
  827.  
  828.         for (j = 0; j < 4; j++) {
  829.             UBYTE colour;
  830.             char *ptr = t_scrn_ptr;
  831.             int k;
  832.  
  833.             colour = lookup1[screendata & 0xc0];
  834.  
  835.             for (k = 0; k < 8; k++) {
  836.                 memset(ptr, colour, 8);
  837.                 ptr += ATARI_WIDTH;
  838.             }
  839.  
  840.             screendata = screendata << 2;
  841.             t_scrn_ptr += 8;
  842.         }
  843.     }
  844. }
  845.  
  846. /*
  847.  * Function to Display Antic Mode 9
  848.  */
  849.  
  850. void antic_9()
  851. {
  852.     char *t_scrn_ptr = &scrn_ptr[xmin + scroll_offset];
  853.     int nbytes = (xmax - xmin) >> 5;    /* Divide by 32 */
  854.     int i;
  855.  
  856. #ifdef DIRECT_VIDEO
  857.     lookup1[0x00] = colour_lookup[8];
  858.     lookup1[0x80] = colour_lookup[4];
  859. #else
  860.     lookup1[0x00] = PF_COLBK;
  861.     lookup1[0x80] = PF_COLPF0;
  862. #endif
  863.  
  864.     for (i = 0; i < nbytes; i++) {
  865.         UBYTE screendata = memory[screenaddr++];
  866.         int j;
  867.  
  868.         for (j = 0; j < 8; j++) {
  869.             UBYTE colour;
  870.             char *ptr = t_scrn_ptr;
  871.             int k;
  872.  
  873.             colour = lookup1[screendata & 0x80];
  874.  
  875.             for (k = 0; k < 4; k++) {
  876.                 memset(ptr, colour, 4);
  877.                 ptr += ATARI_WIDTH;
  878.             }
  879.  
  880.             screendata = screendata << 1;
  881.             t_scrn_ptr += 4;
  882.         }
  883.     }
  884. }
  885.  
  886. /*
  887.  * Function to Display Antic Mode a
  888.  */
  889.  
  890. void antic_a()
  891. {
  892.     char *t_scrn_ptr = &scrn_ptr[xmin + scroll_offset];
  893.     int nbytes = (xmax - xmin) >> 4;    /* Divide by 16 */
  894.     int i;
  895.  
  896. #ifdef DIRECT_VIDEO
  897.     lookup1[0x00] = colour_lookup[8];
  898.     lookup1[0x40] = colour_lookup[4];
  899.     lookup1[0x80] = colour_lookup[5];
  900.     lookup1[0xc0] = colour_lookup[6];
  901. #else
  902.     lookup1[0x00] = PF_COLBK;
  903.     lookup1[0x40] = PF_COLPF0;
  904.     lookup1[0x80] = PF_COLPF1;
  905.     lookup1[0xc0] = PF_COLPF2;
  906. #endif
  907.  
  908.     for (i = 0; i < nbytes; i++) {
  909.         UBYTE screendata = memory[screenaddr++];
  910.         int j;
  911.  
  912.         for (j = 0; j < 4; j++) {
  913.             UBYTE colour;
  914.             char *ptr = t_scrn_ptr;
  915.             int k;
  916.  
  917.             colour = lookup1[screendata & 0xc0];
  918.  
  919.             for (k = 0; k < 4; k++) {
  920.                 memset(ptr, colour, 4);
  921.                 ptr += ATARI_WIDTH;
  922.             }
  923.  
  924.             screendata = screendata << 2;
  925.             t_scrn_ptr += 4;
  926.         }
  927.     }
  928. }
  929.  
  930. /*
  931.  * Function to Display Antic Mode b
  932.  */
  933.  
  934. void antic_b()
  935. {
  936.     char *t_scrn_ptr1 = &scrn_ptr[xmin + scroll_offset];
  937.     char *t_scrn_ptr2 = &scrn_ptr[xmin + ATARI_WIDTH + scroll_offset];
  938.     int nbytes = (xmax - xmin) >> 4;    /* Divide by 16 */
  939.     int i;
  940.  
  941. #ifdef DIRECT_VIDEO
  942.     lookup1[0x00] = colour_lookup[8];
  943.     lookup1[0x80] = colour_lookup[4];
  944. #else
  945.     lookup1[0x00] = PF_COLBK;
  946.     lookup1[0x80] = PF_COLPF0;
  947. #endif
  948.  
  949.     for (i = 0; i < nbytes; i++) {
  950.         UBYTE screendata = memory[screenaddr++];
  951.         UWORD colour;
  952.         int j;
  953.  
  954.         for (j = 0; j < 8; j++) {
  955.             colour = lookup1[screendata & 0x80];
  956.             *t_scrn_ptr1++ = colour;
  957.             *t_scrn_ptr1++ = colour;
  958.             *t_scrn_ptr2++ = colour;
  959.             *t_scrn_ptr2++ = colour;
  960.             screendata = screendata << 1;
  961.         }
  962.     }
  963. }
  964.  
  965. /*
  966.  * Function to Display Antic Mode c
  967.  */
  968.  
  969. void antic_c()
  970. {
  971.     char *t_scrn_ptr = &scrn_ptr[xmin + scroll_offset];
  972.     int nbytes = (xmax - xmin) >> 4;    /* Divide by 16 */
  973.     int i;
  974.  
  975. #ifdef DIRECT_VIDEO
  976.     lookup1[0x00] = colour_lookup[8];
  977.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] = lookup1[0x10] =
  978.         colour_lookup[4];
  979. #else
  980.     lookup1[0x00] = PF_COLBK;
  981.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] = lookup1[0x10] = PF_COLPF0;
  982. #endif
  983.  
  984.     for (i = 0; i < nbytes; i++) {
  985.         UBYTE screendata = memory[screenaddr++];
  986.         int j;
  987.  
  988.         for (j = 0; j < 2; j++) {
  989.             UBYTE colour;
  990.  
  991.             colour = lookup1[screendata & 0x80];
  992.             *t_scrn_ptr++ = colour;
  993.             *t_scrn_ptr++ = colour;
  994.  
  995.             colour = lookup1[screendata & 0x40];
  996.             *t_scrn_ptr++ = colour;
  997.             *t_scrn_ptr++ = colour;
  998.  
  999.             colour = lookup1[screendata & 0x20];
  1000.             *t_scrn_ptr++ = colour;
  1001.             *t_scrn_ptr++ = colour;
  1002.  
  1003.             colour = lookup1[screendata & 0x10];
  1004.             *t_scrn_ptr++ = colour;
  1005.             *t_scrn_ptr++ = colour;
  1006.  
  1007.             screendata <<= 4;
  1008.         }
  1009.     }
  1010. }
  1011.  
  1012. /*
  1013.  * Function to Display Antic Mode d
  1014.  */
  1015.  
  1016. void antic_d()
  1017. {
  1018.     UWORD *t_scrn_ptr1 = (UWORD *) & scrn_ptr[xmin + scroll_offset];
  1019.     UWORD *t_scrn_ptr2 = (UWORD *) & scrn_ptr[ATARI_WIDTH + xmin + scroll_offset];
  1020.     int nbytes = (xmax - xmin) >> 3;
  1021.     int i;
  1022.  
  1023. #ifdef DIRECT_VIDEO
  1024.     lookup1[0x00] = (colour_lookup[8] << 8) | colour_lookup[8];
  1025.     lookup1[0x40] = (colour_lookup[4] << 8) | colour_lookup[4];
  1026.     lookup1[0x80] = (colour_lookup[5] << 8) | colour_lookup[5];
  1027.     lookup1[0xc0] = (colour_lookup[6] << 8) | colour_lookup[6];
  1028. #else
  1029.     lookup1[0x00] = PF2_COLBK;
  1030.     lookup1[0x40] = PF2_COLPF0;
  1031.     lookup1[0x80] = PF2_COLPF1;
  1032.     lookup1[0xc0] = PF2_COLPF2;
  1033. #endif
  1034.  
  1035.     for (i = 0; i < nbytes; i++) {
  1036.         UBYTE screendata;
  1037.  
  1038.         screendata = memory[screenaddr++];
  1039.  
  1040.         if (screendata) {
  1041.             UWORD colour;
  1042.  
  1043.             colour = lookup1[screendata & 0xc0];
  1044.             *t_scrn_ptr1++ = colour;
  1045.             *t_scrn_ptr2++ = colour;
  1046.             screendata = screendata << 2;
  1047.  
  1048.             colour = lookup1[screendata & 0xc0];
  1049.             *t_scrn_ptr1++ = colour;
  1050.             *t_scrn_ptr2++ = colour;
  1051.             screendata = screendata << 2;
  1052.  
  1053.             colour = lookup1[screendata & 0xc0];
  1054.             *t_scrn_ptr1++ = colour;
  1055.             *t_scrn_ptr2++ = colour;
  1056.             screendata = screendata << 2;
  1057.  
  1058.             colour = lookup1[screendata & 0xc0];
  1059.             *t_scrn_ptr1++ = colour;
  1060.             *t_scrn_ptr2++ = colour;
  1061.             screendata = screendata << 2;
  1062.         }
  1063.         else {
  1064. #ifdef DIRECT_VIDEO
  1065.             *t_scrn_ptr1++ = lookup1[0x00];
  1066.             *t_scrn_ptr1++ = lookup1[0x00];
  1067.             *t_scrn_ptr1++ = lookup1[0x00];
  1068.             *t_scrn_ptr1++ = lookup1[0x00];
  1069.  
  1070.             *t_scrn_ptr2++ = lookup1[0x00];
  1071.             *t_scrn_ptr2++ = lookup1[0x00];
  1072.             *t_scrn_ptr2++ = lookup1[0x00];
  1073.             *t_scrn_ptr2++ = lookup1[0x00];
  1074. #else
  1075.             *t_scrn_ptr1++ = PF2_COLBK;
  1076.             *t_scrn_ptr1++ = PF2_COLBK;
  1077.             *t_scrn_ptr1++ = PF2_COLBK;
  1078.             *t_scrn_ptr1++ = PF2_COLBK;
  1079.  
  1080.             *t_scrn_ptr2++ = PF2_COLBK;
  1081.             *t_scrn_ptr2++ = PF2_COLBK;
  1082.             *t_scrn_ptr2++ = PF2_COLBK;
  1083.             *t_scrn_ptr2++ = PF2_COLBK;
  1084. #endif
  1085.         }
  1086.     }
  1087. }
  1088.  
  1089. /*
  1090.  * Function to display Antic Mode e
  1091.  */
  1092.  
  1093. void antic_e()
  1094. {
  1095.     UWORD *t_scrn_ptr = (UWORD *) & scrn_ptr[xmin + scroll_offset];
  1096.     int nbytes = (xmax - xmin) >> 3;
  1097.     int i;
  1098. #ifdef UNALIGNED_LONG_OK
  1099.     int background;
  1100. #endif
  1101.     UBYTE *ptr;
  1102.  
  1103. #ifdef AMIGA_TEST
  1104.     antic_e_test(nbytes - 1, &memory[screenaddr], t_scrn_ptr);
  1105.     screenaddr += nbytes;
  1106. #else
  1107.  
  1108. #ifdef DIRECT_VIDEO
  1109.     lookup1[0x00] = (colour_lookup[8] << 8) | colour_lookup[8];
  1110.     lookup1[0x40] = lookup1[0x10] = lookup1[0x04] = lookup1[0x01] =
  1111.         (colour_lookup[4] << 8) | colour_lookup[4];
  1112.     lookup1[0x80] = lookup1[0x20] = lookup1[0x08] = lookup1[0x02] =
  1113.         (colour_lookup[5] << 8) | colour_lookup[5];
  1114.     lookup1[0xc0] = lookup1[0x30] = lookup1[0x0c] = lookup1[0x03] =
  1115.         (colour_lookup[6] << 8) | colour_lookup[6];
  1116. #else
  1117.     lookup1[0x00] = PF2_COLBK;
  1118.     lookup1[0x40] = lookup1[0x10] = lookup1[0x04] = lookup1[0x01] =
  1119.         PF2_COLPF0;
  1120.     lookup1[0x80] = lookup1[0x20] = lookup1[0x08] = lookup1[0x02] =
  1121.         PF2_COLPF1;
  1122.     lookup1[0xc0] = lookup1[0x30] = lookup1[0x0c] = lookup1[0x03] =
  1123.         PF2_COLPF2;
  1124. #endif
  1125.  
  1126. #ifdef UNALIGNED_LONG_OK
  1127.     background = (lookup1[0x00] << 16) | lookup1[0x00];
  1128. #endif
  1129.  
  1130.     ptr = &memory[screenaddr];
  1131.  
  1132.     for (i = 0; i < nbytes; i++) {
  1133.         UBYTE screendata = ptr[i];
  1134.  
  1135.         if (screendata) {
  1136.             *t_scrn_ptr++ = lookup1[screendata & 0xc0];
  1137.             *t_scrn_ptr++ = lookup1[screendata & 0x30];
  1138.             *t_scrn_ptr++ = lookup1[screendata & 0x0c];
  1139.             *t_scrn_ptr++ = lookup1[screendata & 0x03];
  1140.         }
  1141.         else {
  1142. #ifdef UNALIGNED_LONG_OK
  1143.             ULONG *l_ptr = (ULONG *) t_scrn_ptr;
  1144.  
  1145.             *l_ptr++ = background;
  1146.             *l_ptr++ = background;
  1147.  
  1148.             t_scrn_ptr = (UWORD *) l_ptr;
  1149. #else
  1150.             *t_scrn_ptr++ = lookup1[0x00];
  1151.             *t_scrn_ptr++ = lookup1[0x00];
  1152.             *t_scrn_ptr++ = lookup1[0x00];
  1153.             *t_scrn_ptr++ = lookup1[0x00];
  1154. #endif
  1155.         }
  1156.     }
  1157.  
  1158.     screenaddr += nbytes;
  1159. #endif
  1160. }
  1161.  
  1162. /*
  1163.  * Function to display Antic Mode f
  1164.  */
  1165.  
  1166. void antic_f()
  1167. {
  1168.     char *t_scrn_ptr = &scrn_ptr[xmin + scroll_offset];
  1169.     int nbytes = (xmax - xmin) >> 3;
  1170.     int i;
  1171.  
  1172. #ifdef DIRECT_VIDEO
  1173.     lookup1[0x00] = colour_lookup[6];
  1174.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] =
  1175.         lookup1[0x10] = lookup1[0x08] = lookup1[0x04] =
  1176.         lookup1[0x02] = lookup1[0x01] = colour_lookup[5];
  1177. #else
  1178.     lookup1[0x00] = PF_COLPF2;
  1179.     lookup1[0x80] = lookup1[0x40] = lookup1[0x20] =
  1180.         lookup1[0x10] = lookup1[0x08] = lookup1[0x04] =
  1181.         lookup1[0x02] = lookup1[0x01] = PF_COLPF1;
  1182. #endif
  1183.  
  1184.     for (i = 0; i < nbytes; i++) {
  1185.         UBYTE screendata = memory[screenaddr++];
  1186.  
  1187.         if (screendata) {
  1188.             *t_scrn_ptr++ = lookup1[screendata & 0x80];
  1189.             *t_scrn_ptr++ = lookup1[screendata & 0x40];
  1190.             *t_scrn_ptr++ = lookup1[screendata & 0x20];
  1191.             *t_scrn_ptr++ = lookup1[screendata & 0x10];
  1192.             *t_scrn_ptr++ = lookup1[screendata & 0x08];
  1193.             *t_scrn_ptr++ = lookup1[screendata & 0x04];
  1194.             *t_scrn_ptr++ = lookup1[screendata & 0x02];
  1195.             *t_scrn_ptr++ = lookup1[screendata & 0x01];
  1196.         }
  1197.         else {
  1198. #ifdef DIRECT_VIDEO
  1199.             *t_scrn_ptr++ = colour_lookup[6];
  1200.             *t_scrn_ptr++ = colour_lookup[6];
  1201.             *t_scrn_ptr++ = colour_lookup[6];
  1202.             *t_scrn_ptr++ = colour_lookup[6];
  1203.             *t_scrn_ptr++ = colour_lookup[6];
  1204.             *t_scrn_ptr++ = colour_lookup[6];
  1205.             *t_scrn_ptr++ = colour_lookup[6];
  1206.             *t_scrn_ptr++ = colour_lookup[6];
  1207. #else
  1208.             *t_scrn_ptr++ = PF_COLPF2;
  1209.             *t_scrn_ptr++ = PF_COLPF2;
  1210.             *t_scrn_ptr++ = PF_COLPF2;
  1211.             *t_scrn_ptr++ = PF_COLPF2;
  1212.             *t_scrn_ptr++ = PF_COLPF2;
  1213.             *t_scrn_ptr++ = PF_COLPF2;
  1214.             *t_scrn_ptr++ = PF_COLPF2;
  1215.             *t_scrn_ptr++ = PF_COLPF2;
  1216. #endif
  1217.         }
  1218.     }
  1219. }
  1220.  
  1221. /*
  1222.    *****************************************************************
  1223.    *                                *
  1224.    *    Section         :   Display List        *
  1225.    *    Original Author     :   David Firth     *
  1226.    *    Date Written        :   28th May 1995       *
  1227.    *    Version         :   1.0         *
  1228.    *                                *
  1229.    *   Description                          *
  1230.    *   -----------                          *
  1231.    *                                *
  1232.    *   Section that handles Antic Display List. Not required for    *
  1233.    *   BASIC version.                       *
  1234.    *                                                               *
  1235.    *****************************************************************
  1236.  */
  1237.  
  1238. void pmg_dma(void)
  1239. {
  1240.     if (player_dma_enabled) {
  1241.         if (singleline) {
  1242.             GRAFP0 = memory[p0addr_s + ypos];
  1243.             GRAFP1 = memory[p1addr_s + ypos];
  1244.             GRAFP2 = memory[p2addr_s + ypos];
  1245.             GRAFP3 = memory[p3addr_s + ypos];
  1246.         }
  1247.         else {
  1248.             GRAFP0 = memory[p0addr_d + (ypos >> 1)];
  1249.             GRAFP1 = memory[p1addr_d + (ypos >> 1)];
  1250.             GRAFP2 = memory[p2addr_d + (ypos >> 1)];
  1251.             GRAFP3 = memory[p3addr_d + (ypos >> 1)];
  1252.         }
  1253.     }
  1254.     if (missile_dma_enabled) {
  1255.         if (singleline)
  1256.             GRAFM = memory[maddr_s + ypos];
  1257.         else
  1258.             GRAFM = memory[maddr_d + (ypos >> 1)];
  1259.     }
  1260. }
  1261.  
  1262. void ANTIC_RunDisplayList(void)
  1263. {
  1264.     UWORD dlist;
  1265.     int JVB;
  1266.     int vscrol_flag;
  1267.     int nlines;
  1268.     int i;
  1269.  
  1270.     wsync_halt = 0;
  1271.  
  1272.     /*
  1273.      * VCOUNT must equal zero for some games but the first line starts
  1274.      * when VCOUNT=4. This portion processes when VCOUNT=0, 1, 2 and 3
  1275.      */
  1276.  
  1277.     for (ypos = 0; ypos < 8; ypos++)
  1278.         GO(114);
  1279.  
  1280.     NMIST = 0x00;                /* Reset VBLANK */
  1281.  
  1282.     scrn_ptr = (UBYTE *) atari_screen;
  1283.  
  1284.     ypos = 8;
  1285.     vscrol_flag = FALSE;
  1286.  
  1287.     dlist = (DLISTH << 8) | DLISTL;
  1288.     JVB = FALSE;
  1289.  
  1290.     while ((DMACTL & 0x20) && !JVB && (ypos < (ATARI_HEIGHT + 8))) {
  1291.         UBYTE IR;
  1292.         UBYTE colpf1;
  1293.         int colpf1_fiddled = FALSE;
  1294.  
  1295.         IR = memory[dlist++];
  1296.         colpf1 = COLPF1;
  1297.  
  1298.         switch (IR & 0x0f) {
  1299.         case 0x00:
  1300.             {
  1301.                 nlines = ((IR >> 4) & 0x07) + 1;
  1302.                 antic_blank(nlines);
  1303.             }
  1304.             break;
  1305.         case 0x01:
  1306.             if (IR & 0x40) {
  1307.                 nlines = 0;
  1308.                 JVB = TRUE;
  1309.             }
  1310.             else {
  1311.                 dlist = (memory[dlist + 1] << 8) | memory[dlist];
  1312.                 nlines = 1;
  1313.                 antic_blank(1);    /* Jump aparently uses 1 scan line */
  1314.             }
  1315.             break;
  1316.         default:
  1317.             if (IR & 0x40) {
  1318.                 screenaddr = (memory[dlist + 1] << 8) | memory[dlist];
  1319.                 dlist += 2;
  1320.             }
  1321.             if (IR & 0x20) {
  1322.                 if (!vscrol_flag) {
  1323.                     vskipbefore = VSCROL;
  1324.                     vscrol_flag = TRUE;
  1325.                 }
  1326.             }
  1327.             else if (vscrol_flag) {
  1328.                 vskipafter = VSCROL /* - 1 */ ;
  1329.                 vscrol_flag = FALSE;
  1330.             }
  1331.             if (IR & 0x10) {
  1332.                 xmin = dmactl_xmin_scroll;
  1333.                 xmax = dmactl_xmax_scroll;
  1334.                 scroll_offset = HSCROL + HSCROL;
  1335.             }
  1336.             else {
  1337.                 xmin = dmactl_xmin_noscroll;
  1338.                 xmax = dmactl_xmax_noscroll;
  1339.                 scroll_offset = 0;
  1340.             }
  1341.  
  1342.             switch (IR & 0x0f) {
  1343.             case 0x02:
  1344.                 nlines = 8;
  1345.                 if (!enable_xcolpf1) {
  1346.                     GTIA_PutByte(_COLPF1, (COLPF2 & 0xf0) | (COLPF1 & 0x0f));
  1347.                     colpf1_fiddled = TRUE;
  1348.                 }
  1349.                 antic_2();
  1350.                 break;
  1351.             case 0x03:
  1352.                 nlines = 10;
  1353.                 if (!enable_xcolpf1) {
  1354.                     GTIA_PutByte(_COLPF1, (COLPF2 & 0xf0) | (COLPF1 & 0x0f));
  1355.                     colpf1_fiddled = TRUE;
  1356.                 }
  1357.                 antic_3();
  1358.                 break;
  1359.             case 0x04:
  1360.                 nlines = 8;
  1361.                 antic_4();
  1362.                 break;
  1363.             case 0x05:
  1364.                 nlines = 16;
  1365.                 antic_5();
  1366.                 break;
  1367.             case 0x06:
  1368.                 nlines = 8;
  1369.                 antic_6();
  1370.                 break;
  1371.             case 0x07:
  1372.                 nlines = 16;
  1373.                 antic_7();
  1374.                 break;
  1375.             case 0x08:
  1376.                 nlines = 8;
  1377.                 antic_8();
  1378.                 break;
  1379.             case 0x09:
  1380.                 nlines = 4;
  1381.                 antic_9();
  1382.                 break;
  1383.             case 0x0a:
  1384.                 nlines = 4;
  1385.                 antic_a();
  1386.                 break;
  1387.             case 0x0b:
  1388.                 nlines = 2;
  1389.                 antic_b();
  1390.                 break;
  1391.             case 0x0c:
  1392.                 nlines = 1;
  1393.                 antic_c();
  1394.                 break;
  1395.             case 0x0d:
  1396.                 nlines = 2;
  1397.                 antic_d();
  1398.                 break;
  1399.             case 0x0e:
  1400.                 nlines = 1;
  1401.                 antic_e();
  1402.                 break;
  1403.             case 0x0f:
  1404.                 nlines = 1;
  1405.                 if (!enable_xcolpf1) {
  1406.                     GTIA_PutByte(_COLPF1, (COLPF2 & 0xf0) | (COLPF1 & 0x0f));
  1407.                     colpf1_fiddled = TRUE;
  1408.                 }
  1409.                 antic_f();
  1410.                 break;
  1411.             default:
  1412.                 nlines = 0;
  1413.                 JVB = TRUE;
  1414.                 break;
  1415.             }
  1416.             break;
  1417.         }
  1418.  
  1419.         if (nlines > 0) {
  1420.             nlines--;
  1421.  
  1422. /*
  1423.  * Should be able to optimise the (i >= vskipbefore) ...
  1424.  * into just the number of lines to display :-)
  1425.  
  1426.  * Hopefully I did it right (PS)
  1427.  
  1428.  for (i = 0; i < nlines; i++) {
  1429.  if ((i >= vskipbefore) && (i <= vskipafter)) {
  1430.  pmg_dma();
  1431.  Atari_ScanLine();
  1432.  }
  1433.  }
  1434.  */
  1435.  
  1436.             i = nlines < vskipafter ? nlines : vskipafter;
  1437.             i -= vskipbefore;
  1438.             while (i--) {
  1439.                 pmg_dma();
  1440.                 Atari_ScanLine();
  1441.             }
  1442.  
  1443.             if (IR & 0x80) {
  1444.                 if (NMIEN & 0x80) {
  1445.                     NMIST |= 0x80;
  1446.                     NMI();
  1447.                 }
  1448.             }
  1449.             pmg_dma();
  1450.             Atari_ScanLine();
  1451.         }
  1452.  
  1453.         GO(28);                    /* horizontal blank - 28 cycles - helps in hundred of games */
  1454.  
  1455.         vskipbefore = 0;
  1456.         vskipafter = 99;
  1457.  
  1458.         if (colpf1_fiddled)
  1459.             GTIA_PutByte(_COLPF1, colpf1);
  1460.     }
  1461.  
  1462.     nlines = (ATARI_HEIGHT + 8) - ypos;
  1463.     antic_blank(nlines);
  1464.     for (i = 0; i < nlines; i++) {
  1465.         pmg_dma();
  1466.         Atari_ScanLine();
  1467.     }
  1468.  
  1469.     NMIST = 0x40;                /* Set VBLANK */
  1470.     if (NMIEN & 0x40) {
  1471.         GO(1);                    /* Needed for programs that monitor NMIST (Spy's Demise) */
  1472.         NMI();
  1473.     }
  1474.     if (tv_mode == PAL)
  1475.         for (ypos = 248; ypos < 312; ypos++)
  1476.             GO(114);
  1477.     else
  1478.         for (ypos = 248; ypos < 262; ypos++)
  1479.             GO(114);
  1480. }
  1481.  
  1482. UBYTE ANTIC_GetByte(UWORD addr)
  1483. {
  1484.     UBYTE byte;
  1485.  
  1486.     addr &= 0xff0f;
  1487.     switch (addr) {
  1488.     case _CHBASE:
  1489.         byte = CHBASE;
  1490.         break;
  1491.     case _CHACTL:
  1492.         byte = CHACTL;
  1493.         break;
  1494.     case _DLISTL:
  1495.         byte = DLISTL;
  1496.         break;
  1497.     case _DLISTH:
  1498.         byte = DLISTH;
  1499.         break;
  1500.     case _DMACTL:
  1501.         byte = DMACTL;
  1502.         break;
  1503.     case _PENH:
  1504.     case _PENV:
  1505.         byte = 0x00;
  1506.         break;
  1507.     case _VCOUNT:
  1508.         byte = ypos >> 1;
  1509.         break;
  1510.     case _NMIEN:
  1511.         byte = NMIEN;
  1512.         break;
  1513.     case _NMIST:
  1514.         byte = NMIST;
  1515.         break;
  1516.     case _WSYNC:
  1517.         wsync_halt++;
  1518.         byte = 0;
  1519.         break;
  1520.     }
  1521.  
  1522.     return byte;
  1523. }
  1524.  
  1525. int ANTIC_PutByte(UWORD addr, UBYTE byte)
  1526. {
  1527.     int abort = FALSE;
  1528.  
  1529.     addr &= 0xff0f;
  1530.     switch (addr) {
  1531.     case _CHBASE:
  1532.         CHBASE = byte;
  1533.         chbase_40 = (byte << 8) & 0xfc00;
  1534.         chbase_20 = (byte << 8) & 0xfe00;
  1535.         break;
  1536.     case _CHACTL:
  1537.         CHACTL = byte;
  1538. /*
  1539.    =================================================================
  1540.    Check for vertical reflect, video invert and character blank bits
  1541.    =================================================================
  1542.  */
  1543.         switch (CHACTL & 0x07) {
  1544.         case 0x00:
  1545.             char_offset = 0;
  1546.             char_delta = 1;
  1547.             invert_mask = 0x00;
  1548.             blank_mask = 0x00;
  1549.             break;
  1550.         case 0x01:
  1551.             char_offset = 0;
  1552.             char_delta = 1;
  1553.             invert_mask = 0x00;
  1554.             blank_mask = 0x80;
  1555.             break;
  1556.         case 0x02:
  1557.             char_offset = 0;
  1558.             char_delta = 1;
  1559.             invert_mask = 0x80;
  1560.             blank_mask = 0x00;
  1561.             break;
  1562.         case 0x03:
  1563.             char_offset = 0;
  1564.             char_delta = 1;
  1565.             invert_mask = 0x80;
  1566.             blank_mask = 0x80;
  1567.             break;
  1568.         case 0x04:
  1569.             char_offset = 7;
  1570.             char_delta = -1;
  1571.             invert_mask = 0x00;
  1572.             blank_mask = 0x00;
  1573.             break;
  1574.         case 0x05:
  1575.             char_offset = 7;
  1576.             char_delta = -1;
  1577.             invert_mask = 0x00;
  1578.             blank_mask = 0x80;
  1579.             break;
  1580.         case 0x06:
  1581.             char_offset = 7;
  1582.             char_delta = -1;
  1583.             invert_mask = 0x80;
  1584.             blank_mask = 0x00;
  1585.             break;
  1586.         case 0x07:
  1587.             char_offset = 7;
  1588.             char_delta = -1;
  1589.             invert_mask = 0x80;
  1590.             blank_mask = 0x80;
  1591.             break;
  1592.         }
  1593.         break;
  1594.     case _DLISTL:
  1595.         DLISTL = byte;
  1596.         break;
  1597.     case _DLISTH:
  1598.         DLISTH = byte;
  1599.         break;
  1600.     case _DMACTL:
  1601.         DMACTL = byte;
  1602.         switch (DMACTL & 0x03) {
  1603.         case 0x00:
  1604.             dmactl_xmin_noscroll = dmactl_xmax_noscroll = 0;
  1605.             dmactl_xmin_scroll = dmactl_xmax_scroll = 0;
  1606.             break;
  1607.         case 0x01:
  1608.             dmactl_xmin_noscroll = 64;
  1609.             dmactl_xmax_noscroll = ATARI_WIDTH - 64;
  1610.             dmactl_xmin_scroll = 32;
  1611.             dmactl_xmax_scroll = ATARI_WIDTH - 32;
  1612.             break;
  1613.         case 0x02:
  1614.             dmactl_xmin_noscroll = 32;
  1615.             dmactl_xmax_noscroll = ATARI_WIDTH - 32;
  1616.             dmactl_xmin_scroll = 0;
  1617.             dmactl_xmax_scroll = ATARI_WIDTH;
  1618.             break;
  1619.         case 0x03:
  1620.             dmactl_xmin_noscroll = dmactl_xmin_scroll = 0;
  1621.             dmactl_xmax_noscroll = dmactl_xmax_scroll = ATARI_WIDTH;
  1622.             break;
  1623.         }
  1624.  
  1625.         if (DMACTL & 0x04)
  1626.             missile_dma_enabled = TRUE;
  1627.         else
  1628.             missile_dma_enabled = FALSE;
  1629.  
  1630.         if (DMACTL & 0x08)
  1631.             player_dma_enabled = TRUE;
  1632.         else
  1633.             player_dma_enabled = FALSE;
  1634.  
  1635.         if (DMACTL & 0x10)
  1636.             singleline = TRUE;
  1637.         else
  1638.             singleline = FALSE;
  1639.         break;
  1640.     case _HSCROL:
  1641.         HSCROL = byte & 0x0f;
  1642.         break;
  1643.     case _NMIEN:
  1644.         NMIEN = byte;
  1645.         break;
  1646.     case _NMIRES:
  1647.         NMIST = 0x00;
  1648.         break;
  1649.     case _PMBASE:
  1650.         {
  1651.             UWORD pmbase_s;
  1652.             UWORD pmbase_d;
  1653.  
  1654.             PMBASE = byte;
  1655.  
  1656.             pmbase_s = (PMBASE & 0xf8) << 8;
  1657.             pmbase_d = (PMBASE & 0xfc) << 8;
  1658.  
  1659.             maddr_s = pmbase_s + 768;
  1660.             p0addr_s = pmbase_s + 1024;
  1661.             p1addr_s = pmbase_s + 1280;
  1662.             p2addr_s = pmbase_s + 1536;
  1663.             p3addr_s = pmbase_s + 1792;
  1664.  
  1665.             maddr_d = pmbase_d + 384;
  1666.             p0addr_d = pmbase_d + 512;
  1667.             p1addr_d = pmbase_d + 640;
  1668.             p2addr_d = pmbase_d + 768;
  1669.             p3addr_d = pmbase_d + 896;
  1670.         }
  1671.         break;
  1672.     case _VSCROL:
  1673.         VSCROL = byte & 0x0f;
  1674.         break;
  1675.     case _WSYNC:
  1676.         wsync_halt++;
  1677.         abort = TRUE;
  1678.         break;
  1679.     }
  1680.  
  1681.     return abort;
  1682. }
  1683.