How do I convert a video to GIF using ffmpeg, with reasonable quality?

Question

I'm converting a video to GIF file with ffmpeg:

ffmpeg \
  -i input.flv \
  -ss 00:00:00.000 \
  -pix_fmt rgb24 \
  -r 10 \
  -s 320x240 \
  -t 00:00:10.000 \
  output.gif

It works great, but output gif file has a very low quality.

Any ideas how can I improve quality of converted gif?

Answer 1

ffmpeg example

_183k

ffmpeg can output high quality GIF. Before you start it is always recommended to use a recent version: download or compile.

ffmpeg -ss 30 -t 3 -i input.mp4 \
    -vf "fps=10,scale=320:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
    -loop 0 output.gif

• This example will skip the first 30 seconds (-ss 30) of the input and create a 3 second output (-t 3).
• fps filter sets the frame rate. A rate of 10 frames per second is used in the example.
• scale filter will resize the output to 320 pixels wide and automatically determine the height while preserving the aspect ratio. The lanczos scaling algorithm is used in this example.
• palettegen and paletteuse filters will generate and use a custom palette generated from your input. These filters have many options, so refer to the links for a list of all available options and values. Also see the Advanced options section below.
• split filter will allow everything to be done in one command and avoids having to create a temporary PNG file of the palette.
• Control looping with -loop output option but the values are confusing. A value of 0 is infinite looping, -1 is no looping, and 1 will loop once meaning it will play twice. So a value of 10 will cause the GIF to play 11 times.

Advanced options

The palettegen and paletteuse filters have many additional options. The most important are:

• stats_mode (palettegen). You can force the filters to focus the palette on the general picture (full which is the default), only the moving parts (diff), or each individual frame (single). For example, to generate a palette for each individual frame use palettegen=stats_mode=single & paletteuse=new=1.

• dither (paletteuse). Choose the dithering algorithm. There are three main types: deterministic (bayer), error diffusion (all the others including the default sierra2_4a), and none. Your GIF may look better using a particular dithering algorithm, or no dithering at all. If you want to try bayer be sure to test the bayer_scale option too.

See High quality GIF with FFmpeg for explanations, example images, and more detailed info for advanced usage.

Also see the palettegen and paletteuse documentation for all available options and values.

---

ImageMagick convert example

_227k

Another command-line method is to pipe from ffmpeg to convert (or magick) from ImageMagick.

ffmpeg -i input.mp4 -vf "fps=10,scale=320:-1:flags=lanczos" -c:v pam \
    -f image2pipe - | \
    convert -delay 10 - -loop 0 -layers optimize output.gif

ffmpeg options:

• -vf "fps=10,scale=320:-1:flags=lanczos" a filtergraph using the fps and scale filters. fps sets frame rate to 10, and scale sets the size to 320 pixels wide and height is automatically determined and uses a value that preserves the aspect ratio. The lanczos scaling algorithm is used in this example.

• -c:v pam Chooses the pam image encoder. The example outputs the PAM (Portable AnyMap) image format which is a simple, lossless RGB format that supports transparency (alpha) and is supported by convert. It is faster to encode than PNG.

• -f image2pipe chooses the image2pipe muxer because when outputting to a pipe ffmpeg needs to be told which muxer to use.

convert options:

• -delay See Setting frame rate section below.

• -loop 0 makes infinite loop.

• -layers optimize Will enable the general purpose GIF optimizer. See ImageMagick Animation Optimization for more details. It is not guaranteed that it will produce a smaller output, so it is worth trying without -layers optimize and comparing results.

Setting frame rate

Set frame rate with a combination of the fps filter in ffmpeg and -delay in convert. This can get complicated because convert just gets a raw stream of images so no fps is preserved. Secondly, the -delay value in convert is in ticks (there are 100 ticks per second), not in frames per second. For example, with fps=12.5 = 100/12.5 = 8 = -delay 8.

convert rounds the -delay value to a whole number, so 8.4 results in 8 and 8.5 results in 9. This effectively means that only some frame rates are supported when setting a uniform delay over all frames (a specific delay can be set per frame but that is beyond this answer).

-delay appears to be ignored if used as an output option, so it has to be used before - as shown in the example.

Lastly, browsers and image viewers may implement a minimum delay, so your -delay may get ignored anyway.

_{Video courtesy of U.S. Fish & Wildlife Service National Conservation Training Center.}

Answer 2

If you would prefer to avoid intermediate image files, the commands provided by LordNeckBeard can be piped between ffmpeg and ImageMagick's convert so that no intermediate files are required:

