home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / x / animutil / xflick.lha / xflick / xflick.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-10  |  17.1 KB  |  700 lines
  1. /*
  2.                xflick - Ron Schnell, March, 1991
  3.  
  4.            This code is provided as is, with no warrantees, expressed
  5.                or implied.  I believe this code to be free of encumbrance,
  6.            and offer it to the public domain.  I ask, however, that
  7.            this paragraph and my name be retained in any modified
  8.            versions of the file you may make, and that you notify me
  9.            of any improvements you make to the code.
  10.  
  11.            Ron Schnell (ronnie@sos.com)
  12.  
  13. */
  14.  
  15. /*
  16.     The following changes are from Michael Pall
  17.     (pall@rz.uni-karlsruhe.de) Mar 25-28 1991:
  18.  
  19.     Lots of bugfixes and changes to the structure of the files.
  20.     The file is interpreted before we display it.
  21.     Moved the interpretation part to read.c.
  22.     We use Pixmaps and/or XImages.
  23.     Added interactive input to change the speed/single step.
  24. */
  25.  
  26. /*
  27.     The following extensions are from Klaus Ehrenfried
  28.     (klaus@spock.es.go.dlr.de) Oct 23-24 1992:
  29.  
  30.     Add handling of FLI_DELTA and FLI_256_COLOR chunks.
  31.     Recognize magic number FLC_MAGIC = 0xaf12 for newer 
  32.     flic files.
  33. */
  34.  
  35. #include <stdio.h>
  36. #include <sys/types.h>
  37. #include <sys/signal.h>
  38. #include <sys/time.h>
  39. #include "xflick.h"
  40. #include <X11/Xos.h>
  41. #include <X11/Xlib.h>
  42. #include <X11/Xutil.h>
  43. #include <X11/Xatom.h>
  44.  
  45.  
  46. int verbose = 0;
  47.  
  48. static int timeout;        /* Necessary global for itimer waiting */
  49. static int usecs,rsecs;        /* ditto */
  50.  
  51. static Display *display;    /* The display connection */
  52. static int screen;        /* The default screen */
  53. static Window rootw, window;    /* Root window and our own window */
  54. static XImage *img;        /* The image for the current frame */
  55. static GC gc, blackgc;        /* Graphics contexts */
  56. static Colormap cmap;        /* The colormap for our window */
  57. static XEvent event;        /* Events for our window */
  58.  
  59. static flag_img = 0;        /* Use XImages instead of Pixmaps */
  60. static flag_noint = 0;        /* Don't interpret file first */
  61.  
  62. static int fdelay;        /* Frame delay */
  63. static int wwidth, wheight;    /* Width and height of the window */
  64.  
  65. /* The structure to hold the elements of the interpreted display list */
  66.  
  67. struct disp_list
  68. {
  69.     int disp_type;
  70.     int disp_frame;
  71.     Pixmap disp_pix;
  72.     XImage *disp_img;
  73.     XColor *disp_cols;
  74.     int disp_numcol;
  75.     int disp_width, disp_height;
  76.     int disp_destx, disp_desty;
  77.     struct disp_list *disp_next;
  78. };
  79.  
  80. static struct disp_list disp_root;    /* The start of the display list */
  81. static struct disp_list *disp_cur;    /* The current position */
  82.  
  83. extern void interpret_fli();
  84.  
  85. /* Function which gets called by the signal handler when SIGALRM
  86.    occurs */
  87.  
  88. static
  89. bong()
  90. {
  91.     timeout = True;
  92. }
  93.  
  94.  
  95. /* Convert the frame delay to microseconds/seconds */
  96.  
  97. static void
  98. convert_fdelay()
  99. {
  100.     usecs = (fdelay % 70) * 14285;
  101.     rsecs = fdelay / 70;
  102. }
  103.  
  104. /* Print an error message and exit */
  105.  
  106. void
  107. xferror(str)
  108. char *str;
  109. {
  110.     (void) fprintf(stderr, "%s\n", str);
  111.     exit(-1);
  112. }
  113.  
  114. /* Print a usage message and exit */
  115.  
  116. static void
  117. usage()
  118. {
  119.     (void) fprintf(stderr,
  120.     "Usage: xflick [-v] [-r<count>] [-d<delay>] [-i] [-n] file\n");
  121.     (void) fprintf(stderr, " -v Verbose Debugging info\n\
  122.  -r<count>  Repeat count times\n\
  123.  -d<delay>  Delay between frames in 1/70s\n\
  124.  -i         Use XImages instead of Pixmaps (slower but some servers need it)\n\
  125.  -n         Don't interpret file before display \
  126. (slower but uses less memory)\n");
  127.     exit(0);
  128. }
  129.  
  130. /* Check for pending KeyPress events and process them */
  131.  
  132. static void
  133. check_key()
  134. {
  135.     static int stepflag = 0;    /* Default: singlestep is off */
  136.  
  137.     char kbuf;            /* The buffer to hold the translation */
  138.     int onestep = stepflag;    /* 1 if we should loop waiting for a step */
  139.  
  140.     /* We poll the event Queue and block only in singlestep mode */
  141.  
  142.     while (onestep || QLength(display) > 0)
  143.     {
  144.     /* Get the event (blocks until event received) */
  145.  
  146.     XNextEvent(display, &event);
  147.  
  148.     /* Is it a KeyPress event and is it for our window (just in case)? */
  149.  
  150.     if (event.type == KeyPress && ((XKeyEvent *)&event)->window == window)
  151.     {
  152.         /* Translate the event to a string */
  153.         if (XLookupString((XKeyEvent *)&event, &kbuf, 1, NULL, NULL) != 1)
  154.         continue;
  155.  
  156.         /* Uppercase to lowercase mapping. We don't use ctype.h since
  157.            it's only used here  */
  158.  
  159.         if (kbuf>='A' && kbuf<='Z')
  160.         kbuf += 0x20;
  161.  
  162.         switch (kbuf)
  163.         {
  164.         /* Minus: Slow down */
  165.         case '-':
  166.         fdelay++;
  167.         convert_fdelay();
  168.         break;
  169.         /* Plus: Speed up */
  170.         case '+':
  171.         if (fdelay)
  172.             fdelay--;
  173.         convert_fdelay();
  174.         break;
  175.         /* Space: Single step */
  176.         case ' ':
  177.         stepflag = 1;
  178.         onestep = 0;
  179.         break;
  180.         /* Return: Continue animation */
  181.         case 0x0d:
  182.         stepflag = 0;
  183.         onestep = 0;
  184.         break;
  185.         /* 'q': Quit */
  186.         case 'q':
  187.         exit(0);
  188.         break;
  189.         }
  190.     }
  191.     }
  192. }
  193.  
  194.  
  195. /* Function to display the interpretation immediately */
  196.  
  197. static void
  198. func_disp(ftype, frame, buf, srcx, srcy, destx, desty, swidth, sheight)
  199. int ftype;
  200. int frame;
  201. unsigned char *buf;
  202. int srcx, srcy;
  203. int destx, desty;
  204. int swidth, sheight;
  205. {
  206.     static int colchange=0;        /* Colormap has changed */
  207.  
  208.     struct itimerval iclock;        /* For timeout setting */
  209.     XColor color;
  210.  
  211.     switch (ftype) {
  212.     case FLI_COPY:
  213.     case FLI_LC:
  214.     case FLI_DELTA:
  215.     case FLI_BRUN:
  216.     img->data = (char *)buf;
  217.     XPutImage(display, window, gc, img, srcx, srcy, destx, desty,
  218.           swidth, sheight);
  219.     break;
  220.     case FLI_BLACK:
  221.     XFillRectangle(display, window, blackgc, destx, desty,
  222.                swidth, sheight);
  223.     break;
  224.     case FLI_COLOR:
  225.     while(srcy--)
  226.     {
  227.         color.red = ((*(buf++) & 0x3f) << 2) << 8;
  228.         color.green = ((*(buf++) & 0x3f) << 2) << 8;
  229.         color.blue = ((*(buf++) & 0x3f) << 2) << 8;
  230.         color.pixel = srcx++;
  231.         color.flags = DoRed|DoGreen|DoBlue;
  232.         XStoreColor(display, cmap, &color);
  233.     }
  234.     colchange = 1;
  235.     break;
  236.     case FLI_256_COLOR:
  237.     while(srcy--)
  238.     {
  239.         color.red = ((*(buf++) & 0xff)) << 8;
  240.         color.green = ((*(buf++) & 0xff)) << 8;
  241.         color.blue = ((*(buf++) & 0xff)) << 8;
  242.         color.pixel = srcx++;
  243.         color.flags = DoRed|DoGreen|DoBlue;
  244.         XStoreColor(display, cmap, &color);
  245.     }
  246.     colchange = 1;
  247.     break;
  248.     case FLI_SYNC:
  249.     if (colchange)
  250.     {
  251.         XSetWindowColormap(display, window, cmap);
  252.         colchange = 0;
  253.     }
  254.     XSync(display, 0);
  255.  
  256.     check_key();
  257.  
  258.     /* Do we have a delay between the frames? */
  259.     if (usecs || rsecs)
  260.     {
  261.         timeout = False;
  262.         signal(SIGALRM, bong);
  263.         iclock.it_value.tv_sec = rsecs;
  264.         iclock.it_value.tv_usec = usecs;
  265.         iclock.it_interval.tv_sec = rsecs;
  266.         iclock.it_interval.tv_usec = usecs;
  267.         (void) setitimer(0, &iclock, 0);
  268.         
  269.         if (!timeout)
  270.         (void) pause();
  271.         
  272.         iclock.it_value.tv_sec = 0;
  273.         iclock.it_value.tv_usec = 0;
  274.         iclock.it_interval.tv_sec = 0;
  275.         iclock.it_interval.tv_usec = 0;
  276.         (void) setitimer(0, &iclock, 0);
  277.     }
  278.     break;
  279.     }
  280.  
  281. }
  282.  
  283. /* Store the interpretation */
  284.  
  285. static void
  286. func_interp(ftype, frame, buf, srcx, srcy, destx, desty, swidth, sheight)
  287. int ftype;        /* The type of this chunk */
  288. int frame;        /* The number of this frame */
  289. unsigned char *buf;    /* A pointer to the pixel/colormap data */
  290. int srcx, srcy;        /* The upper left corner in the data array */
  291. int destx, desty;    /* The upper left corner in the window */
  292. int swidth, sheight;    /* The dimensions of the rectangle */
  293. {
  294.     XColor *coltmp;    /* Temporary storage for pointer to XColor struct */
  295.     Pixmap pixtmp;    /* Temporary storage for the Pixmap id */
  296.  
  297.     /* Allocate another element in the display list */
  298.     disp_cur->disp_next = (struct disp_list *)malloc(sizeof(struct disp_list));
  299.     disp_cur = disp_cur->disp_next;
  300.  
  301.     /* Clear the pointer to the next element so we find the end of the list */
  302.     disp_cur->disp_next = (struct disp_list *)0;
  303.  
  304.     /* Copy info pertaining to all or most of the chunks */
  305.     disp_cur->disp_type = ftype;
  306.     disp_cur->disp_frame = frame;
  307.     disp_cur->disp_width = swidth;
  308.     disp_cur->disp_height = sheight;
  309.     disp_cur->disp_destx = destx;
  310.     disp_cur->disp_desty = desty;
  311.  
  312.     switch (ftype) {
  313.     case FLI_COPY:
  314.     case FLI_LC:
  315.     case FLI_DELTA:
  316.     case FLI_BRUN:
  317.     img->data = (char *)buf;
  318.  
  319.     /* There's no reason to store the first frame in a Pixmap since it
  320.        will be used only once. Also use XImages if we've been told so */
  321.     if (frame==0 || flag_img)
  322.     {
  323.         disp_cur->disp_pix = (Pixmap)0;    /* No Pixmap */
  324.         disp_cur->disp_img = XSubImage(img, srcx, srcy, swidth, sheight);
  325.     }
  326.     else
  327.     /* Otherwise we create a Pixmap and copy the changed rectangle to it */
  328.     {
  329.         pixtmp = XCreatePixmap(display, rootw, swidth, sheight, 8);
  330.         if (!pixtmp)
  331.         xferror("Cannot create Pixmap. Try command line switch -i.");
  332.  
  333.         XPutImage(display, pixtmp, gc, img, srcx, srcy, 0, 0,
  334.               swidth, sheight);
  335.         disp_cur->disp_pix = pixtmp;
  336.     }
  337.     break;
  338.     case FLI_COLOR:
  339.     /* Create an array of XColor to hold the colors. Specific to FLI_COLOR:
  340.        srcx is the starting color index and srcy is the number of colors */
  341.     coltmp =  (XColor *)malloc(srcy * sizeof(XColor));
  342.     disp_cur->disp_cols = coltmp;
  343.     disp_cur->disp_numcol = srcy;
  344.  
  345.     /* Copy the changed colors to the XColor array */
  346.     while(srcy--)
  347.     {
  348.         coltmp->red = ((*(buf++) & 0x3f) << 2) << 8;
  349.         coltmp->green = ((*(buf++) & 0x3f) << 2) << 8;
  350.         coltmp->blue = ((*(buf++) & 0x3f) << 2) << 8;
  351.         coltmp->pixel = srcx++;
  352.         coltmp->flags = DoRed|DoGreen|DoBlue;
  353.         coltmp++;
  354.     }
  355.     break;
  356.     case FLI_256_COLOR:
  357.     /* Create an array of XColor to hold the colors. Specific to FLI_COLOR:
  358.        srcx is the starting color index and srcy is the number of colors */
  359.     coltmp =  (XColor *)malloc(srcy * sizeof(XColor));
  360.     disp_cur->disp_cols = coltmp;
  361.     disp_cur->disp_numcol = srcy;
  362.  
  363.     /* Copy the changed colors to the XColor array */
  364.     while(srcy--)
  365.     {
  366.         coltmp->red = ((*(buf++) & 0xff)) << 8;
  367.         coltmp->green = ((*(buf++) & 0xff)) << 8;
  368.         coltmp->blue = ((*(buf++) & 0xff)) << 8;
  369.         coltmp->pixel = srcx++;
  370.         coltmp->flags = DoRed|DoGreen|DoBlue;
  371.         coltmp++;
  372.     }
  373.     break;
  374.  
  375.     /* FLI_BLACK and FLI_SYNC only need to be stored */
  376.     case FLI_BLACK:
  377.     case FLI_SYNC:
  378.     break;
  379.     }
  380.  
  381. }
  382.  
  383. /* Display the stored interpretation */
  384.  
  385. static void
  386. display_interp(dc)
  387. struct disp_list *dc;    /* The structure holding the info on the chunk */
  388. {
  389.     static int colchange=0;    /* Colormap has changed */
  390.  
  391.     struct itimerval iclock;    /* For timeout setting */
  392.     int swidth, sheight;    /* Dimension of the changing rectangle */
  393.     int destx, desty;        /* Upper left corner of the rectangle */
  394.  
  395.     /* Copy some fields from the structure */
  396.     swidth = dc->disp_width;
  397.     sheight = dc->disp_height;
  398.     destx = dc->disp_destx;
  399.     desty = dc->disp_desty;
  400.  
  401.     switch (dc->disp_type) {
  402.     case FLI_COPY:
  403.     case FLI_LC:
  404.     case FLI_DELTA:
  405.     case FLI_BRUN:
  406.     /* A Pixmap needs to be copied internally by the server */
  407.     if (dc->disp_pix)
  408.     {
  409.         XCopyArea(display, dc->disp_pix, window, gc, 0, 0,
  410.               swidth, sheight, destx, desty);
  411.     }
  412.     else
  413.     /* XImages need to be transferred from the client */
  414.     {
  415.         XPutImage(display, window, gc, dc->disp_img, 0, 0, destx, desty,
  416.               swidth, sheight);
  417.     }
  418.     break;
  419.     case FLI_BLACK:
  420.     /* Clear the whole rectangle */
  421.     XFillRectangle(display, window, blackgc, destx, desty,
  422.                swidth, sheight);
  423.     break;
  424.     case FLI_COLOR:
  425.     case FLI_256_COLOR:
  426.     /* Store the changed colors in the colormap and note that */
  427.     XStoreColors(display, cmap, dc->disp_cols, dc->disp_numcol);
  428.     colchange = 1;
  429.     break;
  430.     case FLI_SYNC:
  431.     /* If the colors have changed we set the colormap for the window */
  432.     if (colchange)
  433.     {
  434.         XSetWindowColormap(display, window, cmap);
  435.         colchange = 0;
  436.     }
  437.     /* Keep things in sync */
  438.     XSync(display, False);
  439.  
  440.     check_key();
  441.  
  442.     /* Do we have a delay between the frames? */
  443.     if (usecs || rsecs)
  444.     {
  445.         timeout = False;
  446.         signal(SIGALRM, bong);
  447.         iclock.it_value.tv_sec = rsecs;
  448.         iclock.it_value.tv_usec = usecs;
  449.         iclock.it_interval.tv_sec = rsecs;
  450.         iclock.it_interval.tv_usec = usecs;
  451.         (void) setitimer(0, &iclock, 0);
  452.         
  453.         if (!timeout)
  454.         (void) pause();
  455.         
  456.         iclock.it_value.tv_sec = 0;
  457.         iclock.it_value.tv_usec = 0;
  458.         iclock.it_interval.tv_sec = 0;
  459.         iclock.it_interval.tv_usec = 0;
  460.         (void) setitimer(0, &iclock, 0);
  461.     }
  462.     break;
  463.     }
  464. }
  465.  
  466.  
  467. /* Draw a given string to the center of the window */
  468.  
  469. static void
  470. text_center(str)
  471. char *str;
  472. {
  473.     XFontStruct *fixedfont;
  474.     GC fontgc;
  475.     int w;
  476.  
  477.     /* Load the fixed width font */
  478.  
  479.     fixedfont = XLoadQueryFont(display, "fixed");
  480.     if (fixedfont)
  481.     {
  482.     /* Create a GC to draw the font */
  483.  
  484.     fontgc = XCreateGC(display, rootw, 0, NULL);
  485.     XCopyGC(display, gc, -1, fontgc);
  486.     XSetBackground(display, fontgc, BlackPixel(display, screen));
  487.     XSetForeground(display, fontgc, WhitePixel(display, screen));
  488.     XSetFont(display, fontgc, fixedfont->fid);
  489.  
  490.     /* Determine the width of the string */
  491.  
  492.     w = XTextWidth(fixedfont, str, strlen(str));
  493.     if (w > wwidth)
  494.         w = wwidth;
  495.  
  496.     /* And draw the string */
  497.  
  498.     XDrawImageString(display, window, fontgc, (wwidth-w)/2,
  499.              wheight/2, str, strlen(str));
  500.  
  501.     /* Free everything and show the text */
  502.  
  503.     XFreeGC(display, fontgc);
  504.     XFreeFont(display, fixedfont);
  505.     XFlush(display);
  506.     }
  507. }
  508.  
  509.  
  510. main(argc, argv)
  511. char **argv;
  512. {
  513.     int fd;            /* For the main file descriptor */
  514.     struct fli_header header;    /* To hold the main header */
  515.     unsigned char *data;    /* Always has the current image data */
  516.     int repeatcount;        /* How many times to loop */
  517.     unsigned char notfirst;    /* Is this not the first time through? */
  518.     char *fname;        /* Pointer to filename */
  519.  
  520.     /* X stuff begins here */
  521.  
  522.     XSizeHints hints;        /* Hints for window mapping */
  523.     Visual *visual;
  524.     int xloc, yloc;
  525.  
  526.  
  527.     fdelay = -1;
  528.     repeatcount = 10;
  529.  
  530.     while (--argc && argv[1][0] == '-')
  531.     {
  532.     argv++;
  533.     switch (argv[0][1]) {
  534.     case 'r':
  535.         repeatcount = atol(&(argv[0][2]));
  536.         break;
  537.     case 'd':
  538.         fdelay = atol(&(argv[0][2]));
  539.         break;
  540.     case 'n':
  541.         flag_noint = 1;
  542.         break;
  543.     case 'i':
  544.         flag_img = 1;
  545.         break;
  546.       case 'v':
  547.         verbose = 1;
  548.         break;
  549.     default:
  550.         usage();
  551.     }
  552.  
  553.     }
  554.  
  555.     if (argc != 1)
  556.     usage();
  557.  
  558.     fname = argv[1];
  559.     fd = open(fname, 0);
  560.     if (fd < 0)
  561.     {
  562.     (void) fprintf(stderr, "Error opening %s.\n", fname);
  563.     perror("xflick");
  564.     exit(1);
  565.     }
  566.  
  567.     /* Read the main FLI header */
  568.  
  569.     read_flihead(fd, &header);
  570.  
  571.     if (((header.fhd_magic & 0x0000ffff) != FLI_MAGIC) &&
  572.     ((header.fhd_magic & 0x0000ffff) != FLC_MAGIC))
  573.     {
  574.     (void) fprintf(stderr, "%s, not a .fli file.\n", fname);
  575.     exit(0);
  576.     }
  577.  
  578.     /* Get the width and height */
  579.  
  580.     wwidth = header.fhd_width;
  581.     wheight = header.fhd_height;
  582.     data = (unsigned char *)malloc(wwidth * wheight);
  583.  
  584.     /* The speed is stored in 1/70 seconds, convert to usecs */
  585.  
  586.     if (fdelay<0)
  587.     fdelay = header.fhd_speed;
  588.     convert_fdelay();
  589.  
  590.     display = XOpenDisplay(NULL);
  591.     if (display == NULL)
  592.     xferror("Cannot open display.");
  593.  
  594.     /* Create a wwidth x wheight window to show the flick */
  595.  
  596.     screen = DefaultScreen(display);
  597.     visual = DefaultVisual(display, screen);
  598.     rootw = RootWindow(display, screen);
  599.  
  600.     if (DisplayCells(display, screen) < 256)
  601.     xferror("You do not have enough colors to run xflick.");
  602.  
  603.     xloc = (DisplayWidth(display, screen) - wwidth) / 2;
  604.     yloc = (DisplayHeight(display, screen) - wheight) / 2;
  605.  
  606.     window = XCreateSimpleWindow(display, rootw, xloc, yloc, wwidth, wheight,
  607.         CopyFromParent, CopyFromParent, BlackPixel(display, screen));
  608.  
  609.     /* Set size hints to disable resizing */
  610.  
  611.     hints.flags = (PSize | PMinSize | PMaxSize);
  612.     hints.min_width = hints.max_width = hints.width = wwidth;
  613.     hints.min_height = hints.max_height = hints.height = wheight;
  614.  
  615.     /* Set window and icon name, size hints and other properties */
  616.  
  617.     XSetStandardProperties(display, window, fname, fname, None,
  618.                argv, argc, &hints);
  619.  
  620.     gc = DefaultGC(display, screen);
  621.  
  622.     /* Create a GC with a foreground pixel value of 0 for FLI_BLACK */
  623.  
  624.     blackgc = XCreateGC(display, rootw, 0, NULL);
  625.     XCopyGC(display, gc, -1, blackgc);
  626.     XSetForeground(display, blackgc, 0);
  627.  
  628.     /* Create a colormap and allocate all colors */
  629.  
  630.     cmap = XCreateColormap(display, rootw, visual, AllocAll);
  631.  
  632.     /* Catch Exposure events and KeyPress events */
  633.  
  634.     XSelectInput(display, window, ExposureMask | KeyPressMask);
  635.  
  636.     /* Now map our little window */
  637.     XMapWindow(display, window);
  638.  
  639.     /* We wait for an exposure event, since any output to the window is
  640.        lost if the window is not yet visible */
  641.  
  642.     do
  643.     XNextEvent(display, &event);
  644.     while (event.type != Expose);
  645.  
  646.     /* Now we are no longer interested in Exposure events */
  647.  
  648.     XSelectInput(display, window, KeyPressMask);
  649.  
  650.     /* Create the XImage to hold the current frame */
  651.     img = XCreateImage(display, visual, 8, ZPixmap, 0,
  652.                data, wwidth, wheight, 8, wwidth);
  653.  
  654.  
  655.     notfirst = 0;
  656.  
  657.     /* Either interpret the file while displaying it */
  658.  
  659.     if (flag_noint)
  660.     {
  661.     while (repeatcount--) {
  662.         interpret_fli(fd, &header, data, notfirst, func_disp);
  663.         notfirst = 1;
  664.     }
  665.     }
  666.  
  667.     /* Or interpret everything first and display it afterwards */
  668.  
  669.     else
  670.  
  671.     {
  672.     text_center("Please wait while loading the animation");
  673.  
  674.     /* Interpret it and store the results */
  675.  
  676.     disp_cur = &disp_root;
  677.     interpret_fli(fd, &header, data, 0, func_interp);
  678.  
  679.     /* Now display the results */
  680.  
  681.     while (repeatcount--)
  682.     {
  683.         disp_cur = &disp_root;
  684.         while (disp_cur->disp_next)
  685.         {
  686.         disp_cur = disp_cur->disp_next;
  687.  
  688.         /* Only display the first frame once */
  689.  
  690.         if (disp_cur->disp_frame || !notfirst)
  691.             display_interp(disp_cur);
  692.         }
  693.         notfirst = 1;
  694.     }
  695.     }
  696.  
  697.     return 0;
  698. }
  699.  
  700.