Hi,

GIFs don't necessarily have a constant framerate. As far is i know every frame can have its own delay, until the next frame is displayed. Unfortunately the gifAnimation-library seems to have no public fields or methods to access these delays.
But looking into the source-code helps to create your own function to extract them.
For example with this code:

1. import gifAnimation.*;
   
   void setup() {
     println(getDelays("some.gif"));
   }
   
   int[] getDelays(String filename){
     GifDecoder gifDecoder = new GifDecoder();
     gifDecoder.read(openStream(filename));
     int n = gifDecoder.getFrameCount();
     int[] delays = new int[n];
     for (int i = 0; i < n; i++) {
       delays[i] = gifDecoder.getDelay(i);
     }
     return delays;
   }
   

To calculate an average framerate you would just have to divide the number of frames by the sum of all values from that array.

Hi Benja,

Hi,

my code doesn't print the number of frames, it prints the delay for every frame. (As set in the original gif-file)
When the delay for the different frames are not equal, setting an average framerate is a bad solution.
You could use the delays from the file to set the display-time for every single frame when you draw them in your sketch.

Example:

1. import gifAnimation.*;
   PImage[] animation;
   int[] delays;
   int currentFrame, frameStart;
   String filename = "lavalamp.gif";
   
   void setup() {
     // load the frames into an array
     animation = Gif.getPImages(this, filename);
     // get the delays for the frames
     delays = getDelays(filename);
   }
   
   void draw(){
     background(0);
     // if a frame has been displayed for its specified delay-time, go to the next frame
     if(millis()-frameStart > delays[currentFrame]){
       currentFrame = (++currentFrame)%animation.length;
       frameStart = millis();
     }
     image(animation[currentFrame],0,0);
   }
   
   // extract the delay-times from a gif file
   int[] getDelays(String filename){
     GifDecoder gifDecoder = new GifDecoder();
     gifDecoder.read(openStream(filename));
     int n = gifDecoder.getFrameCount();
     int[] delays = new int[n];
     for (int i = 0; i < n; i++) {
       delays[i] = gifDecoder.getDelay(i);
     }
     return delays;
   }
   

Hi Benja!

Hey,

looked at your code and i see two things, you should change:

1. You check the delays of the first gif-animation, which you pick in setup(), but whenever you load a new gif, you have to extract its own delay-times.

2. You check for the number of frames passed when deciding if you pick a new random image/animation. It's more reliable, if you check for the time passed instead.

Here is another example on displaying random gif-animations, you would have to change it, when you want jpgs too.

1. import gifAnimation.*;
   
   PImage[] animation;
   float Gifanime;
   int GifFragNumber;
   int xGif = 2;
   int[] delays;
   int currentFrame, frameStart, displayStart, displayTime;
   
   void setup() {
     size(500, 500);
     imageMode(CENTER);
   }
   
   
   void draw() {
     background (255);
   
     // this part chooses a new gif-file and calculates how long it shall be shown
    
     if (displayTime <= millis() - displayStart) {
       // pick an new gif-file
       float Gifanime = random (0, xGif);
       int GifFragNumberPlus= ceil(Gifanime);
   
       // number of repetitions
       float r = random (2, 5);
       int gifrepeats = int(r);         
   
       // load gif-animation and delay-times
       animation = Gif.getPImages (this, "Gif_" + GifFragNumberPlus + ".gif");
       delays = getDelays("Gif_" + GifFragNumberPlus + ".gif");
      
       println("Gif_" + GifFragNumberPlus + ".gif, repeat: "+gifrepeats);
      
       // calculate length of the whole animation
       int gifTime = 0;
       for (int i = 0; i< animation.length; i++) {
         gifTime += delays[i];
       }
      
       displayTime = gifrepeats*gifTime;
       displayStart = millis();
       currentFrame = 0;
     }
   
     // show the gif-animation
     if (millis()-frameStart > delays[currentFrame]) {
       currentFrame = (++currentFrame)%animation.length;
       frameStart = millis();
     }
     image(animation[currentFrame], width/2, height/2);
   }
   
   
   
   // get delay-times of a gif-animation
   int[] getDelays(String gifname) {
     GifDecoder gifDecoder = new GifDecoder();
     gifDecoder.read(openStream(gifname));
     int n = gifDecoder.getFrameCount();
     int[] delays = new int[n];
     for (int i = 0; i < n; i++) {
       delays[i] = gifDecoder.getDelay(i);
     }
     return delays;
   }
   

It works perfectly!!