ffmpeg -i input.flv -vf scale=320:-1 -r 10 -f image2pipe -vcodec ppm - | convert -delay 10 -loop 0 - output.gif

The -f image2pipe tells ffmpeg to split the video into images and make it suitable to be piped out, and -vcodec ppm specifies the output format to be ppm (for some reason if the format is png, either convert does not read all the images from the pipe, or ffmpeg does not output them all). The - for both commands specifies that a pipe will be used for output and input respectively.

To optimize the result without saving a file, you can pipe the output from convert to a second convert command:

ffmpeg -i input.flv -vf scale=320:-1 -r 10 -f image2pipe -vcodec ppm - | convert -delay 10 -loop 0 - gif:- | convert -layers Optimize - output.gif

The gif:- tells convert to pipe its output as gif formatted data and -layers Optimize tells the second convert to perform optimize-frame and optimize-transparancy methods (see the ImageMagick Introduction to Animation Optimization). Note that the output from the -layers Optimize may not always provide a smaller file size, so you may want to try converting to a gif without optimization first to be sure.

Remember that during this whole process everything is in memory so you may need sufficient memory if the images are quite large.

Answer 3

As of ffmpeg 2.6, we can do even better. Based on High quality GIF with FFmpeg:

palette="/tmp/palette.png"
filters="fps=15,scale=320:-1:flags=lanczos"

ffmpeg -i input.flv -vf "$filters,palettegen" -y $palette
ffmpeg -i input.flv -i $palette -lavfi "$filters [x]; [x][1:v] paletteuse" -y output.gif

Answer 4

The answer from @Stephane is very good. But it will get a warning like Buffer queue overflow, dropping. for some video, and the generated gif has some frame dropped.

Here is a better version with fifo filter to avoid Buffer queue overflow when using paletteuse filter. By using split filter to avoid the creation of intermediate palette PNG file.

ffmpeg -i input.mp4 -filter_complex 'fps=10,scale=320:-1:flags=lanczos,split [o1] [o2];[o1] palettegen [p]; [o2] fifo [o3];[o3] [p] paletteuse' out.gif

Answer 5

I made my own version of this script, which parameterizes the output resolution and frame rate as well.

Running ./gifenc.sh input.mov output.gif 720 10 will output 720p wide 10fps GIF from the movie you gave it. You might need to do chmod +x gifenc.sh for the file.

#!/bin/sh

palette="/tmp/palette.png"

filters="fps=$4,scale=$3:-1:flags=lanczos"

ffmpeg -v warning -i "$1" -vf "$filters,palettegen" -y "$palette"
ffmpeg -v warning -i "$1" -i $palette -lavfi "$filters [x]; [x][1:v] paletteuse" -y "$2"

You can read the details on my Github

Assumptions: ffmpeg is installed, and the script is in the same folder as the other files.

Answer 6

Linux/Unix/macOS

Following @LordNeckbeard approach with ffmpeg command, please find the following useful Bash function which can be added into your ~/.bash_profile file:

# Convert video to gif file.
# Usage: video2gif video_file (scale) (fps)
video2gif() {
  ffmpeg -y -i "${1}" -vf fps=${3:-10},scale=${2:-320}:-1:flags=lanczos,palettegen "${1}.png"
  ffmpeg -i "${1}" -i "${1}.png" -filter_complex "fps=${3:-10},scale=${2:-320}:-1:flags=lanczos[x];[x][1:v]paletteuse" "${1}".gif
  rm "${1}.png"
}

Once the function is loaded (manually or from . ~/.bash_profile), you should have new video2gif command.

Example usage:

video2gif input.flv

or:

video2gif input.flv 320 10

^{Scale to 320 width with 10 frames per second.}

You can also specify a different video format (such as mp4).

---

macOS

You can try GIF Brewery app which can create GIFs from video files.

---

Alternatively there are several websites which are doing conversion online free of charge.

Answer 7

The selected answer assumes you wish to scale the source video and change its fps in the gif produced. If you do not need to do this, the following works:

src="input.flv"
dest="output.gif"
palette="/tmp/palette.png"

ffmpeg -i $src -vf palettegen -y $palette
ffmpeg -i $src -i $palette -lavfi paletteuse -y $dest

This came in handy when I wanted a gif that faithfully recreated the source video I was using.

Answer 8

The ffmpeg with palette method can be run in a single command, without intermediary .png file.

