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"
 
 
@@ skipping 370 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 = 15;  /* 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 microseconds between two timevals.  Return 0 if
+ * the clock is not reliable.  Don't worry about overflows.
+ */
+int difference_nsec(struct timespec x, struct timespec y)

[Daniel Erat, 2010/12/14 02:18:05]

why not return int64_t (and add some casts in the expression) so that overflows
won't happen?

+{
+  if (bad_clock)
+    {
+      return 0;
+    }
+
+  return (x.tv_sec - y.tv_sec) * (1000 * 1000 * 1000) + x.tv_nsec - y.tv_nsec;
+}
+
+
+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>]");
+  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;
 
-      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 ();
+            }
+
+          gettime_check (&then);
+          for (i = 4; i < argc; i++)
+            {
+              struct timespec req;
+              int elapsed_nsec;
+              gettime_check (&now);
+              elapsed_nsec = difference_nsec (now, then);
+              req.tv_sec = 0;
+              req.tv_nsec = (1000 * 1000 * 1000) / frame_rate - elapsed_nsec;

[Daniel Erat, 2010/12/14 02:18:05]

could you pull a variable like:

  int64_t nsec_between_frames;
  ...
  nsec_between_frames = (1000 * 1000 * 1000) / frame_rate;

outside of the loop, and then do:

  int64_t nsec_to_sleep = nsec_between_frames - difference_nsec (now, then);
  if (nsec_to_sleep > 0) {
    struct timespec req;
    req.tv_sec = nsec_to_sleep / (1000 * 1000 * 1000);
    req.tv_nsec = nsec_to_sleep % (1000 * 1000 * 1000);
    nanosleep (&req, NULL);
  }

here?  i think it's a bit easier to read and is more correct if we get changed
to a less-than-one-frame-per-second framerate for some reason.

+              if (req.tv_nsec > 0)
+                {
+                  nanosleep (&req, NULL);
+                }
+              gettime_check (&then);

[Daniel Erat, 2010/12/14 02:18:05]

it'd be cleaner/more accurate to copy 'now' into 'then' instead of fetching a
new timestamp here; you can accumulate extra time between the two
gettime_check() calls otherwise

+              ply_frame_buffer_show_file_at_xy (buffer, argv[i], xoff, yoff);
+            }
+        }
     }
 
-  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;
 }