Linux Video Notes

I have successfully used the technique described here. For example, this takes a long boring video and makes it a smaller (size) and shorter (time) video.

This saves an enormous amount of storage space.

Sometimes you get video data in the form of something like a raw H264 stream. To encode that into a proper mp4 codec is pretty simple with ffmpeg. Here is video captured from a Raspbery Pi camera being converted to a playable format.

Sometimes you make a nice video and the stupid browser complains: Video can’t be played because the file is corrupt. This may happen even if you can play it from the command line just fine. How to fix? Well, I don’t really understand the details of the problem (an always moving target), but this encoding process cleared it up for me.

Note that there are rumors that it has to be a square aspect ratio. That’s a bit mental but whatever - in my case, it coincidentally worked out but something to keep in mind.

Instead of rescaling you can change the output size by cropping the frames, perhaps removing something stupid, e.g. a FLIR logo.

The crop variable is the width, height followed by the x and y offsets; left is 0 and top is 0.

The epic stupidity of telephone cameras means that it is almost the rule rather than the exception that video taken with them will be upside down or in the incorrect mode. Which is portrait mode — the incorrect mode for video is portrait.

To fix this, it seems you have to re-encode it. Super annoying. The following seemed to work for a completely upside down video.

I think that a 90 degree rotation can be achieved by removing one of the "transpose=1" statements. When running this I got a ton of "Past duration too large" warnings which I ignored.

Also consider this if your camera is mounted up side down.

And for lack of a better place to note it, if you have still images from a "telephone" "camera", they too are no doubt tagged with an incorrect orientation. To dump all the exif data an image is tagged with, just use exiftool image.jpg. That command I believe can fix orientation problems but an easier way may be to use exifautotran image.jpg.

Here is roughly the technique needed to get this working.

Note here that the resulting video is only 30s long (6 min to 6.5 min from the original source). Also note that it seems important that the -ss come before the -i option.

Is the video silent? Do something like this and it definitely will be.

This one will split a video into two files at a breakpoint 30 seconds into the video.

Here is another look at doing this.

Here is another trick if you’re tying to get a short clip from a bigger video because you want to share it on some web platform like Slack or Discord. Note the libvpx codec. This file is only 6MB for 20 seconds, so pretty light.

Note that ffmpeg has a -t option to set the duration time of the video, but I’ve have had problems getting it to work and have seen reports of others with the same problem. But -vframes does seem to cut off the video at the right place. It’s annoying they don’t just have start time and stop time which would make sense. To get the correct vframes value you have to figure out the duration in seconds you want and then multiply by the frame rate (often 30). To get frame rate, play the video with mplayer and watch its console output for "FPS".

Official documentation for concatenation might be useful.

If you have multiple fragments that you need to join, include their paths in a text file. The file formerly could be a simple ls but now it seems to want some fancier format. This worked for me.

Once you have the file list created this should work.

Some discussion about this topic.

Note that the extremely irritating "safe" nonsense relates to a bunch of cryptic things discussed here.

Very good official documentation about all aspects of video scaling can be found here. A good way to shrink videos from the Canon A590 to send to fb:

Another application to shrink videos to save space (factor of 5 without noticeable quality loss):

The -s is the new size. The -ar is the audio bitrate.

Here is the ffmpeg way to resize. This shrinks the geometry with -s and removes the audio with -an. This size is quarter HD and used in some driving videos I’ve worked with.

Often you want to share something in a bandwidth economical way — this often can be best achieved by scaling and extracting only relevant parts. Here I’m taking a 3.7GB dashcam video and creating a new (re-encoded) video of only the action between 1:45 and 2:45.

The resulting file is 1.7MB and is sufficient to properly understand what’s going on.

The following technique is useful for making stop motion animation videos and videos of slide shows. It takes a list of jpeg files (and only jpeg files as I understand it) and converts them into a video format. The following was able to take hundreds of jpegs and make them into a video that could be uploaded to YouTube.

(Hmmm. This actually doesn’t look right. See farther down…)

The -r is the framerate, here 120 frames per second (30 is common). These particular settings were to extract video from a GoPro. Note that with this starting offset (-ss) the program can sit there apparently doing not much of anything for quite a while until it gets to the relevant section; I think it must calculate the previous frames since many codecs are basically diffs.

This used to work for PNG:

