From InstallGentoo Wiki
Jump to: navigation, search

WebM support is the newest addition to 4chan (as of April 6th, 2014). WebM is an open, royalty-free, media file format designed for the web.

WebM defines the file container structure, video and audio formats. WebM files consist of video streams compressed with the VP8 video codec and audio streams compressed with the Vorbis audio codec. The WebM file structure is based on the Matroska container.

This wiki page is meant to serve as an instructional tool to help you get started converting your content to WebM for posting.

General info

List of stickies / test threads


Current limits for WebM files on 4chan are:

  • Maximum file size is 4096KB.
  • Maximum duration is 300 seconds (5 minutes).
  • Maximum resolution is 2048x2048 pixels.
  • No audio streams except on /gif/ and /wsg/. (use -an)

Current limits for WebM files on 8chan are:

  • Maximum file size is 8192KB.
  • Maximum resolution is 10000x10000 pixels.
  • Audio streams permitted globally.

Converting with ffmpeg

Note: avconv and ffmpeg are not entirely drop-in replacements. Make sure you know which one you are using.

OS X Users: The homebrew version of ffmpeg doesn't include webm support by default, try brew install ffmpeg --with-libvpx.

Command line options

Below is an ffmpeg command:

ffmpeg -i input.mp4 -c:v libvpx-vp9 -b:v 1M -c:a libvorbis output.webm

This may look intimidating but it is not all that bad. Let's look at the different parameters:

  • -i: Specifies the input file, which you're converting to another format.
  • -c:v Specifies the video codec to use. webm isn't actually an encoding type unto itself, but an audio/video container, like mkv. Nevertheless, you will almost always use libvpx for the video. VP8 has been succeeded by VP9. In order to utilise it, you must use "libvpx-vp9", as "libvpx" will use VP8 instead.
  • -b: Sets the target bitrate. -b:v sets video bitrate and -b:a sets audio. Only use this option if you desire a constant bitrate, which will produce a higher quality file. If you are looking for a smaller file size, consider leaving this out.
  • -c:a: Specifies the audio codec to use. Some options include libvorbis, libmp3lame, etc. If you are unsure stick with libvorbis. As libopus is capable of lower filesizes at very low bitrates, if you are using an audio bitrate of, for example, 64K, you may consider using libopus instead of libvorbis.

Other useful options:

  • -threads: Tells ffmpeg to use multithreading, speeding up the encoding process. Enter the number of cores your processor has -1 as a parameter (for quadcore, use -threads 3) or put 0 to use them all. VP8 and VP9 cannot auto-detect the amount of cores your processor has, so using -threads 0 is equivalent to using -threads 1. Be aware that using multithreading may slightly lower output quality and have the effect that repeat encodes do not have identical results.
  • -ac: Sets number of audio channels, normally 2 or 1. Sometimes setting to 1 will give you a smaller filesize. You should probably not touch this unless you know what you're doing.
  • -an: Disable audio. Use when converting .gif files to .webm.
  • -sn: Disable subtitles.
  • -ss: Seeks to a position in the file. Useful for cutting out small scenes. Takes time in seconds as a parameter or HH:MM:SS syntax. use -t in tandem to set the file duration. For example, -t 00:00:10 cuts out the first ten seconds of the video for conversion, and -ss 00:00:10 -t 00:00:10 would skip the first ten seconds and cut out the next ten for conversion.
  • -speed: Controls the speed at which the video is encoded. Faster speeds come at the expense of lower quality and larger filesizes. Use -speed 0 for maximum quality and lowest filesizes.
  • -qmin and -qmax: Tells ffmpeg what "quantization parameter" to use when assigning quality. Don't worry if you don't know what a quantization parameter is, because neither do I. All I know is that lower numbers = better quality. I believe the -qmax option prevents the quality from dropping below a certain level for any given frame, so the overall video quality will be more consistent (it prevents you from getting certain frames in your video which are of absolutely dreadful quality where everything is blocky as fuck, basically). Recommended values: -qmin 0 -qmax 50
  • -crf: Sets CRF value. Must be from 4-63 in VP8, or 0-63 in VP9. Lower is higher quality. 10 the recommended setting. There are two ways of using CRF - 1) "Constant Quality" mode, 2) "Constrained Quality" mode.
    • 1) To use constant quality mode, you MUST use a value of "0" when specifying the video bitrate (-b:v 0). If you just remove the "-b:v" option altogether, ffmpeg will simply fall back on the default bitrate (256K, I think), which will result in a constrained quality encode with extremely poor quality. Constant quality mode tries to achieve a... well... constant level of quality, using whatever bitrate is necessary to achieve that level of quality. This can result in very large file sizes, so is generally not suitable for making webms intended for imageboards which typically have a file size limit of 10MB or less. Example command: ffmpeg -i input.mp4 -c:v libvpx-vp9 -crf 10 -b:v 0 -c:a libvorbis output.webm
    • 2) To use constrained quality mode, you must specify both a CRF value (e.g. -crf 10) AND a video bitrate value (e.g. -b:v 1M). Constrained quality mode will try to achieve a certain level of quality, but without going over a specified bitrate level. When -b:v is used without -crf, the value of -b:v is a target bitrate, but when -b:v and -crf are used together, -b:v becomes a maximum bitrate. This is a way of achieving high quality while still retaining control over the filesize. Ideally it should be used with the 2-pass encoding method. Example command: ffmpeg -i input.mp4 -c:v libvpx-vp9 -crf 10 -b:v 1M -c:a libvorbis output.webm