ffmpeg -y -ss 30 -t 3 -i input.flv -filter_complex \
"fps=10,scale=320:-1:flags=lanczos[x];[x]split[x1][x2]; \
[x1]palettegen[p];[x2][p]paletteuse" output.gif

This can be done thanks to the split filter.

Answer 9

made a script, tested and works.

usage:

./avi2gif.sh ./vokoscreen-2015-05-28_12-41-56.avi

HAVE PHUN :)

vim avi2gif.sh

#!/bin/sh

INPUT=$1

# default settings, modify if you want.

START_AT_SECOND=0; # in seconds, if you want to skip the first 30 seconds put 30 here

LENGTH_OF_GIF_VIDEO=9999999; # in seconds, how long the gif animation should be

echo "Generate a palette:"
ffmpeg -y -ss $START_AT_SECOND -t $LENGTH_OF_GIF_VIDEO -i $INPUT -vf fps=10,scale=320:-1:flags=lanczos,palettegen palette.png

echo "Output the GIF using the palette:"
ffmpeg -ss $START_AT_SECOND -t $LENGTH_OF_GIF_VIDEO -i $INPUT -i palette.png -filter_complex "fps=10,scale=320:-1:flags=lanczos[x];[x][1:v]paletteuse" $INPUT.gif

btw: vokoscreen is an EXCELLENT ScreenCapturing tool for Linux :)

THANKS A LOT Michael Kohaupt :) Rock steady.

some file size stats:

5.3M = vokoscreen-2015-04-28_15-43-17.avi -> vokoscreen-2015-05-28_12-41-56.avi.gif = 1013K

see the results here.

Answer 10

For Windows users: create a file \Windows\video2gif.bat with this content:

@echo off
set arg1=%1
set arg2=%arg1:~0,-4%
ffmpeg -y -i %arg1% -vf fps=10,scale=-1:-1:flags=lanczos,palettegen %TEMP%\palette.png
ffmpeg -i %arg1% -i %TEMP%\palette.png -filter_complex "fps=10,scale=-1:-1:flags=lanczos[x];[x][1:v]paletteuse" %arg2%.gif
del /f %TEMP%\palette.png

And then you can use it anywhere like this:

video2gif myvideo.mp4

Then you have myvideo.gif next to your original input file. If myvideo.gif already exists, you will be asked to overwrite it.

I suggest using this versatile batch script.

Answer 11

ffmpeg commands:

1. Run this command so that ffmpeg can figure out a good palette:

   ffmpeg -y -i foo.mp4 -vf fps=30,scale=320:-1:flags=lanczos,palettegen palette.png
   

2. Run this command to convert the mp4 file into gif:

   ffmpeg -y -i foo.mp4 -i palette.png -filter_complex "fps=30,scale=320:-1:flags=lanczos[x];[x][1:v]paletteuse" foo.gif
   

You might want to tweak the fps and scale. Smaller for either will result in better file size.

Making a simple alias function

You can also create an alias function like this. I added it to my .bashrc or .bash_profile:

function makegif {
  ffmpeg -y -i $1 -vf fps=30,scale=320:-1:flags=lanczos,palettegen palette.png
  ffmpeg -y -i $1 -i palette.png -filter_complex "fps=30,scale=320:-1:flags=lanczos[x];[x][1:v]paletteuse" $1.gif
}

And then just makegif foo

Note: You'll need ffmpeg of course. Get it here https://www.ffmpeg.org/download.html or brew install ffmpeg

Answer 12

How to add a windows 7/10 "right-click" context menu entry to convert your video file to gif

Some of the other answers mentioned the video2gif script, which I used. But, you could use any script.

To create the context-menu option, you need to edit your registry. Open a powershell command prompt, running w/ admin privs. Execute these commands:

