media file: get duration of animated GIFs, PNGs, and ugoiras.

Add methods to MediaFile to calculate the duration, frame count, and
frame rate of animated GIFs, PNGs, Ugoiras, and videos.

Some considerations:

* It's possible to have a GIF or PNG that's technically animated but
  just has one frame. These are treated as non-animated images.

* It's possible to have an animated GIF that has an unspecified
  frame rate. In this case we assume the frame rate is 10 FPS; this is
  browser dependent and may not be correct.

* Animated GIFs, PNGs, and Ugoiras all support variable frame rates.
  Technically, each frame has a separate delay, and the delays can be
  different frame-to-frame. We report only the average frame rate.

* Getting the duration of an APNG is surprisingly hard. Most tools don't
  have good support for APNGs since it's a rare and non-standardized
  format. The best we can do is get the frame count using ExifTool and the
  frame rate using ffprobe, then calculate the duration from that.

app/logical/media_file/image.rb

@@ -23,8 +23,49 @@ class MediaFile::Image < MediaFile
     true
   end
 
-  def is_animated?
-    is_animated_gif? || is_animated_png?
+  def duration
+    if is_animated_gif?
+      if metadata.has_key?("GIF:Duration")
+        # GIF:Duration => "9.03 s"
+        metadata["GIF:Duration"].to_f
+      else
+        # If GIF:Duration is absent then it means the GIF has an unlimited
+        # framerate. In this situation we assume the browser will play the GIF
+        # at 10 FPS; this is browser dependent.
+        #
+        # A GIF consists of a series of frames, each frame having a separate frame
+        # delay. The duration of the GIF is the sum of each frame delay. If the frame
+        # delay of each frame is zero, then it means the GIF has an unlimited framerate
+        # and should be played as fast as possible. In reality, browsers cap the
+        # framerate to around 10FPS.
+        (frame_count * (1.0/10.0)).round(2)
+      end
+    elsif is_animated_png?
+      frame_count.to_f / frame_rate
+    else
+      nil
+    end
+  end
+
+  def frame_count
+    if file_ext == :gif
+      image.get("n-pages")
+    elsif file_ext == :png
+      metadata.fetch("PNG:AnimationFrames", 1)
+    else
+      nil
+    end
+  end
+
+  def frame_rate
+    if is_animated_gif?
+      frame_count / duration
+    elsif is_animated_png?
+      # XXX we have to resort to ffprobe to get the frame rate because libvips and exiftool can't get it.
+      video.frame_rate
+    else
+      nil
+    end
   end
 
   def channels
@@ -62,11 +103,11 @@ class MediaFile::Image < MediaFile
   end
 
   def is_animated_gif?
-    file_ext == :gif && image.get("n-pages") > 1
+    file_ext == :gif && is_animated?
   end
 
   def is_animated_png?
-    file_ext == :png && metadata.fetch("PNG:AnimationFrames", 1) > 1
+    file_ext == :png && is_animated?
   end
 
   # @return [Vips::Image] the Vips image object for the file
@@ -74,5 +115,9 @@ class MediaFile::Image < MediaFile
     Vips::Image.new_from_file(file.path, fail: true).autorot
   end
 
-  memoize :image, :dimensions, :is_corrupt?, :is_animated_gif?, :is_animated_png?
+  def video
+    FFmpeg.new(file)
+  end
+
+  memoize :image, :video, :dimensions, :is_corrupt?, :is_animated_gif?, :is_animated_png?
 end

app/logical/media_file/ugoira.rb

@@ -32,6 +32,22 @@ class MediaFile::Ugoira < MediaFile
     preview_frame.crop(width, height)
   end
 
+  def duration
+    (frame_delays.sum / 1000.0)
+  end
+
+  def frame_count
+    frame_data.count
+  end
+
+  def frame_rate
+    frame_count / duration
+  end
+
+  def frame_delays
+    frame_data.map { |frame| frame["delay"] }
+  end
+
   # Convert a ugoira to a webm.
   # XXX should take width and height and resize image
   def convert

app/logical/media_file/video.rb

@@ -3,7 +3,7 @@
 #
 # @see https://github.com/streamio/streamio-ffmpeg
 class MediaFile::Video < MediaFile
-  delegate :duration, :has_audio?, to: :video
+  delegate :duration, :frame_count, :frame_rate, :has_audio?, to: :video
 
   def dimensions
     [video.width, video.height]