To simply print metadata about a video file: ffmpeg -i input_file -f ffmetadata metadata.txt

Seeking issue with VP9

VP9 currently has a stupid default value (9999, i.e. infinite) for the maximum interval between keyframes, which can result in only a single keyframe being created at the very beginning of the video causing the following seeking issues during playback:

  • Trying to navigate forwards through the video using the arrow keys on your keyboard causes the audio to skip ahead but the video to freeze.
  • Trying to navigate backwards causes the video to skip right back to the first frame.
  • Precise seeking using mouse clicks is very slow; after clicking somewhere on the progress bar, there will be a delay of several seconds before the video actually skips to that point.

If you encounter this problem, it is easily fixed with the -g option. The default value in VP8 for this option was 128, so try that first ("-g 128"). If seeking issues persist, try lowering the interval further (e.g. "-g 64").

2-pass encoding

You may utilise the 2-pass encoding method in order to increase the quality of your video, at the expense of making the encoding process a little longer. During 2-pass encoding, you will make one "pass" through the video where the encoder simply collects information about the video you want to make a webm from, and then a second "pass" where you encode the video for real utilising the information collected during the first "pass". The advantage of this is that the encoder knows what to expect when encoding the video and doesn't have to guess whether the next frame is going to be a difficult frame or not depending on how difficult the previous frames were. This results in a better allocation of bits, and thus better quality.

Here is an example:

  • First pass: ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 1 -qmin 0 -qmax 50 -crf 10 -b:v 1M -threads 1 -tile-columns 0 -speed 4 -g 128 -aq-mode 0 -an -sn -f webm /dev/null
  • Second pass: ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 2 -qmin 0 -qmax 50 -crf 10 -b:v 1M -c:a libopus -b:a 64K -vbr on -threads 1 -tile-columns 0 -speed 0 -auto-alt-ref 1 -lag-in-frames 25 -g 128 -aq-mode 0 -sn -f webm output.webm

Operations with -vf

The -vf flag allows you to define 'filters' which can help you further manipulate the file. The syntax for this looks something like -vf <filter<=<param>. Use ffmpeg -filters to get a list of filters and how to use them. Some of the more common ones will be explored below.

  • scale: Scale takes two arguments separated by a colon, which are width and height respectively. If you enter -1 for either variable, ffmpeg will scale the video based off of the aspect ratio of the source file. An example of this would be -vf scale=640:-1, though it is preferable to use -2 which will ensure that the resolution is divisible by 2.
  • crop: Crop the input video to given dimensions. Takes 4 arguments: width:height:left:top. For example -vf crop=200:100:50:10 will crop a 200x100 rectangle 50px left from the border and 10 from the top.

Join clips

To join 2 or more clips, create a text file containing the name of the files like this:

file 'file1.webm'
file 'file2.webm'
file 'file3.webm'

Then call ffmpeg: ffmpeg -f concat -i files.txt -c copy output.webm

Reverse a video

Use the following command to reverse a video:

ffmpeg -i input.webm -vf reverse out.webm

Premade scripts

If you're that lazy, here's a couple premade scripts for video and gif conversion.


Save these programs as a .bat file and place them in the folder of the video you want to convert.

Video to WebM'