Now I’ve had better luck with this.

This makes a large but high quality video. I’ll let YouTube sort out the details.

Sometimes you have a big collection of jpegs from something like motion and they have messy timestamps in their names. How do you make all the images into a format for something like a technique that needs a numeric printf pattern?

Or check out this method that can use globs directly.

It seems like globbing isn’t always present in ffmpeg and that’s a pain.

Just like the other way around, you can pull still images out of video. Some official documentation describes this technique which looks good.

Wow… I just learned something very important. The order of arguments matters!! A lot! I have a long video I need to get 100 frames from at specific points. If I do this it could take half an hour.

If I do this it takes half a second.

Note the order is the only difference. The order in this case changes it from accurate seeking mode to fast seeking mode. More is said about this here.

Here’s another example. This one takes a still every second (fps=1). The qscale:v is a quality specifier. Apparently 2 is the highest.

Note that stuff like fps=1/2 for an image every two seconds. It’s worth double checking the quality of the images if that is important. I found that the -qscale technique could have quality issues despite 2 being the ostensible "best".

Some people believe that using -qmin 1 -qscale:v 1 will make things good. I didn’t try that but worth checking. Watch file sizes.

This works ok. Not perfect but ok.

In theory you need to have a particular cooperative codec. In practice it helped a lot.

Also note that if you extract to PNG it may not be lossless (and jpg certainly loses information). A strategy that avoids this problem is to extract to uncompressed .bmp files. These might be quicker to produce. After reviewing the images to your satisfaction, you can use ImageMagick’s convert to change them to lossless PNG with the PNG24: filename prefix.

Extract mp3 track of the video to sound files with:

This assumes that the video has an mp3 encoded sound track. YouTube appears to do this. Here’s a more complicated way to do this that might be necessary:

Here’s a function that can turn Youtube videos into mp3 files on the fly:

To check what streams, audio and video, are in a video file:

To actually convert some other audio stream:

Where -ab specifies the audio bitrate.

To extract a subset of video to a new video:

Not that the -ss is the start always in seconds. The -endpos is more ambiguous. If an -ss is used, it means seconds running time of the subset. If -ss isn’t used, it means the same thing and it actually corresponds to endposition (time of subset from zero). This is why in the example, the "end position" is less than the -ss, starting position.

General ripping:

Check animated GIFs by loading them from a browser (file:///tmp/mymeme.gif) or this.

Install that with apt install gifview.

Some proper documentation details about speeding up (and slowing down) video (including audio) can be found here.

This mostly works.

This technique is supposed to drop 19 of 20 frames by playing with the frame rates.

Sometimes I’ve had problems where video playback does not end. I play the video and it looks fine but when it finishes, it sits there and waits a long time. This is often when I’ve been altering the speed of things or making time lapse from normal video. What I have figured out is that this can be caused by some latent, perhaps silent audio track that didn’t get the same kind of time dilation and it’s finishing its (silent) playback. I found that by throwing in a -an the problem was fixed.

This article sums up the Real Housewives of libav/ffmpeg quite well.

Ya, so this is tricky. It sounds like the ffmpeg lead maintainer was being a bit of an imperious wanker and then the avconv guys forked it (or something), started up with their own management style problems, and proved why he needed to be a wanker.

Previously I had needed to give avconv its own section because it was showing up as the primary option on Debian and there were enough irritating differences. These days I think that the Libav project is struggling now that it has lost its ace card of being bundled with Ubuntu.

Here is Wikipedia on the current state of affairs as of March 2019.

There seems to have been something of a vague reconciliation. Now it looks like there may be an ffmpeg package that is the real thing again, now no longer forked. Whew! The active ffmpeg web site seems like it’s still going strong. Doing a Debian apt-get install libav-tools in Feb 2017 produced a working avconv and no ffmpeg. Here is a discussion of this situation.

I am personally going to pick sides here and go with ffmpeg as my first choice.

So I’m going to focus only on ffmpeg in the future.

Getting sick of removing the SD card from the camera and mounting it on a proper computer every time? Use gphoto2! Obviously make sure the camera is turned on and detected.

This all works pretty well. Note that caja . to look at the current directory’s photos is pretty handy though sometimes if the files are bigger than 10MB — which is a regular situation with a fine camera — then thumbnails are not generated unless you go to Preferences and raise the limit.