Add frame-by-frame animation.

src/ply-image.c

 /* ply-image.c - png file loader
  *
  * Copyright (C) 2006, 2007 Red Hat, Inc.
  * Copyright (C) 2003 University of Southern California
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2, or (at your option)
  * any later version.
  *
@@ skipping 24 matching lines @@
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <time.h>
 #include <unistd.h>
 #include <math.h>
 
 #include <png.h>
 
 #include <linux/fb.h>
 
 #include "ply-utils.h"
 
+#define BILLION (1000 * 1000 * 1000)
+
 
 typedef union
 {
  uint32_t *as_pixels;
  png_byte *as_png_bytes;
  char *address;
 } ply_image_layout_t;
 
 struct _ply_image
 {
@@ skipping 361 matching lines @@
           theta -= theta_offset;
           old_x = center_x + d * cos (theta);
           old_y = center_y + d * sin (theta);
           new_image->layout.as_pixels[x + y * width] =
                     ply_image_interpolate (image, width, height, old_x, old_y);
         }
     }
   return new_image;
 }
 
+ply_image_t *
+ply_image_from_file(const char *path)
+{
+  int exit_code;
+  ply_image_t *image = ply_image_new (path);
+
+  if (!ply_image_load (image))
+    {
+      exit_code = errno;
+      perror (path);
+      exit (exit_code);
+    }
+  return image;
+}
+
 #include "ply-frame-buffer.h"
 
 #include <math.h>
 #include <signal.h>
 #include <stdio.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <values.h>
 
 #include <linux/kd.h>
 
+const int frame_rate = 20;  /* Animation frames per second */
+int bad_clock = 0;          /* Set to 1 if the clock ever returns an error */
+
+void
+ply_frame_buffer_show_file_at_xy(ply_frame_buffer_t *buffer, const char *path,
+                                 long x, long y)
+{
+  ply_image_t *image;
+  uint32_t *data;
+  long width, height;
+  ply_frame_buffer_area_t area;
+
+  image = ply_image_from_file (path);
+
+  data = ply_image_get_data (image);
+  width = ply_image_get_width (image);
+  height = ply_image_get_height (image);
+
+  ply_frame_buffer_get_size (buffer, &area);
+  area.x = (area.width / 2) - (width / 2);  // + x;
+  area.y = (area.height / 2) - (height / 2);  // + y;
+  area.width = width;
+  area.height = height;
+
+  ply_frame_buffer_fill (buffer, &area, x, y, data);
+  ply_image_free (image);
+}
+
+/*
+ * Compute the difference in nanoseconds between two timevals.  Return 0 if the
+ * clock is not reliable.
+ */
+int64_t difference_nsec(struct timespec x, struct timespec y)
+{
+  int64_t z;
+
+  if (bad_clock)
+    {
+      return 0;
+    }
+
+  z = x.tv_sec - y.tv_sec;
+  z *= BILLION;
+  z += x.tv_nsec - y.tv_nsec;
+  return z;
+}
+
+
+void gettime_check(struct timespec *ts)
+{
+  int r = clock_gettime(CLOCK_MONOTONIC, ts);
+  if (r)
+    {
+      bad_clock = 1;
+    }
+}
+
+
+int usage(void)
+{
+  fprintf(stderr,
+          "usage: ply-image --clear\n"
+          "       ply-image <background> [<x-offset> <y-offset> "
+          "<frame-1> ... <frame-n>]\n");
+  exit(1);
+}
+
 
 int
 main (int    argc,
       char **argv)
 {
-  ply_image_t *image = NULL;
+  int exit_code = 0;
+  int clear = 0;
+  int help = 0;
   ply_frame_buffer_t *buffer;
-  int exit_code;
-  ply_frame_buffer_area_t area;
-  uint32_t *data;
-  long width, height;
-
-  exit_code = 0;
+  int i;
+  int xoff, yoff;
+  char *endptr;
 
   // hide_cursor ();
 
-  if (argc != 2 || strcasecmp(argv[1], "-h") == 0 || strcasecmp(argv[1], "--help") == 0)
+  /*
+   * Ad-hoc arg parsing, to keep the program small.
+   */
+
+  if (argc > 1)
     {
-      perror ("usage: ply-image [--clear | <pngImageFile>]");
-      return 1;
+      clear = strcasecmp (argv[1], "--clear") == 0;
+      help = strcasecmp (argv[1], "--help") == 0 ||
+        strcasecmp (argv[1], "-h") == 0;
     }
 
-  if (strcasecmp(argv[1], "--clear") != 0)
+  if (help || argc == 1 || argc == 3 || argc == 4)
     {
-      image = ply_image_new (argv[1]);
-
-      if (!ply_image_load (image))
-        {
-          exit_code = errno;
-          perror ("could not load image");
-          return exit_code;
-        }
+      usage();
     }
 
   buffer = ply_frame_buffer_new (NULL);
 
   if (!ply_frame_buffer_open (buffer))
     {
       exit_code = errno;
       perror ("could not open framebuffer");
       return exit_code;
     }
 
-  if (image == NULL)
+  if (clear)
     {
       ply_frame_buffer_clear (buffer);
     }
   else
     {
-      data = ply_image_get_data (image);
-      width = ply_image_get_width (image);
-      height = ply_image_get_height (image);
+      /*
+       * Display main image.
+       */
+      ply_frame_buffer_show_file_at_xy (buffer, argv[1], 0, 0);
 
-      ply_frame_buffer_get_size (buffer, &area);
-      area.x = (area.width / 2) - (width / 2);
-      area.y = (area.height / 2) - (height / 2);
-      area.width = width;
-      area.height = height;
+      if (argc >= 4)
+        {
+          /*
+           * Animate frames.
+           */
+          struct timespec then, now;
+          int64_t error_nsec;
+          int64_t interval_nsec;
 
-      ply_frame_buffer_fill (buffer, &area, 0, 0, data);
-      ply_image_free (image);
+          xoff = strtol (argv[2], &endptr, 10);
+          if (endptr == argv[2] || *endptr != '\0')
+            {
+              usage ();
+            }
+          yoff = strtol (argv[3], &endptr, 10);
+          if (endptr == argv[3] || *endptr != '\0')
+            {
+              usage ();
+            }
+
+          /*
+           * Begin animation.
+           *
+           * The first time around, we don't know how long it takes to draw a
+           * frame, so we assume it's instantaneous.  After that, we assume
+           * that the drawing time for the previous cycle is a good estimate
+           * for the next cycle.  Errors may be introduced by different frame
+           * size and complexity (PNG decoding).
+           */
+          error_nsec = 0;
+          interval_nsec = BILLION / frame_rate;
+          gettime_check (&now);
+
+          for (i = 4; i < argc; i++)
+            {
+              /*
+               * Before displaying the next frame, sleep for the inter-frame
+               * interval, adjusted by the error in the previous cycle.
+               * Positive error means the last cycle took longer than desired.
+               */
+              if (interval_nsec - error_nsec > 0)
+                {
+                  struct timespec req;
+                  req.tv_sec = (interval_nsec - error_nsec) / BILLION;
+                  req.tv_nsec = (interval_nsec - error_nsec) % BILLION;
+                  nanosleep (&req, NULL);
+                }
+              ply_frame_buffer_show_file_at_xy (buffer, argv[i], xoff, yoff);
+              then = now;
+              gettime_check (&now);
+              error_nsec = difference_nsec (now, then) - interval_nsec;
+            }
+        }
     }
 
-  ply_frame_buffer_close (buffer);
-  ply_frame_buffer_free (buffer);
+  // Skip these to save time.
+  // ply_frame_buffer_close (buffer);
+  // ply_frame_buffer_free (buffer);
 
   return exit_code;
 }