$key = "Registry::HKEY_CLASSES_ROOT\`*\shell\Run Video2Gif"
New-Item -Path $key"\Command" -Value "C:\dev\ffmpeg\ffmpeg-3.4.2-win64-static\bin\video2gif.bat `"%1`"" -Force

Now when you right click a file you'll have a "Run Video2Gif" option!

btw I installed ffmpeg to C:\dev\ffmpeg\ffmpeg-3.4.2-win64-static\ and put the video2gif.bat script in the bin dir right next to ffmpeg.exe. I also added C:\dev\ffmpeg\ffmpeg-3.4.2-win64-static\bin to my windows PATH, but I don't think you need to.

If you want the option of being able to supply some extra command line flags / args to the script, then make a new file named video2gif-prompt.bat, and have the registry referce it instead of video2gif.bat:

@echo off
set /p inp=Enter extrta args, if desired:
C:\dev\ffmpeg\ffmpeg-3.4.2-win64-static\bin\video2gif.bat %* %inp%

You can still just hit enter to quickly get the defaults.

Answer 13

Below is the batch file for Windows users:

gifenc.bat:

set start_time=0
set duration=60
set palette="c:\temp\palette.png"
set filters="fps=15,scale=-1:-1:flags=lanczos"
ffmpeg -v warning -ss %start_time% -t %duration% -i %1 -vf "%filters%,palettegen" -y %palette%
ffmpeg -v warning -ss %start_time% -t %duration% -i %1 -i %palette% -lavfi "%filters% [x]; [x][1:v] paletteuse" -y %2

Source: High quality GIF with FFmpeg: Extracting just a sample

If you just want to use one input variable and have the output name have just the GIF (pronounced JIF) extension, then use this instead:

set start_time=0
set duration=60
set palette="c:\temp\palette.png"
set filters="fps=15,scale=-1:-1:flags=lanczos"
ffmpeg -v warning -ss %start_time% -t %duration% -i %1 -vf "%filters%,palettegen" -y %palette%
set var1=%1
set var2=%var1:~0,-4%
ffmpeg -v warning -ss %start_time% -t %duration% -i %1 -i %palette% -lavfi "%filters% [x]; [x][1:v] paletteuse" -y %var2%.gif

Answer 14

ImageMagick can do this simply:

convert in.mp4 out.gif

Answer 15

My simple trick to GIF conversion is the HandBrake/ffmpeg NLmeans filter. In HandBrake, just tick the NLMeans options in the video config tab.

It smooths out the rough GIF image, making it more easily compressable. The output looks nicer AND has a smaller size.

Answer 16

You can do:

ffmpeg -i input.mp4 output.gif

Answer 17

Simple Bash Function

My most commonly used shell command these days

Usage

makeGif inputVideo.mp4

#DESC make a high-quality gif out of a video (esp. .mp4 or .mov)
makeGif () {
  if [ -z "$1" ]
  then
    echo "makeGif inputVideo [outputGif]"
    return 244
  fi
  vid="$1"
  
  if [ -z "$2" ]
  then
    # remove extension
    outputVideo="${vid%.*}.gif"
  else
    outputVideo="$2"
  fi
  
  ffmpeg -i "$vid" -vf "scale=1920:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=256[p];[s1][p]paletteuse=dither=floyd_steinberg" -loop 0 "$outputVideo"
  
  echo "GIF created: $outputVideo"
}

Answer 18

Using a little bit of everyone's answer, here's a bash script with params and only one ffmpeg command (and show the final file size):

#!/bin/bash

# Default values
fps=15
scale=720

# Function to display usage
usage() {
  echo "Usage: $0 [--fps <fps_value>] [--scale <scale_value>] <input_video.mp4>"
  echo "  --fps: Optional. Set frames per second (default: 15)"
  echo "  --scale: Optional. Set output width in pixels (default: 720)"
  exit 1
}

# Parse optional arguments
while [[ "$#" -gt 0 ]]; do
  case "$1" in
  --fps)
    fps="$2"
    shift 2
    ;;
  --scale)
    scale="$2"
    shift 2
    ;;
  -*)
    echo "Unknown option: $1"
    usage
    ;;
  *)
    input_video="$1"
    shift
    ;;
  esac
done

# Check if input file is provided and ends with .mp4
if [[ -z "$input_video" || ! "$input_video" =~ \.mp4$ ]]; then
  echo "Error: Input file must be specified and have a .mp4 extension"
  usage
fi

# Output GIF file name
output_gif="${input_video%.mp4}.gif"

# Generate the GIF in a single command using split for palette
echo "Creating GIF with fps=$fps and scale=$scale"
# ffmpeg -i "$input_video" -vf "fps=$fps,scale=${scale}:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" "$output_gif"
ffmpeg -i "$input_video" -vf "fps=$fps,scale=${scale}:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=256[p];[s1][p]paletteuse=dither=floyd_steinberg" "$output_gif"

gif_size=$(stat -c %s "$output_gif" | numfmt --to=iec)

echo "Conversion complete: $output_gif (fps=$fps, scale=$scale, size=${gif_size})"

Example Usage:

mp4togif --fps 10 --scale 720 myvideo.mp4

--fps: Optional. Set frames per second (default: 15)
--scale: Optional. Set output width in pixels (default: 720)