@echo off
rem about 3megabyte in bit 3*1024*1024*8*0.95
set /A MAXSIZE=23907532
set WIDTH=720
ffmpeg -i %1 2> webm.tmp
for /F "tokens=1,2,3,4,5,6 delims=:., " %%i in (webm.tmp) do (
    if "%%i"=="Duration" call :calcLength %%j %%k %%l %%m
del webm.tmp
ffmpeg -y -i %1 -threads 0 -sn -an -c:v libvpx -b:v %BITRATE% -vf scale=-1:%WIDTH% -quality best -cpu-used 0 -slices 8 -auto-alt-ref 1 -f webm -pass 1 NUL
ffmpeg -y -i %1 -threads 0 -sn -an -c:v libvpx -b:v %BITRATE% -vf scale=-1:%WIDTH% -quality best -cpu-used 0 -slices 8 -auto-alt-ref 1 -f webm -pass 2 %~n1.webm"
del ffmpeg2pass-0.log > NUL
goto :EOF
FOR /F "tokens=* delims=0" %%A IN ("%3") DO SET /A s=%%A
FOR /F "tokens=* delims=0" %%A IN ("%2") DO SET /A s=s+%%A*60
FOR /F "tokens=* delims=0" %%A IN ("%1") DO SET /A s=s+%%A*60*60

gif to webm

ffmpeg -y -i "%~1" -b:v 3M -quality best -cpu-used 0 -slices 8 "%~1.webm"

Linux / OS X

If you're using OS X or Linux, you probably know how to save and execute these scripts already, but here's a quick overview:

  1. Create a file, such as ~/bin/my_script.sh
  2. Copy and paste the code into this file with your favorite editor.
  3. Open a shell. Run the command chmod +x ~/bin/my_script.sh
  4. The script can now be called as ~/bin/my_script.sh some_file.type or if you have your PATH set correctly, my_script.sh some_file.type


It does interactive cropping with mplayer, interactive selection of start and end times with mplayer, hardsubs, and has many more options.


.gif Convert

ffmpeg -i $1 -threads 0 -cpu-used 0 -c:v libvpx -f webm -b:v 700k -quality good -qmin 10 -qmax 42 -an /dev/null
ffmpeg -i $1 -threads 0 -cpu-used 0 -c:v libvpx -f webm -b:v 700k -quality good -qmin 10 -qmax 42 -an "$F"

High-End Video Convert

# Warning: this script will probably take up a lot of CPU usage. Don't crash your machine.
ffmpeg -i $1 -threads 0 -cpu-used 0 -c:v libvpx -c:a libvorbis -ac 2 -qmin 0 -qmax 10 -bufsize 1000k -quality good -crf 4 -b:v 2M -pass 1 /dev/null
ffmpeg -i $1 -threads 0 -cpu-used 0 -c:v libvpx -c:a libvorbis -ac 2 -qmin 0 -qmax 10 -bufsize 1000k -quality good -crf 4 -b:v 2M -pass 1 "$1".webm

̈́Split Video

# Takes a large video file and splits it into multiple 3MB webm files
# Duration of original video in seconds
duration=$(expr `mediainfo --Inform="General;%Duration%" "$1"` / 1000)
until (($sec >= $duration))
ffmpeg -ss $sec -i "$1" -an -sn -threads $threads -c:v libvpx -crf $crf -b:v $bitrate -fs 3M $j.webm  
# Duration of previous video is added to the sum of every previous video
sec=$(expr $(expr `mediainfo --Inform="General;%Duration%" $j.webm` / 1000) + $sec)

Poster Image with Audio

ffmpeg -r 1 -loop 1 -i 1.png -i 1.wav -c:v libvpx -c:a libvorbis -b:a 64k -shortest out.webm

GUI options


Records the selected area and saves the output as WebM, just like GifCam does it with GIFs.


You can also refer to Recommended_software for video editing and converting programs.

External resources

  1. https://trac.ffmpeg.org/wiki/vpxEncodingGuide
  2. WebM of a WebM tutorial: https://rbt.asia/boards/g/img/0411/75/1396646705233.webm
  3. http://www.webmproject.org/docs/encoder-parameters/
  4. http://wiki.webmproject.org/ffmpeg
  5. N0Lif3's Windows tutorial: https://www.youtube.com/watch?v=WeM3SUp-HRg
  6. http://wiki.webmproject.org/ffmpeg/vp9-encoding-guide
  7. https://github.com/Kagami/webm.py/wiki/Notes-on-encoding-settings
  8. https://trac.ffmpeg.org/wiki/Encode/VP8
  9. https://trac.ffmpeg.org/wiki/Encode/VP9
  10. http://forum.doom9.org/showthread.php?t=168947
  11. http://slhck.info/video-encoding