home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / GFX / viewer / flick-1.4.lha / src / flick.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-05  |  57.8 KB  |  1,984 lines
  1. /*****************************************************************************
  2.  
  3.         Flick FLI-format Animation Viewer v1.4           5 Jan 1994
  4.         --------------------------------------
  5.  
  6.  
  7. This program plays FLI/FLC-format bitmapped animation files on any ECS,
  8. AGA or EGS Amiga running OS2.04 or higher.  FLI/FLC-format files are
  9. produced by Autodesk Animator and Autodesk 3D Studio on a PC, as well
  10. as by other programs.
  11.  
  12. The files in this archive may be distributed anywhere provided they are
  13. unmodified and are not sold for profit.
  14.  
  15. Ownership and copyright of all files remains with the author:
  16.  
  17.     Peter McGavin, 86 Totara Crescent, Lower Hutt, New Zealand.
  18.     e-mail: peterm@maths.grace.cri.nz
  19.  
  20. *****************************************************************************/
  21.  
  22. #include "includes.h"
  23.  
  24. const char version[] = "$VER: Flick 1.4 " __AMIGADATE__ ;
  25.  
  26. long __oslibversion = 37;    /* we require at least OS2.0 */
  27.  
  28. char __stdiowin[] = "CON:20/50/500/130/Flick";
  29. char __stdiov37[] = "/AUTO/CLOSE";
  30.  
  31. #define FLI_256_COLOR  4
  32. #define FLI_SS2        7
  33. #define FLI_COLOR     11
  34. #define FLI_LC        12
  35. #define FLI_BLACK     13
  36. #define FLI_BRUN      15
  37. #define FLI_COPY      16
  38. #define FLI_PSTAMP    18
  39.  
  40. struct header {
  41.   ULONG size;
  42.   UWORD magic;
  43.   UWORD frames;
  44.   UWORD width;
  45.   UWORD height;
  46.   UWORD depth;
  47.   UWORD flags;
  48.   ULONG speed;
  49.   UWORD reserved1;
  50.   ULONG created;
  51.   ULONG creator;
  52.   ULONG updated;
  53.   ULONG updater;
  54.   UWORD aspectx;
  55.   UWORD aspecty;
  56.   UBYTE reserved2[38];
  57.   ULONG oframe1;
  58.   ULONG oframe2;
  59.   UBYTE reserved3[40];
  60. };
  61.  
  62. struct frameheader {
  63.   ULONG size;
  64.   UWORD magic;
  65.   UWORD chunks;
  66.   UBYTE expand[8];
  67. };
  68.  
  69. struct chunkheader {
  70.   ULONG size;
  71.   UWORD type;
  72. };
  73.  
  74. struct options {
  75.   BOOL ram;
  76.   enum mode_type mode;
  77.   BOOL once;
  78.   BOOL rom;
  79.   BOOL dbuf;
  80.   BOOL warp;
  81.   BOOL akiko;
  82. };
  83.  
  84. struct Library *EGSBase = NULL;
  85. struct Library *EGSGfxBase = NULL;
  86. struct Library *EGSBlitBase = NULL;
  87. struct Library *EGSIntuiBase = NULL;
  88.  
  89. PLANEPTR raster[2] = {NULL, NULL};    /* 8 contiguous bitplanes */
  90. struct BitMap screen_bm[2];    /* The displayed bitmap */
  91. struct RastPort rp[2];
  92.  
  93. UWORD __chip emptypointer[] = {
  94.     0x0000, 0x0000,        /* reserved, must be NULL */
  95.     0x0000, 0x0000,     /* 1 row of image data */
  96.     0x0000, 0x0000};    /* reserved, must be NULL */
  97.  
  98. struct NewScreen ns = {
  99.         0,0,0,0,0,
  100.         2,1,
  101.         0 /* HIRES | LACE */,
  102.         CUSTOMSCREEN | CUSTOMBITMAP,
  103.         NULL,
  104.         NULL,
  105.         NULL,
  106.         &screen_bm[0]
  107. };
  108.  
  109. struct NewWindow nw = {
  110.         0,0,            /* Starting corner */
  111.         0,0,            /* Width, height */
  112.         2,1,            /* detail, block pens */
  113.         IDCMP_VANILLAKEY | IDCMP_RAWKEY | IDCMP_MOUSEBUTTONS, /* IDCMP flags */
  114.         WFLG_ACTIVATE | WFLG_BORDERLESS | WFLG_RMBTRAP,    /* Window flags */
  115.         NULL,            /* Pointer to first gadget */
  116.         NULL,            /* Pointer to checkmark */
  117.         NULL,            /* title */
  118.         NULL,            /* screen pointer */
  119.         NULL,            /* bitmap pointer */
  120.         0,0,0,0,        /* window not sized */
  121.         CUSTOMSCREEN        /* type of screen */
  122.         };
  123.  
  124. struct Screen *s = NULL;
  125. struct Window *w = NULL;
  126.  
  127. static struct EI_NewScreen ei_ns = {
  128.     NULL,                     /* screenmode name is put here later... */
  129.     8, 0, &version[6],        /* depth, pad, title */
  130.     NULL,                     /* CLUPtr */
  131.     { 3, 1, 0, 2, 1, 3, 1 },  /* WinColors */
  132.     0,                        /* backPen */
  133.     NULL,                     /* backPattern */
  134.     NULL,                     /* Maus */
  135.     NULL                      /* TextAttr */
  136. };
  137.  
  138. static struct EI_NewWindow ei_nw =
  139. {
  140.     0, 0, 320, 200,         /* LeftEdge, TopEdge, Width, Height */
  141.     0, 0, 320, 200,        /* MinWidth,MinHeight, MaxWidth, MaxHeight */
  142.     NULL,            /* Screen - might be set to some screen later */
  143.     EI_WINDOWCLOSE | EI_WINDOWBACK | EI_WINDOWDRAG,    /* SysGadgets */
  144.     NULL,            /* FirstGadgets */
  145.     &version[6],        /* Title */
  146.     EI_SMART_REFRESH | EI_GIMMEZEROZERO | EI_WINDOWACTIVE | EI_RMBTRAP,    /* Flags */
  147.     EI_iCLOSEWINDOW | EI_iVANILLAKEY | EI_iRAWKEY | EI_iMOUSEBUTTONS |
  148.         EI_iACTIVEWINDOW | EI_iINACTIVEWINDOW,    /*EI_IDCMPFlags */
  149.     NULL,            /*Port */
  150.     {0,0,0,0,0,0,0},    /* Colors */
  151.     NULL,            /* Menu */
  152.     NULL            /* Render */
  153. };
  154.  
  155. EI_ScreenPtr ei_s = NULL;
  156. EI_WindowPtr ei_w = NULL;
  157. E_EBitMapPtr e_bm = NULL;
  158. E_CLU *e_oldscreencolours = NULL;
  159. E_CLU *e_screencolours = NULL;
  160. EG_RastPortPtr eg_rp;
  161.  
  162. UWORD screen_width;
  163. UWORD screen_depth;
  164. UWORD screen_width32;        /* screen_width/32 */
  165.  
  166. struct ScreenBuffer *sb[2] = {NULL, NULL};
  167. struct MsgPort *safeport = NULL;
  168. struct MsgPort *dispport = NULL;
  169. BOOL safe = TRUE;
  170. BOOL disp = TRUE;
  171.  
  172. struct RastPort temprp;        /* for WritePixelArray8() */
  173. struct BitMap tmp_bm;        /* for WritePixelArray8(), Height=1, Depth=? */
  174. PLANEPTR tmpras = NULL;        /* for WritePixelArray8() */
  175.  
  176. UBYTE *chunky = NULL;        /* screen_width*h.height chunky pixels */
  177.  
  178. struct header h;
  179.  
  180. struct Library *TimerBase = NULL;
  181. struct MsgPort *timermp = NULL;
  182. struct timerequest *timerio = NULL;
  183. ULONG timerclosed = TRUE;
  184. struct EClockVal *time = NULL;
  185. struct EClockVal *time0 = NULL;
  186. struct EClockVal *time1 = NULL;
  187. double micros_per_eclock;    /* Length of EClock tick in microseconds */
  188.  
  189. struct Task *thistask = NULL;
  190. BOOL v39 = FALSE;
  191. BOOL v40 = FALSE;
  192. ULONG cpu_type;  /* 68000, 68010, 68020, 68030, 68040, 68060 */
  193.  
  194. char programname[20];
  195. BPTR olddir = NULL;
  196. struct RDArgs *rdargs = NULL;
  197.  
  198. struct Library *AslBase = NULL;
  199. struct FileRequester *fr = NULL;
  200.  
  201.  
  202. /****************************************************************************/
  203.  
  204. void swapw (UWORD *w)
  205. /* Swap the bytes around in a word which may be on an odd byte-boundary */
  206. {
  207.   UBYTE t;
  208.  
  209.   t = ((UBYTE *)w)[0];
  210.   ((UBYTE *)w)[0] = ((UBYTE *)w)[1];
  211.   ((UBYTE *)w)[1] = t;
  212. }
  213.  
  214. void swapl (ULONG *l)
  215. /* Swap the bytes around in a longword which may be on an odd byte-boundary */
  216. {
  217.   UBYTE t;
  218.  
  219.   t = ((UBYTE *)l)[0];
  220.   ((UBYTE *)l)[0] = ((UBYTE *)l)[3];
  221.   ((UBYTE *)l)[3] = t;
  222.   t = ((UBYTE *)l)[1];
  223.   ((UBYTE *)l)[1] = ((UBYTE *)l)[2];
  224.   ((UBYTE *)l)[2] = t;
  225. }
  226.  
  227. UWORD extractw (UWORD *w)
  228. /* Get a word which may be on an odd byte-boundary */
  229. {
  230.   UBYTE t[2];
  231.  
  232.   t[0] = ((UBYTE *)w)[0];
  233.   t[1] = ((UBYTE *)w)[1];
  234.   return *(UWORD *)t;
  235. }
  236.  
  237. ULONG extractl (ULONG *l)
  238. /* Get a longword which may be on an odd byte-boundary */
  239. {
  240.   UBYTE t[4];
  241.  
  242.   t[0] = ((UBYTE *)l)[0];
  243.   t[1] = ((UBYTE *)l)[1];
  244.   t[2] = ((UBYTE *)l)[2];
  245.   t[3] = ((UBYTE *)l)[3];
  246.   return *(ULONG *)t;
  247. }
  248.  
  249. /****************************************************************************/
  250.  
  251. void close_screen (void)
  252. {
  253.   int which;
  254.  
  255.   if (chunky != NULL) {
  256.     if (e_bm == NULL || chunky != e_bm->Plane)
  257.       free (chunky);
  258.     chunky = NULL;
  259.   };
  260.   if (e_bm != NULL) {
  261.     e_bm->Lock--;
  262.     E_DisposeBitMap(e_bm);
  263.     e_bm = NULL;
  264.   }
  265.   if (e_oldscreencolours != NULL) {
  266.     E_SetRGB8CM (ei_w->WScreen->EScreen, e_oldscreencolours, 0, 256);
  267.     free (e_oldscreencolours);
  268.     e_oldscreencolours = NULL;
  269.   }
  270.   if (e_screencolours != NULL) {
  271.     free (e_screencolours);
  272.     e_screencolours = NULL;
  273.   }
  274.   if (ei_w != NULL) {
  275.     EI_CloseWindow (ei_w);
  276.     ei_w = NULL;
  277.   }
  278.   if (ei_s != NULL) {
  279.     EI_CloseScreen (ei_s);
  280.     ei_s = NULL;
  281.   }
  282.   if (w != NULL) {
  283.     ClearPointer (w);
  284.     CloseWindow (w);
  285.     w = NULL;
  286.   }
  287.   if (sb[1] != NULL) {
  288.     FreeScreenBuffer (s, sb[1]);
  289.     sb[1] = NULL;
  290.   }
  291.   if (sb[0] != NULL) {
  292.     FreeScreenBuffer (s, sb[0]);
  293.     sb[0] = NULL;
  294.   }
  295.   if (s != NULL) {
  296.     CloseScreen (s);
  297.     s = NULL;
  298.   }
  299.   if (dispport != NULL) {
  300.     DeletePort (dispport);
  301.     dispport = NULL;
  302.   }
  303.   if (safeport != NULL) {
  304.     DeletePort (safeport);
  305.     safeport = NULL;
  306.   }
  307.   for (which = 0; which < 2; which++) {
  308.     if (raster[which] != NULL) {
  309.       FreeRaster (raster[which], screen_width, screen_depth * h.height);
  310.       raster[which] = NULL;
  311.     }
  312.   }
  313. }
  314.  
  315. /****************************************************************************/
  316.  
  317. void _STDcleanup (void)
  318. /* This get called automatically by SAS/C 6.3 on any sort of exit condition */
  319. {
  320.   if (!safe) {
  321.     Wait (1 << safeport->mp_SigBit);
  322.     while (GetMsg (safeport) != NULL) /* clear message queue */
  323.       /* nothing */ ;
  324.     safe = TRUE;
  325.   }
  326.   if (!disp) {
  327.     Wait (1 << dispport->mp_SigBit);
  328.     while (GetMsg (dispport) != NULL) /* clear message queue */
  329.       /* nothing */ ;
  330.     disp = TRUE;
  331.   }
  332.   close_screen ();
  333.   if (tmpras != NULL) {
  334.     FreeRaster (tmpras, screen_width, screen_depth);
  335.     tmpras = NULL;
  336.   }
  337.   if (fr != NULL) {
  338.     FreeAslRequest (fr);
  339.     fr = NULL;
  340.   }
  341.   if (AslBase != NULL) {
  342.     CloseLibrary (AslBase);
  343.     AslBase = NULL;
  344.   }
  345.   if (time1 != NULL) {
  346.     FreeMem (time1, sizeof(struct EClockVal));
  347.     time1 = NULL;
  348.   }
  349.   if (time0 != NULL) {
  350.     FreeMem (time0, sizeof(struct EClockVal));
  351.     time0 = NULL;
  352.   }
  353.   if (time != NULL) {
  354.     FreeMem (time, sizeof(struct EClockVal));
  355.     time = NULL;
  356.   }
  357.   if (olddir != NULL) {
  358.     CurrentDir (olddir);
  359.     olddir = NULL;
  360.   }
  361.   if (rdargs != NULL) {
  362.     FreeArgs (rdargs);
  363.     rdargs = NULL;
  364.   }
  365.   if (!timerclosed) {
  366.     CloseDevice ((struct IORequest *)timerio);
  367.     timerclosed = TRUE;
  368.     TimerBase = NULL;
  369.   }
  370.   if (timerio != NULL) {
  371.     DeleteExtIO ((struct IORequest *)timerio);
  372.     timerio = NULL;
  373.   }
  374.   if (timermp != NULL) {
  375.     DeletePort (timermp);
  376.     timermp = NULL;
  377.   }
  378.   if (EGSIntuiBase != NULL) {
  379.     CloseLibrary (EGSIntuiBase);
  380.     EGSIntuiBase = NULL;
  381.   }
  382.   if (EGSBlitBase != NULL) {
  383.     CloseLibrary (EGSBlitBase);
  384.     EGSBlitBase = NULL;
  385.   }
  386.   if (EGSGfxBase != NULL) {
  387.     CloseLibrary (EGSGfxBase);
  388.     EGSGfxBase = NULL;
  389.   }
  390.   if (EGSBase != NULL) {
  391.     CloseLibrary (EGSBase);
  392.     EGSBase = NULL;
  393.   }
  394.   /* standard libraries are auto-closed here by SAS/C */
  395. }
  396.  
  397. /****************************************************************************/
  398.  
  399. static char bodystring[64];
  400.  
  401. static struct TextAttr topaz80 = {
  402.   "topaz.font", 8, 0, 0
  403. };
  404.  
  405. static struct IntuiText bodytext[] = {
  406.   {0, 1, JAM2, 10, 8, &topaz80, programname, &bodytext[1]},
  407.   {0, 1, JAM2, 10, 20, &topaz80, bodystring, NULL},
  408. };
  409.  
  410. static struct IntuiText negtext = {0, 1, JAM2, 6, 3, &topaz80, "Ok", NULL};
  411.  
  412. void die (char *msg, ...)
  413. /* Exit program with message, return code 10 */
  414. {
  415.   va_list arglist;
  416.  
  417.   va_start (arglist, msg);
  418.   vsprintf (bodystring, msg, arglist);
  419.   va_end (arglist);
  420.   AutoRequest (w, &bodytext[0], NULL, &negtext, 0, 0, 320, 60);
  421.   exit (10);
  422.   /* SAS/C executes _STDcleanup() automatically on exit */
  423. }
  424.  
  425. /****************************************************************************/
  426.  
  427. void *malloc_check (size_t size)
  428. {
  429.   void *p;
  430.  
  431.   if ((p = malloc (size)) == NULL)
  432.     die ("%s: Out of memory trying to allocate %ld bytes!", programname,
  433.          size);
  434.   return (p);
  435. }
  436.  
  437. /****************************************************************************/
  438.  
  439. void c2p_rom (UBYTE *chunky,
  440.               UBYTE *copy_of_chunky,
  441.               struct RastPort *rp,
  442.               struct RastPort *temprp,
  443.               UBYTE *dirty_list)
  444. {
  445.   ULONG h32, *p1, *p2;
  446.   UWORD x, y0, y1, w32, i;
  447.   UBYTE *p;
  448.  
  449.   w32 = screen_width >> 5;
  450.   h32 = w32 * (h.height - 1);
  451.   for (x = 0; x < screen_width; x += 32) {
  452.     p = dirty_list;
  453.     y0 = 0;
  454.     while (y0++ < h.height && !*p)
  455.       p += w32;
  456.     if (y0 < h.height) {
  457.       y0--;
  458.       p = dirty_list + h32;
  459.       y1 = h.height - 1;
  460.       while (!*p) {
  461.         p -= w32;
  462.         y1--;
  463.       }
  464.       p2 = (ULONG *)copy_of_chunky;
  465.       p1 = (ULONG *)(&chunky[y0 * (rp->BitMap->BytesPerRow << 3) + x]);
  466.       for (i = y1 - y0 + 1; i > 0; i--) {
  467.         *p2++ = *p1++;
  468.         *p2++ = *p1++;
  469.         *p2++ = *p1++;
  470.         *p2++ = *p1++;
  471.         *p2++ = *p1++;
  472.         *p2++ = *p1++;
  473.         *p2++ = *p1++;
  474.         *p2++ = *p1;
  475.         p1 += (screen_width >> 2) - 7;
  476.       }
  477.       WritePixelArray8 (rp, x, y0, x + 31, y1, copy_of_chunky, temprp);
  478.     }
  479.     dirty_list++;
  480.   }
  481. }
  482.  
  483. /****************************************************************************/
  484.  
  485. void c2p_egs (E_EBitMapPtr e_bm,
  486.               EG_RastPortPtr eg_rp,
  487.               UBYTE *dirty_list,
  488.               ULONG plsiz)
  489. {
  490.   ULONG h32;
  491.   UWORD x, y0, y1, w32;
  492.   UBYTE *p;
  493.  
  494.   w32 = e_bm->Width >> 5;
  495.   h32 = w32 * (e_bm->Height - 1);
  496.   for (x = 0; x < e_bm->Width; x += 32) {
  497.     p = dirty_list;
  498.     y0 = 0;
  499.     while (y0++ < e_bm->Height && !*p)
  500.       p += w32;
  501.     if (y0 < e_bm->Height) {
  502.       y0--;
  503.       p = dirty_list + h32;
  504.       y1 = e_bm->Height - 1;
  505.       while (!*p) {
  506.         p -= w32;
  507.         y1--;
  508.       }
  509.       EG_CopyBitMapRastPort (e_bm, eg_rp, x, y0, 32, y1 - y0 + 1, x, y0);
  510.     }
  511.     dirty_list++;
  512.   }
  513.  
  514. /*
  515.   UWORD d, x, y;
  516.  
  517.   x = 0;
  518.   y = 0;
  519.   for (d = plsiz >> 2; d > 0; d--) {
  520.     if (*dirty_list++ != 0)
  521.       EG_CopyBitMapRastPort (e_bm, eg_rp, x, y, 32, 1, x, y);
  522.     if ((x += 32) >= screen_width) {
  523.       x = 0;
  524.       y++;
  525.     }
  526.   }
  527. */
  528.  
  529. /*
  530.   EG_CopyBitMapRastPort (e_bm, eg_rp, 0, 0, e_bm->Width, e_bm->Height, 0, 0);
  531. */
  532. }
  533.  
  534. /****************************************************************************/
  535.  
  536. void decode_ss2 (UBYTE *chunkbuf, UBYTE *chunky, struct header *h,
  537.                  UBYTE *dirty_list)
  538. {
  539.   UWORD lines, packets, bsize, start;
  540.   ULONG tmp;
  541.   UBYTE *chunky2;
  542.  
  543.   lines = *chunkbuf++;
  544.   lines |= (*chunkbuf++ << 8);
  545.   for ( ; lines > 0; lines--) {
  546.     do {
  547.       packets = *chunkbuf++;
  548.       packets |= (*chunkbuf++ << 8);
  549.       if (packets > 32767)
  550.         if (packets > 49151) {
  551.           tmp = (65536 - packets) * (ULONG)screen_width;
  552.           chunky += tmp;
  553.           dirty_list += (tmp >> 5);
  554.         } else {
  555.           *(chunky + h->width - 1) = (packets & 0xff);
  556.           dirty_list[(h->width - 1) >> 5] = TRUE;
  557.         }
  558.     } while (packets >= 32768);
  559.     chunky2 = chunky;
  560.     for ( ; packets > 0; packets--) {
  561.       chunky2 += *chunkbuf++;
  562.       bsize = *chunkbuf++;
  563.       start = (chunky2 - chunky) >> 5;
  564.       if (bsize > 127) {
  565.         bsize = 256 - bsize;
  566. /*
  567.         repmem (chunky2, chunkbuf, 2, bsize);
  568.         chunky2 += (bsize << 1);
  569. */
  570.         for ( ; bsize > 0; bsize--) {
  571.           *chunky2++ = *chunkbuf;
  572.           *chunky2++ = *(chunkbuf + 1);
  573.         }
  574.         chunkbuf += 2;
  575.       } else {
  576.         bsize <<= 1;
  577.         memcpy (chunky2, chunkbuf, bsize);
  578. /*
  579.         CopyMem (chunkbuf, chunky2, bsize);
  580. */
  581.         chunkbuf += bsize;
  582.         chunky2 += bsize;
  583.       }
  584.       memset (&dirty_list[start], TRUE, ((chunky2-1 - chunky) >> 5) - start + 1);
  585.     }
  586.     chunky += screen_width;
  587.     dirty_list += screen_width32;
  588.   }
  589. }
  590.  
  591.  
  592. void decode_ss2_xlate (UBYTE *chunkbuf, UBYTE *chunky, struct header *h,
  593.                        UBYTE *xlate, UBYTE *dirty_list)
  594. {
  595.   UWORD lines, packets, bsize, start;
  596.   ULONG tmp;
  597.   UBYTE *chunky2, pattern[2];
  598.  
  599.   lines = *chunkbuf++;
  600.   lines |= (*chunkbuf++ << 8);
  601.   for ( ; lines > 0; lines--) {
  602.     do {
  603.       packets = *chunkbuf++;
  604.       packets |= (*chunkbuf++ << 8);
  605.       if (packets > 32767)
  606.         if (packets > 49151) {
  607.           tmp = (65536 - packets) * (ULONG)screen_width;
  608.           chunky += tmp;
  609.           dirty_list += (tmp >> 5);
  610.         } else {
  611.           *(chunky + h->width - 1) = xlate[packets & 0xff];
  612.           dirty_list[(h->width - 1) >> 5] = TRUE;
  613.         }
  614.     } while (packets >= 32768);
  615.     chunky2 = chunky;
  616.     for ( ; packets > 0; packets--) {
  617.       chunky2 += *chunkbuf++;
  618.       bsize = *chunkbuf++;
  619.       start = (chunky2 - chunky) >> 5;
  620.       if (bsize > 127) {
  621.         bsize = 256 - bsize;
  622.         pattern[0] = xlate[*chunkbuf++];
  623.         pattern[1] = xlate[*chunkbuf++];
  624. /*
  625.         repmem (chunky2, pattern, 2, bsize);
  626.         chunky2 += (bsize << 1);
  627. */
  628.         for ( ; bsize > 0; bsize--) {
  629.           *chunky2++ = pattern[0];
  630.           *chunky2++ = pattern[1];
  631.         }
  632.       } else {
  633.         bsize <<= 1;
  634.         for ( ; bsize > 0; bsize--)
  635.           *chunky2++ = xlate[*chunkbuf++];
  636.       }
  637.       memset (&dirty_list[start], TRUE, ((chunky2-1 - chunky) >> 5) - start + 1);
  638.     }
  639.     chunky += screen_width;
  640.     dirty_list += screen_width32;
  641.   }
  642. }
  643.  
  644.  
  645. #if 0
  646. void decode_lc (UBYTE *chunkbuf, UBYTE *chunky,
  647.                 UBYTE *xlate, enum mode_type mode, UBYTE *dirty_list)
  648. {
  649.   UBYTE *chunky2;
  650.   UWORD lines, packets, bsize, start;
  651.  
  652.   start = *chunkbuf++;
  653.   start |= (*chunkbuf++ << 8);
  654.   chunky = &chunky[start * screen_width];
  655.   dirty_list = &dirty_list[start * screen_width32];
  656.   lines = *chunkbuf++;
  657.   lines |= (*chunkbuf++ << 8);
  658.   for ( ; lines > 0; lines--) {
  659.     chunky2 = chunky;
  660.     for (packets = *chunkbuf++; packets > 0; packets--) {
  661.       chunky2 += *chunkbuf++;
  662.       bsize = *chunkbuf++;
  663.       start = (chunky2 - chunky) >> 5;
  664.       if (bsize > 127) {
  665.         bsize = 256 - bsize;
  666.         memset (chunky2, xlate[*chunkbuf++], bsize);
  667.         chunky2 += bsize;
  668.       } else {
  669.         if (mode == MODE_COLOUR) {
  670.           memcpy (chunky2, chunkbuf, bsize);
  671. /*
  672.           CopyMem (chunkbuf, chunky2, bsize);
  673. */
  674.           chunkbuf += bsize;
  675.           chunky2 += bsize;
  676.         } else
  677.           for ( ; bsize > 0; bsize--)
  678.             *chunky2++ = xlate[*chunkbuf++];
  679.       }
  680.       memset (&dirty_list[start], TRUE, ((chunky2-1 - chunky) >> 5) - start + 1);
  681.     }
  682.     chunky += screen_width;
  683.     dirty_list += screen_width32;
  684.   }
  685. }
  686. #endif
  687.  
  688. void decode_brun (UBYTE *chunkbuf, UBYTE *chunky, struct header *h,
  689.                   UBYTE *xlate, enum mode_type mode, UBYTE *dirty_list)
  690. {
  691.   UBYTE *chunky2;
  692.   UWORD lines, bsize;
  693.  
  694.   for (lines = h->height; lines > 0; lines--) {
  695.     chunky2 = chunky + h->width;
  696.     chunkbuf++;    /* skip packet count */
  697.     while (chunky < chunky2) {
  698.       bsize = *chunkbuf++;
  699.       if (bsize <= 127) {
  700.         memset (chunky, xlate[*chunkbuf++], bsize);
  701.         chunky += bsize;
  702.       } else {
  703.         bsize = 256 - bsize;
  704.         if (mode == MODE_COLOUR) {
  705.           memcpy (chunky, chunkbuf, bsize);
  706. /*
  707.           CopyMem (chunkbuf, chunky, bsize);
  708. */
  709.           chunkbuf += bsize;
  710.           chunky += bsize;
  711.         } else
  712.           for ( ; bsize > 0; bsize--)
  713.             *chunky++ = xlate[*chunkbuf++];
  714.       }
  715.     }
  716.     chunky += (screen_width - h->width);
  717.     memset (dirty_list, TRUE, ((h->width - 1) >> 5) + 1);
  718.     dirty_list += screen_width32;
  719.   }
  720. }
  721.  
  722.  
  723. /****************************************************************************/
  724.  
  725. int open_screen (char *fname, struct options *opt)
  726. {
  727.   int which, depth;
  728.  
  729.   if (opt->mode == MODE_EGS) {
  730.  
  731.     if (EGSBase == NULL ||
  732.         EGSGfxBase == NULL ||
  733.         EGSBlitBase == NULL ||
  734.         EGSIntuiBase == NULL)
  735.       return (FALSE);
  736.  
  737.     if ((ei_ns.Mode = getenv ("FLICK")) != NULL) {
  738.       if ((ei_s = EI_OpenScreen (&ei_ns)) == NULL) {
  739.         fprintf (stderr, "Can't open \"%s\" EGS screen!\n", ei_ns.Mode);
  740.         return (FALSE);
  741.       }
  742.       ei_nw.Screen = ei_s;
  743.       ei_nw.LeftEdge = (ei_s->Width - screen_width) >> 1;
  744.       ei_nw.TopEdge = (ei_s->Height - h.height) >> 1;
  745.     }
  746.  
  747.     ei_nw.Width = screen_width;
  748.     ei_nw.Height = h.height;
  749.     ei_nw.Title = fname;
  750.     if ((ei_w = EI_OpenWindow (&ei_nw)) == NULL) {
  751.       close_screen ();
  752.       return (FALSE);
  753.     }
  754.     eg_rp = ei_w->RPort;
  755.  
  756.     if (ei_w->WScreen->EScreen->Map->Depth != 8) {
  757.       fprintf (stderr, "Default EGS screen is not depth 8!\n");
  758.       fprintf (stderr, "Use 'setenv FLICK \"egs-mode-name\"' to select another EGS mode\n");
  759.       close_screen ();
  760.       return (FALSE);
  761.     }
  762.  
  763.     if ((e_bm = E_AllocBitMap (screen_width, h.height, 8, E_PIXELMAP, 0, 0))
  764.                                                                      == NULL) {
  765.       close_screen ();
  766.       return (FALSE);
  767.     }
  768.     e_bm->Lock++;    /* ensure EGS system doesn't move bitmap memory */
  769.     chunky = e_bm->Plane;
  770.  
  771.   } else {
  772.     switch (opt->mode) {
  773.       case MODE_COLOUR:
  774.         if (!v39)
  775.           return (FALSE);
  776.         screen_depth = 8;
  777.         break;
  778.       case MODE_EHB:
  779.         ns.ViewModes |= EXTRA_HALFBRITE;
  780.         screen_depth = 6;
  781.         break;
  782.       case MODE_COLOUR4:
  783.       case MODE_GREY:
  784.         screen_depth = 4;
  785.       default:
  786.         break;
  787.     }
  788.     ns.Width = screen_width;
  789.     ns.Height = h.height;
  790.     ns.Depth = screen_depth;
  791.     if (screen_width > 384)
  792.       ns.ViewModes |= HIRES;
  793.     else
  794.       ns.ViewModes &= ~HIRES;
  795.     if (h.height > 283)
  796.       ns.ViewModes |= LACE;
  797.     else
  798.       ns.ViewModes &= ~LACE;
  799.  
  800.     /* allocate 2 rasters (for double-buffering) and initialise rp[] */
  801.     if (v39 && opt->rom) {
  802.       ns.Type &= ~CUSTOMBITMAP;  /* allow for mode promotion with ROM option */
  803.       ns.CustomBitMap = NULL;    /* i.e, no custom bitmap */
  804.     } else {
  805.       ns.Type |= CUSTOMBITMAP;
  806.       ns.CustomBitMap = &screen_bm[0];
  807.       for (which = 0; which < (opt->dbuf ? 2 : 1); which++) {
  808.         InitBitMap (&screen_bm[which], screen_depth, screen_width, h.height); /* Displayed bm */
  809.         /* Allocate 1 contiguous raster for all screen_depth planes */
  810.         if ((raster[which] = (PLANEPTR)AllocRaster (screen_width,
  811.                                               screen_depth * h.height)) == NULL) {
  812.           close_screen ();
  813.           return (FALSE);
  814.         }
  815.         for (depth = 0; depth < screen_depth; depth++)
  816.           screen_bm[which].Planes[depth] = raster[which] +
  817.                                          depth * RASSIZE (screen_width, h.height);
  818.         InitRastPort (&rp[which]);
  819.         rp[which].BitMap = &screen_bm[which];
  820.         SetRast (&rp[which], 0);
  821.       }
  822.     }
  823.  
  824.     if ((s = OpenScreen(&ns)) == NULL) {
  825.       close_screen ();
  826.       return (FALSE);
  827.     }
  828.  
  829.     /* allocate structures for double-buffering (if v39) */
  830.     if (v39 && opt->dbuf) {
  831.       if ((safeport = CreatePort (NULL, 0)) == NULL ||
  832.           (dispport = CreatePort (NULL, 0)) == NULL)
  833.         die ("%s: Can't create port!", programname);
  834.       if (opt->rom) {
  835.         if ((sb[0] = AllocScreenBuffer (s, NULL, SB_SCREEN_BITMAP)) == NULL ||
  836.             (sb[1] = AllocScreenBuffer (s, NULL, 0)) == NULL) {
  837.           fprintf (stderr, "Can't allocate structure for double buffering\n");
  838.           close_screen ();
  839.           return (FALSE);
  840.         }
  841.       } else {
  842.         if ((sb[0] = AllocScreenBuffer (s, &screen_bm[0], 0)) == NULL ||
  843.             (sb[1] = AllocScreenBuffer (s, &screen_bm[1], 0)) == NULL) {
  844.           fprintf (stderr, "Can't allocate structure for double buffering\n");
  845.           close_screen ();
  846.           return (FALSE);
  847.         }
  848.       }
  849.       sb[0]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort = safeport;
  850.       sb[0]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort = dispport;
  851.       sb[1]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort = safeport;
  852.       sb[1]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort = dispport;
  853.     }
  854.  
  855.     /* initialise rp[] for ROM option */
  856.     if (v39 && opt->rom) {
  857.       InitRastPort (&rp[0]);
  858.       rp[0].BitMap = s->RastPort.BitMap;
  859.       SetRast (&rp[0], 0);
  860.       if (opt->dbuf) {
  861.         InitRastPort (&rp[1]);
  862.         rp[1].BitMap = sb[1]->sb_BitMap;
  863.         SetRast (&rp[1], 0);
  864.       }
  865.     }
  866.  
  867.     /* open a backdrop window (for intuition events) */
  868.     nw.Width = screen_width;
  869.     nw.Height = h.height;
  870.     nw.Screen = s;
  871.     nw.MinWidth = screen_width;
  872.     nw.MinHeight = h.height;
  873.     nw.MaxWidth = screen_width;
  874.     nw.MaxHeight = h.height;
  875.     if ((w = OpenWindow(&nw)) == NULL) {
  876.       close_screen ();
  877.       return (FALSE);
  878.     }
  879.  
  880.     /* allocate chunky pixels */
  881.     if ((chunky = (UBYTE *)malloc (screen_width * (ULONG)h.height)) == NULL) {
  882.       close_screen ();
  883.       return (FALSE);
  884.     }
  885.  
  886.   }
  887.   memset (chunky, 0, screen_width * (ULONG)h.height);
  888.   return (TRUE);
  889. }
  890.  
  891. /****************************************************************************/
  892.  
  893. void parse_tooltypes (char *fname, struct options *opt)
  894. {
  895.   struct DiskObject *obj;
  896.   char **toolarray;
  897.  
  898.   if ((obj = GetDiskObject (fname)) != NULL) {
  899.     toolarray = obj->do_ToolTypes;
  900.     if (FindToolType (toolarray, "DISK") != NULL)
  901.       opt->ram = FALSE;
  902.     if (FindToolType (toolarray, "RAM") != NULL)
  903.       opt->ram = FALSE;
  904.     if (FindToolType (toolarray, "ONCE") != NULL)
  905.       opt->once = TRUE;
  906.     if (FindToolType (toolarray, "COLOUR") != NULL ||
  907.         FindToolType (toolarray, "COLOR") != NULL)
  908.       opt->mode = MODE_COLOUR;
  909.     if (FindToolType (toolarray, "EHB") != NULL)
  910.       opt->mode = MODE_EHB;
  911.     if (FindToolType (toolarray, "COLOUR4") != NULL ||
  912.         FindToolType (toolarray, "COLOR4") != NULL)
  913.       opt->mode = MODE_COLOUR4;
  914.     if (FindToolType (toolarray, "GREY") != NULL ||
  915.         FindToolType (toolarray, "GRAY") != NULL)
  916.       opt->mode = MODE_GREY;
  917.     if (FindToolType (toolarray, "EGS") != NULL)
  918.       opt->mode = MODE_EGS;
  919.     if (FindToolType (toolarray, "ROM") != NULL)
  920.       opt->rom = TRUE;
  921.     if (FindToolType (toolarray, "DBUF") != NULL)
  922.       opt->dbuf = TRUE;
  923.     if (FindToolType (toolarray, "WARP") != NULL)
  924.       opt->warp = TRUE;
  925.     if (FindToolType (toolarray, "NOAKIKO") != NULL)
  926.       opt->akiko = FALSE;
  927.     FreeDiskObject (obj);
  928.   }
  929. }
  930.  
  931. /****************************************************************************/
  932.  
  933. void animate_file (char *fname, struct options opt)
  934. {
  935.   FILE *f;
  936.   ULONG size, class, ei_class, totalframes, restartpos, l, *lp, *lp0, *lp1;
  937.   UWORD i, frame, chunk, code, ei_code;
  938.   UWORD packets, n, m, c, lines, depth, which;
  939.   UWORD *viewcolourtable;
  940.   UBYTE (*colourtable)[256][3];
  941.   struct IntuiMessage *msg;
  942.   struct EI_EIntuiMsg *ei_msg;
  943.   UBYTE *filebuf, *buf, *framebuf, *chunkbuf, *p, *p2;
  944.   UBYTE *dirty_list[2], *combined_dirty_list, *copy_of_chunky;
  945.   UBYTE *restartptr, *xlate;
  946.   BOOL going, firstloop;
  947.   struct frameheader *fh;
  948.   struct chunkheader *ch;
  949.   ULONG fh_size;
  950.   UWORD fh_magic, fh_chunks, ch_type;
  951.   BOOL palette_changed;
  952.   int oldpri;
  953.   struct EClockVal eclocks, next_time;
  954.   void __asm (*c2p)(register __a0 UBYTE *chunky_data,
  955.                     register __a1 PLANEPTR raster,
  956.                     register __a2 UBYTE *dirty_list,
  957.                     register __d1 ULONG plsiz,
  958.                     register __a5 UBYTE *tmp_buffer);
  959.  
  960.  
  961.   /* initialise resources */
  962.   f = NULL;
  963.   viewcolourtable = NULL;
  964.   filebuf = NULL;
  965.   framebuf = NULL;
  966.   dirty_list[0] = NULL;
  967.   dirty_list[1] = NULL;
  968.   combined_dirty_list = NULL;
  969.   copy_of_chunky = NULL;
  970.   xlate = NULL;
  971.   colourtable = NULL;
  972.   fh = NULL;
  973.  
  974.   parse_tooltypes (fname, &opt);
  975.  
  976.   if (opt.mode == MODE_EGS) {
  977.     opt.dbuf = FALSE;
  978.     opt.rom = FALSE;
  979.   }
  980.  
  981.   /* open file and read header struct */
  982.   if ((f = fopen (fname, "rb")) == NULL)
  983.     die ("%s: Can't open %s", programname, fname);
  984.   if ((fread (&h, sizeof(struct header), 1, f)) != 1)
  985.     die ("%s: Error reading file", programname);
  986.   swapl (&h.size);
  987.   swapw (&h.magic);
  988.   swapw (&h.frames);
  989.   swapw (&h.width);
  990.   swapw (&h.height);
  991.   swapw (&h.depth);
  992.   swapw (&h.flags);
  993.   swapl (&h.speed);
  994.   swapl (&h.creator);
  995.   swapl (&h.updater);
  996.   swapw (&h.aspectx);
  997.   swapw (&h.aspecty);
  998.   swapl (&h.oframe1);
  999.   swapl (&h.oframe2);
  1000.  
  1001.   printf ("File = %s\n", fname);
  1002.   printf ("%lu bytes, %u frames, %ux%ux%u, speed = %u\n", h.size, h.frames,
  1003.           h.width, h.height, h.depth, h.speed);
  1004.  
  1005.   eclocks.ev_hi = 0;
  1006.   if (h.magic == 0xaf11) {
  1007.     eclocks.ev_lo = (ULONG)((1000000.0 / 70.0) * h.speed / micros_per_eclock + 0.5);
  1008.     if (h.speed != 0)
  1009.       printf ("Defined frames per second = %4.1lf", 70.0 / h.speed);
  1010.     putchar ('\n');
  1011.   } else if (h.magic == 0xaf12) {
  1012.     eclocks.ev_lo = (ULONG)((1000000.0 / 1000.0) * h.speed / micros_per_eclock + 0.5);
  1013.     if (h.speed != 0)
  1014.       printf ("Defined frames per second = %4.1lf", 1000.0 / h.speed);
  1015.     putchar ('\n');
  1016.   } else
  1017.     die ("%s: Unrecognised magic number %04x", programname, h.magic);
  1018.   if (opt.warp)
  1019.     eclocks.ev_lo = 0;
  1020.  
  1021.   /* allow for AGA modes */
  1022.   screen_width = (h.width + 63) & ~63;
  1023.   screen_width32 = (screen_width >> 5);
  1024.  
  1025.   /* allocate dirty lists */
  1026.   for (which = 0; which < (opt.dbuf ? 2 : 1); which++) {
  1027.     dirty_list[which] = malloc_check (screen_width32 * (ULONG)h.height + 8);
  1028.     memset (dirty_list[which], FALSE, screen_width32 * (ULONG)h.height + 8);
  1029.   }
  1030.  
  1031.   if (opt.dbuf) {
  1032.     combined_dirty_list = malloc_check (screen_width32 * (ULONG)h.height + 8);
  1033.     memset (combined_dirty_list, FALSE, screen_width32 * (ULONG)h.height + 8);
  1034.   } else
  1035.     combined_dirty_list = dirty_list[0];
  1036.  
  1037.   /* if using ram then read in the entire file else allocate header buffers */
  1038.   if (opt.ram)
  1039.     if ((filebuf = malloc (h.size - sizeof(struct header))) == NULL) {
  1040.       printf ("%s: Not enough free contiguous memory to load into RAM\n", programname);
  1041.       printf ("       Playing from disk instead\n");
  1042.       opt.ram = FALSE;
  1043.     } else {
  1044.       if ((fread (filebuf, h.size - sizeof(struct header), 1, f)) != 1)
  1045.         die ("%s: Error reading file", programname);
  1046.       buf = filebuf;
  1047.     }
  1048.   if (!opt.ram) {
  1049.     fh = malloc_check (sizeof(struct frameheader));
  1050.   }
  1051.  
  1052.   /* open screen with custom bitmap */
  1053.   while (!open_screen (fname, &opt)) {
  1054.     switch (opt.mode) {
  1055.       case MODE_COLOUR:
  1056.         printf ("%s: Can't open 8 bitplane COLOUR screen\n", programname);
  1057.         if (ns.ViewModes & HIRES) {
  1058.           printf ("       Trying 4 bitplane COLOUR4 instead\n");
  1059.           opt.mode = MODE_COLOUR4;
  1060.         } else {
  1061.           printf ("       Trying 6 bitplane EHB instead\n");
  1062.           opt.mode = MODE_EHB;
  1063.         }
  1064.         break;
  1065.       case MODE_EHB:
  1066.         printf ("%s: Can't open 6 bitplane EHB screen\n", programname);
  1067.         printf ("       Trying 4 bitplane COLOUR4 instead\n");
  1068.         opt.mode = MODE_COLOUR4;
  1069.         break;
  1070.       case MODE_EGS:
  1071.         printf ("%s: Can't open 8 bitplane EGS screen\n", programname);
  1072.         printf ("       Trying 8 bitplane COLOUR instead\n");
  1073.         opt.mode = MODE_COLOUR;
  1074.         break;
  1075.       case MODE_COLOUR4:
  1076.       case MODE_GREY:
  1077.       default:
  1078.         die ("%s: Can't open screen!", programname);
  1079.     }
  1080.     Delay (100);
  1081.   }
  1082.  
  1083.   /* initialise tmp stuff for WritePixelArray8() */
  1084.   if (opt.rom) {
  1085.     if ((tmpras = (PLANEPTR)AllocRaster (screen_width, screen_depth)) == NULL)
  1086.       die ("%s: Out of memory", programname);
  1087.     InitBitMap (&tmp_bm, screen_depth, screen_width, 1);
  1088.     for (depth = 0; depth < screen_depth; depth++)
  1089.       tmp_bm.Planes[depth] = tmpras + depth * RASSIZE (screen_width, 1);
  1090.     temprp = rp[0];
  1091.     temprp.Layer = NULL;
  1092.     temprp.BitMap = &tmp_bm;
  1093.   }
  1094.  
  1095.   /* turn the mouse pointer off for this window */
  1096.   if (opt.mode != MODE_EGS)
  1097.     SetPointer (w, emptypointer, 1, 16, 0, 0);
  1098.  
  1099.   /* allocate and initialise colour tables and pixel xlate table */
  1100.   colourtable = (UBYTE (*)[256][3])malloc_check (sizeof(*colourtable));
  1101.   memset (colourtable, 0, sizeof(*colourtable));
  1102.   xlate = malloc_check (256);
  1103.  
  1104.   switch (opt.mode) {
  1105.     case MODE_COLOUR4:
  1106.     case MODE_EHB:
  1107.       viewcolourtable = (UWORD *)malloc_check ((1 << screen_depth) * sizeof(UWORD));
  1108.       memset (viewcolourtable, 0, (1 << screen_depth) * sizeof(UWORD));
  1109.       break;
  1110.     case MODE_GREY:
  1111.       viewcolourtable = (UWORD *)malloc_check ((1 << screen_depth) * sizeof(UWORD));
  1112.       memset (viewcolourtable, 0, (1 << screen_depth) * sizeof(UWORD));
  1113.       for (c = 0; c < 16; c++)
  1114.         viewcolourtable[c] = c * 0x0111;
  1115.       LoadRGB4 (&s->ViewPort, viewcolourtable, 1 << screen_depth);
  1116.       break;
  1117.     case MODE_COLOUR:
  1118.       viewcolourtable = (UWORD *)malloc_check (2 * sizeof(UWORD) +
  1119.                        (1 << screen_depth) * 3 * sizeof(ULONG) + sizeof(UWORD));
  1120.       memset (viewcolourtable, 0, 2 * sizeof(UWORD) +
  1121.                        (1 << screen_depth) * 3 * sizeof(ULONG) + sizeof(UWORD));
  1122.       viewcolourtable[0] = 1 << screen_depth;
  1123.       for (i = 0; i < 256; i++)
  1124.         xlate[i] = i;
  1125.       break;
  1126.     case MODE_EGS:
  1127.       e_screencolours = (E_CLU *)malloc_check (256 * sizeof(E_CLU));
  1128.       e_oldscreencolours = (E_CLU *)malloc_check (256 * sizeof(E_CLU));
  1129.       E_GetRGB8CM (ei_w->WScreen->EScreen, e_oldscreencolours, 0, 256);
  1130.       E_GetRGB8CM (ei_w->WScreen->EScreen, e_screencolours, 0, 256);
  1131.       for (i = 0; i < 256; i++)
  1132.         xlate[i] = i;
  1133.       break;
  1134.   }
  1135.  
  1136.   /* select a chunky to planar (c2p) routine */
  1137.   if (opt.mode != MODE_EGS) {
  1138.     if (opt.rom) {
  1139.       copy_of_chunky = malloc_check (screen_width * (ULONG)h.height);
  1140.     } else if (v40 && opt.akiko && (GfxBase->ChunkyToPlanarPtr != NULL)) {
  1141.       copy_of_chunky = (UBYTE *)GfxBase->ChunkyToPlanarPtr;
  1142.       switch (screen_depth) {
  1143.         case 4:
  1144.           c2p = c2p_4_akiko;
  1145.           break;
  1146.         case 6:
  1147.           c2p = c2p_6_akiko;
  1148.           break;
  1149.         case 8:
  1150.           c2p = c2p_8_akiko;
  1151.           break;
  1152.         default:
  1153.           die ("%s: Unsupported resolution", programname);
  1154.           break;
  1155.       }
  1156.     } else {
  1157.       switch (cpu_type) {
  1158.         case 68000:
  1159.         case 68010:
  1160.           switch (screen_depth) {
  1161.             case 4:
  1162.               c2p = c2p_4_000;
  1163.               break;
  1164.             case 6:
  1165.               c2p = c2p_6_000;
  1166.               break;
  1167.             case 8:
  1168.               c2p = c2p_8_000;
  1169.               break;
  1170.             default:
  1171.               die ("%s: Unsupported resolution", programname);
  1172.               break;
  1173.           }
  1174.           break;
  1175.         case 68020:
  1176.         case 68030:
  1177.           copy_of_chunky = malloc_check (screen_width * (ULONG)h.height);
  1178.           switch (screen_depth) {
  1179.             case 4:
  1180.               c2p = c2p_4_020;
  1181.               break;
  1182.             case 6:
  1183.               c2p = c2p_6_020;
  1184.               break;
  1185.             case 8:
  1186.               c2p = c2p_8_020;
  1187.               break;
  1188.             default:
  1189.               die ("%s: Unsupported resolution", programname);
  1190.               break;
  1191.           }
  1192.           break;
  1193.         case 68040:
  1194.         case 68060:
  1195.           switch (screen_depth) {
  1196.             case 4:
  1197.               c2p = c2p_4_040;
  1198.               break;
  1199.             case 6:
  1200.               c2p = c2p_6_040;
  1201.               break;
  1202.             case 8:
  1203.               c2p = c2p_8_040;
  1204.               break;
  1205.             default:
  1206.               die ("%s: Unsupported resolution", programname);
  1207.               break;
  1208.           }
  1209.           break;
  1210.         default:
  1211.           die ("%s: Unsupported CPU type %d", programname, cpu_type);
  1212.       }
  1213.     }
  1214.   }
  1215.  
  1216.   /* initialise loop variables */
  1217.   which = 0;    /* bitmap index --- flips between 0 and 1 with each frame */
  1218.   palette_changed = FALSE;
  1219.   frame = 0;
  1220.   totalframes = 0;
  1221.   firstloop = TRUE;
  1222.   going = TRUE;
  1223.  
  1224.   /* read the start time */
  1225.   ReadEClock (time0);
  1226.   next_time = *time0;
  1227.   add64 (&next_time, &eclocks);
  1228.  
  1229.   /* loop for each frame */
  1230.   while (going) {
  1231.  
  1232.     /* if this is the 2nd frame, save the current file-position for loop */
  1233.     if (totalframes == 1)
  1234.       if (opt.ram)
  1235.         restartptr = buf;
  1236.       else
  1237.         if ((restartpos = ftell (f)) == -1)
  1238.           die ("%s: Error ftelling file", programname);
  1239.  
  1240.     /* read the frame header */
  1241.     if (opt.ram) {
  1242.       fh = (struct frameheader *)buf;
  1243.       buf += sizeof(struct frameheader);
  1244.     } else
  1245.       if ((fread (fh, sizeof(struct frameheader), 1, f)) != 1)
  1246.         die ("%s: Error reading file", programname);
  1247.     if (firstloop || !opt.ram) {
  1248.       swapl (&fh->size);
  1249.       swapw (&fh->magic);
  1250.       swapw (&fh->chunks);
  1251.     }
  1252.     fh_size = extractl (&fh->size);
  1253.     fh_magic = extractw (&fh->magic);
  1254.     fh_chunks = extractw (&fh->chunks);
  1255.  
  1256.     /* allocate memory for and read the rest of the frame */
  1257.     if (opt.ram) {
  1258.       framebuf = buf;
  1259.     } else {
  1260.       size = fh_size - sizeof(struct frameheader);
  1261.       if (size == 0)
  1262.         framebuf = NULL;
  1263.       else {
  1264.         framebuf = malloc_check (size);
  1265.         if ((fread (framebuf, size, 1, f)) != 1)
  1266.           die ("%s: Error reading file", programname);
  1267.         buf = framebuf;
  1268.       }
  1269.     }
  1270.  
  1271.     /* check for and ignore 0xf100 frames */
  1272.     if (fh_magic == 0xf100) {
  1273.  
  1274.       totalframes--;    /* don't count this frame */
  1275.       frame--;
  1276.  
  1277.     } else {
  1278.  
  1279.       /* consistency check */
  1280.       if (fh_magic != 0xf1fa)
  1281.         die ("%s: Unrecognised magic number in frame %04x %lu",
  1282.                  programname, fh_magic, fh_size);
  1283.  
  1284.       /* render into the non-displayed raster (if double-buffering) */
  1285.       if (opt.dbuf)
  1286.         which = 1 - which;
  1287.  
  1288.       /* clear the dirty list for this frame */
  1289.       memset (dirty_list[which], FALSE, screen_width32 * (ULONG)h.height);
  1290.  
  1291.       /* loop for each chunk */
  1292.       for (chunk = 0; chunk < fh_chunks; chunk++) {
  1293.  
  1294.         /* examine the chunk header */
  1295.         ch = (struct chunkheader *)buf;
  1296.         if (firstloop || !opt.ram) {
  1297.           swapl (&ch->size);
  1298.           swapw (&ch->type);
  1299.         }
  1300.         chunkbuf = buf + sizeof(struct chunkheader);
  1301.         buf += (extractl (&ch->size) + 1) & ~1;
  1302.         ch_type = extractw (&ch->type);
  1303.  
  1304.         /* uncompress chunk into chunky pixels */
  1305.         switch (ch_type) {
  1306.  
  1307.           case FLI_SS2:
  1308.             if (opt.mode == MODE_COLOUR || opt.mode == MODE_EGS)
  1309.               decode_ss2 (chunkbuf, chunky, &h, dirty_list[which]);
  1310.             else
  1311.               decode_ss2_xlate (chunkbuf, chunky, &h, xlate, dirty_list[which]);
  1312.             break;
  1313.  
  1314.           case FLI_256_COLOR:
  1315.           case FLI_COLOR:
  1316.             p = chunkbuf;
  1317.             packets = *p++;
  1318.             packets |= (*p++ << 8);
  1319.             c = 0;
  1320.             for ( ; packets > 0; packets--) {
  1321.               c += *p++;
  1322.               n = *p++;
  1323.               if (n == 0)
  1324.                 n = 256;
  1325.               for (m = 0; m < n; m++) {
  1326.                 if (ch_type == FLI_256_COLOR) {
  1327.                   (*colourtable)[c][0] = *p++;        /* R */
  1328.                   (*colourtable)[c][1] = *p++;        /* G */
  1329.                   (*colourtable)[c][2] = *p++;        /* B */
  1330.                 } else {
  1331.                   (*colourtable)[c][0] = *p++ << 2;    /* R */
  1332.                   (*colourtable)[c][1] = *p++ << 2;    /* G */
  1333.                   (*colourtable)[c][2] = *p++ << 2;    /* B */
  1334.                 }
  1335.                 c++;
  1336.               }
  1337.             }
  1338.             switch (opt.mode) {
  1339.               case MODE_COLOUR4:
  1340.               case MODE_EHB:
  1341.                 median_cut (*colourtable, viewcolourtable, xlate, opt.mode);
  1342.                 break;
  1343.               case MODE_GREY:
  1344.                 for (c = 0; c < 256; c++)
  1345.                   xlate[c] = ((((UWORD)(*colourtable)[c][0]) +
  1346.                                ((UWORD)(*colourtable)[c][1]) +
  1347.                                ((UWORD)(*colourtable)[c][2])) / 3) >> 4;
  1348.                 break;
  1349.               case MODE_COLOUR:
  1350.                 break;
  1351.               case MODE_EGS:
  1352.                 for (c = 0; c < 256; c++) {
  1353.                   e_screencolours[c].Red = (*colourtable)[c][0];
  1354.                   e_screencolours[c].Green = (*colourtable)[c][1];
  1355.                   e_screencolours[c].Blue = (*colourtable)[c][2];
  1356.                 }
  1357.                 break;
  1358.             }
  1359.             palette_changed = TRUE;
  1360.             break;            
  1361.  
  1362.           case FLI_LC:
  1363.             if (opt.mode == MODE_COLOUR || opt.mode == MODE_EGS)
  1364.               decode_lc (chunkbuf, chunky, dirty_list[which]);
  1365.             else
  1366.               decode_lc_xlate (chunkbuf, chunky, xlate, dirty_list[which]);
  1367.             break;
  1368.  
  1369.           case FLI_BLACK:
  1370.             memset (chunky, xlate[0], screen_width * (ULONG)h.height);
  1371.             memset (dirty_list[which], TRUE, screen_width32 * (ULONG)h.height);
  1372.             break;
  1373.  
  1374.           case FLI_BRUN:
  1375.             decode_brun (chunkbuf, chunky, &h, xlate, opt.mode,
  1376.                          dirty_list[which]);
  1377.             break;
  1378.  
  1379.           case FLI_COPY:
  1380.             if (opt.mode == MODE_COLOUR || opt.mode == MODE_EGS)
  1381.               if (h.width == screen_width) {
  1382. /*
  1383.                 memcpy (chunky, chunkbuf, h.width * (ULONG)h.height);
  1384. */
  1385.                 CopyMemQuick (chunkbuf, chunky, screen_width * (ULONG)h.height);
  1386.               } else {
  1387.                 p = chunkbuf;
  1388.                 p2 = chunky;
  1389.                 for (lines = h.height; lines > 0; lines--) {
  1390.                   CopyMemQuick (p, p2, h.width);
  1391.                   p += h.width;
  1392.                   p2 += screen_width;
  1393.                 }
  1394.               }
  1395.             else {
  1396.               if (h.width == screen_width) {
  1397.                 p2 = chunky;
  1398.                 for (l = h.width * (ULONG)h.height; l > 0; l--)
  1399.                   *p2++ = xlate[*p++];
  1400.               } else {
  1401.                 p = chunkbuf;
  1402.                 p2 = chunky;
  1403.                 for (lines = h.height; lines > 0; lines--) {
  1404.                   for (i = h.width; i > 0; i--)
  1405.                     *p2++ = xlate[*p++];
  1406.                   p2 += (screen_width - h.width);
  1407.                 }
  1408.               }
  1409.             }
  1410.             memset (dirty_list[which], TRUE, screen_width32 * (ULONG)h.height);
  1411.             break;
  1412.  
  1413.           case FLI_PSTAMP:
  1414.             break;
  1415.  
  1416.           default:
  1417.             die ("%s: Unrecognised chunk type %04x", programname, ch_type);
  1418.             break;
  1419.         } /* end of switch for each chunk type */
  1420.  
  1421.       } /* end of loop for each chunk within frame */
  1422.  
  1423.       /* if double-buffering, combine the dirty lists */
  1424.       if (opt.dbuf) {
  1425.         lp0 = (ULONG *)dirty_list[which];
  1426.         lp1 = (ULONG *)dirty_list[1 - which];
  1427.         lp = (ULONG *)combined_dirty_list;
  1428.         for (l = ((screen_width32 * (ULONG)h.height) >> 2) + 1; l > 0; l--)
  1429.           *lp++ = *lp0++ | *lp1++;
  1430.       }
  1431.  
  1432.       /* update amiga's colourtable if palette has changed in this frame */
  1433.       if (palette_changed) {
  1434.         switch (opt.mode) {
  1435.           case MODE_COLOUR4:
  1436.             LoadRGB4 (&s->ViewPort, viewcolourtable, 16);
  1437.             break;
  1438.           case MODE_EHB:
  1439.             LoadRGB4 (&s->ViewPort, viewcolourtable, 32);
  1440.             break;
  1441.           case MODE_GREY:
  1442.             break;
  1443.           case MODE_COLOUR:
  1444.             for (c = 0; c < (1 << screen_depth); c++) {
  1445.               ((ULONG *)viewcolourtable)[3*c+1] = (*colourtable)[c][0] << 24;
  1446.               ((ULONG *)viewcolourtable)[3*c+2] = (*colourtable)[c][1] << 24;
  1447.               ((ULONG *)viewcolourtable)[3*c+3] = (*colourtable)[c][2] << 24;
  1448.             }
  1449.             LoadRGB32 (&s->ViewPort, (ULONG *)viewcolourtable);
  1450.             break;
  1451.           case MODE_EGS:
  1452.             E_SetRGB8CM (ei_w->WScreen->EScreen, e_screencolours, 0, 256);
  1453.             break;
  1454.         }
  1455.         palette_changed = FALSE;
  1456.       }
  1457.  
  1458.       /* Wait until it is safe to modify bitmap without flicker (if v39) */
  1459.       if (v39 && opt.dbuf) {
  1460.         if (!safe) {
  1461.           Wait (1 << safeport->mp_SigBit);
  1462.           while (GetMsg (safeport) != NULL) /* clear message queue */
  1463.             /* nothing */ ;
  1464.           safe = TRUE;
  1465.         }
  1466.       }
  1467.  
  1468.       /* convert from chunky pixels to (hidden) planar raster[which] */
  1469.       if (opt.mode == MODE_EGS)
  1470.         c2p_egs (e_bm, eg_rp, combined_dirty_list,
  1471.                  (screen_width * (ULONG)h.height) >> 3);
  1472. /*
  1473.         EG_CopyBitMapRastPort (e_bm, eg_rp, 0, 0, screen_width, h.height, 0, 0);
  1474. */
  1475.       else if (opt.rom) {
  1476.         /* WritePixelArray8() destroys original chunky, so make a copy */
  1477. /*
  1478.         CopyMemQuick (chunky, copy_of_chunky, screen_width * (ULONG)h.height);
  1479.         WritePixelArray8 (&rp[which], 0, 0, screen_width-1, h.height-1,
  1480.                           copy_of_chunky, &temprp);
  1481. */
  1482.         c2p_rom (chunky, copy_of_chunky, &rp[which], &temprp,
  1483.                  combined_dirty_list);
  1484.       } else
  1485.         c2p (chunky, raster[which], combined_dirty_list,
  1486.              (screen_width * (ULONG)h.height) >> 3, copy_of_chunky);
  1487.  
  1488.       /* wait for time between frames */
  1489.       ReadEClock (time);
  1490.       if (cmp64 (time, &next_time) > 0) {
  1491.         timerio->tr_node.io_Command = TR_ADDREQUEST;
  1492.         *(struct EClockVal *)&timerio->tr_time = next_time;
  1493.         sub64 ((struct EClockVal *)&timerio->tr_time, time); /* timerio->tr_time -= time */
  1494.         /* oldpri = SetTaskPri (thistask, 20); */ /* don't flicker when mouse moves */
  1495.         DoIO ((struct IORequest *)timerio);  /* delay */
  1496.         /* SetTaskPri (thistask, oldpri); */ /* restore task priority */
  1497.       }
  1498.       while (cmp64 (time, &next_time) > 0) {
  1499.         ReadEClock (time);
  1500.       }
  1501.       next_time = *time;
  1502.       add64 (&next_time, &eclocks);
  1503.  
  1504.       /* make the new raster visible (if double-buffering) */
  1505.       if (opt.dbuf) {
  1506.         if (v39) {
  1507.           oldpri = SetTaskPri (thistask, 20); /* don't flicker when mouse moves */
  1508.           /* Wait until it is safe to swap bitmaps without flicker */
  1509.           if (!disp) {
  1510.             Wait (1 << dispport->mp_SigBit);
  1511.             while (GetMsg (dispport) != NULL) /* clear message queue */
  1512.               /* nothing */ ;
  1513.             disp = TRUE;
  1514.           }
  1515.           if (ChangeScreenBuffer (s, sb[which])) {
  1516.             disp = FALSE;
  1517.             safe = FALSE;
  1518.           }
  1519.           SetTaskPri (thistask, oldpri); /* restore task priority */
  1520.         } else {
  1521.           s->ViewPort.RasInfo->BitMap = &screen_bm[which];
  1522.           MakeScreen (s);
  1523.           RethinkDisplay ();
  1524.         }
  1525.       }
  1526.  
  1527.       /* check for CTRL/C or BREAK */
  1528.       if (SetSignal (0, 0) & SIGBREAKF_CTRL_C) {
  1529.         SetSignal (0, SIGBREAKF_CTRL_C);
  1530.         printf ("***Break\n");
  1531.         exit (0);
  1532.       }
  1533.  
  1534.       /* check for intuition messages */
  1535.       if (opt.mode == MODE_EGS) {
  1536.         while ((ei_msg = (struct EI_EIntuiMsg *)GetMsg (ei_w->UserPort)) != NULL) {
  1537.           ei_class = ei_msg->Class;
  1538.           ei_code = ei_msg->Code;
  1539.           ReplyMsg ((struct Message *)ei_msg);
  1540.           switch (ei_class) {
  1541.             case EI_iRAWKEY:
  1542.               switch (ei_code) {
  1543.                 case 0x45: /* ESC */
  1544.                   going = FALSE;
  1545.                   break;
  1546.                 case 0x50: /* F1 */
  1547.                   eclocks.ev_lo = 0;
  1548.                   break;
  1549.                 case 0x51: /* F2 */
  1550.                   eclocks.ev_lo = (ULONG)((1000000.0 / 60.0) / micros_per_eclock + 0.5);
  1551.                   break;
  1552.                 case 0x52: /* F3 */
  1553.                   eclocks.ev_lo = (ULONG)((1000000.0 / 30.0) / micros_per_eclock + 0.5);
  1554.                   break;
  1555.                 case 0x53: /* F4 */
  1556.                   eclocks.ev_lo = (ULONG)((1000000.0 / 24.0) / micros_per_eclock + 0.5);
  1557.                   break;
  1558.                 case 0x54: /* F5 */
  1559.                   eclocks.ev_lo = (ULONG)((1000000.0 / 15.0) / micros_per_eclock + 0.5);
  1560.                   break;
  1561.                 case 0x55: /* F6 */
  1562.                   eclocks.ev_lo = (ULONG)((1000000.0 / 12.0) / micros_per_eclock + 0.5);
  1563.                   break;
  1564.                 case 0x56: /* F7 */
  1565.                   eclocks.ev_lo = (ULONG)((1000000.0 / 10.0) / micros_per_eclock + 0.5);
  1566.                   break;
  1567.                 case 0x57: /* F8 */
  1568.                   eclocks.ev_lo = (ULONG)((1000000.0 / 5.0) / micros_per_eclock + 0.5);
  1569.                   break;
  1570.                 case 0x58: /* F9 */
  1571.                   eclocks.ev_lo = (ULONG)(1000000.0 / micros_per_eclock + 0.5);
  1572.                   break;
  1573.                 case 0x59: /* F10 */
  1574.                   if (h.magic == 0xaf11)
  1575.                     eclocks.ev_lo = (ULONG)((1000000.0 / 70.0) * h.speed /
  1576.                                      micros_per_eclock + 0.5);
  1577.                   else if (h.magic == 0xaf12)
  1578.                     eclocks.ev_lo = (ULONG)((1000000.0 / 1000.0) * h.speed /
  1579.                                      micros_per_eclock + 0.5);
  1580.                   break;
  1581.                 default:
  1582.                   break;
  1583.               }
  1584.               break;
  1585.             case EI_iVANILLAKEY:
  1586.               switch (ei_code) {
  1587.                 case 0x03: /* CTRL/C */
  1588.                   printf ("***Break\n");
  1589.                   exit (0);
  1590.                 case 0x1b: /* ESC */
  1591.                 case 0x51: /* q */
  1592.                 case 0x71: /* Q */
  1593.                   going = FALSE;
  1594.                   break;
  1595.                 case '+':
  1596.                   if (eclocks.ev_lo == 1)
  1597.                     eclocks.ev_lo = 0;
  1598.                   else
  1599.                     eclocks.ev_lo >>= 1;
  1600.                   break;
  1601.                 case '-':
  1602.                   if (eclocks.ev_lo == 0)
  1603.                     eclocks.ev_lo = 1;
  1604.                   else if (eclocks.ev_lo < 500000)
  1605.                     eclocks.ev_lo <<= 1;
  1606.                   break;
  1607.                 default:
  1608.                   break;
  1609.               }
  1610.               break;
  1611.             case EI_iCLOSEWINDOW:
  1612.               going = FALSE;
  1613.               break;
  1614.             case EI_iMOUSEBUTTONS:
  1615.               if (ei_code == MENUDOWN)
  1616.                   going = FALSE;
  1617.               break;
  1618.             case EI_iACTIVEWINDOW:
  1619.               E_SetRGB8CM (ei_w->WScreen->EScreen, e_screencolours, 0, 256);
  1620.               break;
  1621.             case EI_iINACTIVEWINDOW:
  1622.               E_SetRGB8CM (ei_w->WScreen->EScreen, e_oldscreencolours, 0, 256);
  1623.               break;
  1624.             default:
  1625.               break;
  1626.           }
  1627.         }
  1628.       } else {
  1629.         while ((msg = (struct IntuiMessage *)GetMsg (w->UserPort)) != NULL) {
  1630.           class = msg->Class;
  1631.           code = msg->Code;
  1632.           ReplyMsg ((struct Message *)msg);
  1633.           switch (class) {
  1634.             case IDCMP_RAWKEY:
  1635.               switch (code) {
  1636.                 case 0x45: /* ESC */
  1637.                   going = FALSE;
  1638.                   break;
  1639.                 case 0x50: /* F1 */
  1640.                   eclocks.ev_lo = 0;
  1641.                   break;
  1642.                 case 0x51: /* F2 */
  1643.                   eclocks.ev_lo = (ULONG)((1000000.0 / 60.0) / micros_per_eclock + 0.5);
  1644.                   break;
  1645.                 case 0x52: /* F3 */
  1646.                   eclocks.ev_lo = (ULONG)((1000000.0 / 30.0) / micros_per_eclock + 0.5);
  1647.                   break;
  1648.                 case 0x53: /* F4 */
  1649.                   eclocks.ev_lo = (ULONG)((1000000.0 / 24.0) / micros_per_eclock + 0.5);
  1650.                   break;
  1651.                 case 0x54: /* F5 */
  1652.                   eclocks.ev_lo = (ULONG)((1000000.0 / 15.0) / micros_per_eclock + 0.5);
  1653.                   break;
  1654.                 case 0x55: /* F6 */
  1655.                   eclocks.ev_lo = (ULONG)((1000000.0 / 12.0) / micros_per_eclock + 0.5);
  1656.                   break;
  1657.                 case 0x56: /* F7 */
  1658.                   eclocks.ev_lo = (ULONG)((1000000.0 / 10.0) / micros_per_eclock + 0.5);
  1659.                   break;
  1660.                 case 0x57: /* F8 */
  1661.                   eclocks.ev_lo = (ULONG)((1000000.0 / 5.0) / micros_per_eclock + 0.5);
  1662.                   break;
  1663.                 case 0x58: /* F9 */
  1664.                   eclocks.ev_lo = (ULONG)(1000000.0 / micros_per_eclock + 0.5);
  1665.                   break;
  1666.                 case 0x59: /* F10 */
  1667.                   if (h.magic == 0xaf11)
  1668.                     eclocks.ev_lo = (ULONG)((1000000.0 / 70.0) * h.speed /
  1669.                                      micros_per_eclock + 0.5);
  1670.                   else if (h.magic == 0xaf12)
  1671.                     eclocks.ev_lo = (ULONG)((1000000.0 / 1000.0) * h.speed /
  1672.                                      micros_per_eclock + 0.5);
  1673.                   break;
  1674.                 default:
  1675.                   break;
  1676.               }
  1677.               break;
  1678.             case IDCMP_VANILLAKEY:
  1679.               switch (code) {
  1680.                 case 0x03: /* CTRL/C */
  1681.                   printf ("***Break\n");
  1682.                   exit (0);
  1683.                 case 0x1b: /* ESC */
  1684.                 case 0x51: /* q */
  1685.                 case 0x71: /* Q */
  1686.                   going = FALSE;
  1687.                   break;
  1688.                 case '+':
  1689.                   if (eclocks.ev_lo == 1)
  1690.                     eclocks.ev_lo = 0;
  1691.                   else
  1692.                     eclocks.ev_lo >>= 1;
  1693.                   break;
  1694.                 case '-':
  1695.                   if (eclocks.ev_lo == 0)
  1696.                     eclocks.ev_lo = 1;
  1697.                   else if (eclocks.ev_lo < 500000)
  1698.                     eclocks.ev_lo <<= 1;
  1699.                   break;
  1700.                 default:
  1701.                   break;
  1702.               }
  1703.             case IDCMP_MOUSEBUTTONS:
  1704.               if (code == MENUDOWN)
  1705.                   going = FALSE;
  1706.               break;
  1707.             default:
  1708.               break;
  1709.           }
  1710.         }
  1711.       }
  1712.  
  1713.     } /* end of if frame magic != 0xf100 */
  1714.  
  1715.     /* seek to the beginning of the next frame or deallocate frame ram */
  1716.     if (opt.ram)
  1717.       buf = framebuf + fh_size - sizeof(struct frameheader);
  1718.     else
  1719.       if (framebuf != NULL)
  1720.         free (framebuf);
  1721.     framebuf = NULL;
  1722.  
  1723.     /* seek back to frame 1 (the 2nd frame) when we get to the last frame */
  1724.     if (frame++ == h.frames)
  1725.       if (opt.once)
  1726.         going = FALSE;
  1727.       else {
  1728.         firstloop = FALSE;
  1729.         frame = 1;
  1730.         if (opt.ram)
  1731.           buf = restartptr;
  1732.         else
  1733.           if (fseek (f, restartpos, SEEK_SET) == -1)
  1734.             die ("%s: Error seeking file", programname);
  1735.       }
  1736.  
  1737.     totalframes++;
  1738.  
  1739.   } /* end of loop for each frame */
  1740.  
  1741.   if (!safe) {
  1742.     Wait (1 << safeport->mp_SigBit);
  1743.     while (GetMsg (safeport) != NULL) /* clear message queue */
  1744.       /* nothing */ ;
  1745.     safe = TRUE;
  1746.   }
  1747.   if (!disp) {
  1748.     Wait (1 << dispport->mp_SigBit);
  1749.     while (GetMsg (dispport) != NULL) /* clear message queue */
  1750.       /* nothing */ ;
  1751.     disp = TRUE;
  1752.   }
  1753.  
  1754.   /* find out and display how long it took */
  1755.   ReadEClock (time1);
  1756.   sub64 (time1, time0);
  1757.   printf ("%s: Achieved frames per second = %4.1lf\n", programname,
  1758.           1000000.0 * totalframes /
  1759.           ((time1->ev_hi * 4294967296.0 + time1->ev_lo) * micros_per_eclock));
  1760.  
  1761.   /* close files and free memory */
  1762.   if (f != NULL) {
  1763.     fclose (f);
  1764.     f = NULL;
  1765.   }
  1766.   close_screen ();
  1767.   if (colourtable != NULL) {
  1768.     free (colourtable);
  1769.     colourtable = NULL;
  1770.   }
  1771.   if (viewcolourtable != NULL) {
  1772.     free (viewcolourtable);
  1773.     viewcolourtable = NULL;
  1774.   }
  1775.   if (xlate != NULL) {
  1776.     free (xlate);
  1777.     xlate = NULL;
  1778.   }
  1779.   if (filebuf != NULL) {
  1780.     free (filebuf);
  1781.     filebuf = NULL;
  1782.   }
  1783.   if (!opt.ram) {
  1784.     if (fh != NULL) {
  1785.       free (fh);
  1786.       fh = NULL;
  1787.     }
  1788.   }
  1789.   if (opt.dbuf)
  1790.     if (combined_dirty_list != NULL) {
  1791.       free (combined_dirty_list);
  1792.       combined_dirty_list = NULL;
  1793.     }
  1794.   if (dirty_list[1] != NULL) {
  1795.     free (dirty_list[1]);
  1796.     dirty_list[1] = NULL;
  1797.   }
  1798.   if (dirty_list[0] != NULL) {
  1799.     free (dirty_list[0]);
  1800.     dirty_list[0] = NULL;
  1801.   }
  1802.   if (copy_of_chunky != NULL) {
  1803.     if (copy_of_chunky != (UBYTE *)GfxBase->ChunkyToPlanarPtr)
  1804.       free (copy_of_chunky);
  1805.     copy_of_chunky = NULL;
  1806.   }
  1807.   if (tmpras != NULL) {
  1808.     FreeRaster (tmpras, screen_width, screen_depth);
  1809.     tmpras = NULL;
  1810.   }
  1811. }
  1812.  
  1813. /****************************************************************************/
  1814.  
  1815. struct TagItem frtags[] = {
  1816.   {ASL_Hail,        0},
  1817.   {ASL_Pattern,        (ULONG)"#?.fl[ic]"},
  1818.   {ASL_OKText,        (ULONG)"Play"},
  1819.   {ASL_CancelText,    (ULONG)"Cancel"},
  1820.   {ASL_FuncFlags,    FILF_PATGAD},
  1821.   {TAG_DONE,        0}
  1822. };
  1823.  
  1824. char resultstring[128];
  1825.  
  1826. void filerequestloop (struct options *opt)
  1827. {
  1828.   if ((AslBase = OpenLibrary ("asl.library", 37L)) != NULL) {
  1829.     frtags[0].ti_Data = (ULONG)programname;
  1830.     if (AslBase->lib_Version < 39)
  1831.       frtags[1].ti_Data = (ULONG)"#?.fl?";
  1832.     if ((fr = (struct FileRequester *)AllocAslRequest
  1833.                                           (ASL_FileRequest, frtags)) != NULL) {
  1834.       while (AslRequest (fr, NULL)) {
  1835.         strcpy (resultstring, fr->rf_Dir);
  1836.         AddPart (resultstring, fr->rf_File, 128);
  1837.         animate_file (resultstring, *opt);
  1838.       }
  1839.       FreeAslRequest (fr);
  1840.       fr = NULL;
  1841.     }
  1842.     CloseLibrary (AslBase);
  1843.     AslBase = NULL;
  1844.   }
  1845. }
  1846.  
  1847. /****************************************************************************/
  1848.  
  1849. LONG argarray[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  1850.  
  1851. int main (int argc, char *argv[])
  1852. {
  1853.   struct WBStartup *argmsg;
  1854.   struct WBArg *wb_arg;
  1855.   char **fnames;
  1856.   UWORD ktr;
  1857.   struct options opt;
  1858.  
  1859.  
  1860.   /* standard libraries are auto-opened here by SAS/C */
  1861.  
  1862.   /* find out about ourself */
  1863.   thistask = FindTask (NULL);
  1864.   GetProgramName (programname, 19);
  1865.   v39 = (GfxBase->LibNode.lib_Version >= 39);
  1866.   v40 = (GfxBase->LibNode.lib_Version >= 40);
  1867.   if ((SysBase->AttnFlags & AFF_68040) != 0)
  1868.     cpu_type = 68040;
  1869.   else if ((SysBase->AttnFlags & AFF_68030) != 0)
  1870.     cpu_type = 68030;
  1871.   else if ((SysBase->AttnFlags & AFF_68020) != 0)
  1872.     cpu_type = 68020;
  1873.   else if ((SysBase->AttnFlags & AFF_68010) != 0)
  1874.     cpu_type = 68010;
  1875.   else
  1876.     cpu_type = 68000;
  1877.  
  1878.   /* timer stuff */
  1879.   if ((timermp = CreatePort (0, 0)) == NULL)
  1880.     die ("%s: Can't create messageport!", programname);
  1881.   if ((timerio = (struct timerequest *)CreateExtIO (timermp,
  1882.                  sizeof(struct timerequest))) == NULL)
  1883.     die ("%s: Can't create External IO!", programname);
  1884.   if (timerclosed = OpenDevice (TIMERNAME, UNIT_MICROHZ,
  1885.                                 (struct IORequest *)timerio, 0))
  1886.     die ("%s: Can't open timer.device!", programname);
  1887.   TimerBase = (struct Library *)timerio->tr_node.io_Device;
  1888.   if ((time = (struct EClockVal *)AllocMem (sizeof(struct EClockVal),
  1889.                                           MEMF_CLEAR | MEMF_PUBLIC)) == NULL ||
  1890.       (time0 = (struct EClockVal *)AllocMem (sizeof(struct EClockVal),
  1891.                                           MEMF_CLEAR | MEMF_PUBLIC)) == NULL ||
  1892.       (time1 = (struct EClockVal *)AllocMem (sizeof(struct EClockVal),
  1893.                                           MEMF_CLEAR | MEMF_PUBLIC)) == NULL)
  1894.     die ("%s: Out of memory", programname);
  1895.   micros_per_eclock = 1000000.0 / (double)ReadEClock (time);
  1896.  
  1897.   /* set default switches */
  1898.   opt.ram = TRUE;
  1899.   opt.mode = MODE_COLOUR;
  1900.   opt.once = FALSE;
  1901.   opt.rom = FALSE;
  1902.   opt.dbuf = FALSE;
  1903.   opt.warp = FALSE;
  1904.   opt.akiko = TRUE;
  1905.  
  1906.   /* try opening EGS libraries */
  1907.   if ((EGSBase = OpenLibrary ("egs.library", 0)) != NULL &&
  1908.       (EGSGfxBase = OpenLibrary ("egsgfx.library", 0)) != NULL &&
  1909.       (EGSBlitBase = OpenLibrary ("egsblit.library", 0)) != NULL &&
  1910.       (EGSIntuiBase = OpenLibrary ("egsintui.library", 0)) != NULL) {
  1911.     opt.mode = MODE_EGS;
  1912.   }
  1913.  
  1914.   /* parse workbench message or commandline */
  1915.   if (argc == 0) {
  1916.     argmsg = (struct WBStartup *)argv;
  1917.     wb_arg = argmsg->sm_ArgList;
  1918.     strcpy (programname, wb_arg->wa_Name);
  1919.     parse_tooltypes (wb_arg->wa_Name, &opt);
  1920.     if (argmsg->sm_NumArgs <= 1)
  1921.       filerequestloop (&opt);
  1922.     else {
  1923.       wb_arg++;
  1924.       for (ktr = 1; ktr < argmsg->sm_NumArgs; ktr++, wb_arg++)
  1925.         if (wb_arg->wa_Lock != NULL) {
  1926.           olddir = CurrentDir (wb_arg->wa_Lock);
  1927.           animate_file (wb_arg->wa_Name, opt);
  1928.           CurrentDir (olddir);
  1929.           olddir = NULL;
  1930.         } else
  1931.           animate_file (wb_arg->wa_Name, opt);
  1932.       }
  1933.   } else {
  1934.     if ((rdargs = ReadArgs
  1935.         ("FILE/M,DISK/S,RAM/S,ONCE/S,COLOUR/S,COLOR/S,EHB/S,COLOUR4/S,COLOR4/S,GREY/S,GRAY/S,EGS/S,ROM/S,DBUF/S,WARP/S,NOAKIKO/S",
  1936.                             argarray, NULL)) != NULL) {
  1937.       if (argarray[1])
  1938.         opt.ram = FALSE;
  1939.       if (argarray[2])
  1940.         opt.ram = TRUE;
  1941.       if (argarray[3])
  1942.         opt.once = TRUE;
  1943.       if (argarray[4] || argarray[5])
  1944.         opt.mode = MODE_COLOUR;
  1945.       if (argarray[6])
  1946.         opt.mode = MODE_EHB;
  1947.       if (argarray[7] || argarray[8])
  1948.         opt.mode = MODE_COLOUR4;
  1949.       if (argarray[9] || argarray[10])
  1950.         opt.mode = MODE_GREY;
  1951.       if (argarray[11])
  1952.         opt.mode = MODE_EGS;
  1953.       if (argarray[12])
  1954.         opt.rom = TRUE;
  1955.       if (argarray[13])
  1956.         opt.dbuf = TRUE;
  1957.       if (argarray[14])
  1958.         opt.warp = TRUE;
  1959.       if (argarray[15])
  1960.         opt.akiko = FALSE;
  1961.       fnames = (char **)argarray[0];
  1962.       if (fnames == NULL || *fnames == NULL)
  1963.         filerequestloop (&opt);
  1964.       else
  1965.         while (*fnames != NULL)
  1966.           animate_file (*fnames++, opt);
  1967.       FreeArgs (rdargs);
  1968.       rdargs = NULL;
  1969.     }
  1970.   }
  1971.  
  1972.   /* Let the user see how fast it went before the window closes */
  1973.   if (argc == 0)
  1974.     Delay (200);
  1975.  
  1976.   /* exit program with success code */
  1977.   return (0);
  1978.  
  1979.   /* SAS/C executes _STDcleanup() automatically on exit or break */
  1980.  
  1981. }
  1982.  
  1983. /****************************************************************************/
  1984.