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. Portrait mode is an abomination made more painful by the surprisingly complex process required to correct it.

A good resource on this (is not StackExchange!) can be found here.

To fix this, it seems you have to re-encode it. Not only that but you often need a two step process to first correct the metadata and then the re-encode to dimensions that are actually accurate. Super annoying.

First make sure you can get a handle on what you’ve got. You can use ffprobe or exiftool to have a look at what you need to know. I find that ffprobe works fine and without surprises, but exiftool is very clear. For example running it on a video shot with a telephone held the wrong way yields this.

If it’s really a vertically oriented shot with, say, a person’s head at the top and feet at the bottom, how would the "width" be bigger than the "height"? So it’s like the camera is fixed with its horizontal axis as the long one and it’s just being held sideways and that’s noted in the rotation metadata.

Step one is to fix that metadata. This should work.

Perhaps check it again to see if that worked. But now you have a video with no spurious "rotation" metadata, (which mplayer ignores). How do you re-encode it so that it’s actually 1080 wide and 1920 high? This seems to work.

Note that the transpose settings are rather cryptic and though I haven’t verified this, here is a plausible explanation I have encountered.

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 image files and converts them into a video format.

Note that without the -pix_fmt yuv420p option, you might get something that plays in mplayer but will crash in vlc.

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 gifsicle.

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.

If you’re trying to make a video showing someone how you do a computer thing you’ll want to live capture your screen. The x11grab format specification can do the job. Here is the full command to record 10s of screen action from roughly the upper left HD quadrant of a display.

I’ll break down what everything does.

The y is to agree to overwrite any pre-existing file.

The video grabbing format and the input device is similar to -i ${DISPLAY}+${X}+{Y} where X and Y are the coordinates from upper left to start the subregion from. The size completes the specification. Some people believe framerates of 30 make sense, but I would think even lower is ok if space is important.

Now the audio.

I’m not sure if the thread_queue_size is important. The ac means two channel - this also may be wrong. The input device seems to be the default mic and can be looked into with arecord -l; the numbers come from the card 0: and device 0: I think.

Finally specify how long you want the capture to last and the file name. I would recommend specifying a fixed time even if you don’t know how long you’ll ramble on. By cutting off the recording (with Ctrl-C BTW) you may leave the recorded file in a confused state. It might be better to have a longer file that you can then truncate later.

To make sure the region you want to record is exactly correct, it can be helpful to use wmctrl like this.

This puts the Blender window in the upper left corner of the display in the right place and size to be captured. Another way for Blender specifically is this.

Note the first two numbers are x and y of the lower left point.

Here’s a way to keep a running countdown to keep an eye on how much time you have left. This will print a countdown (presumably to the end of your fixed length video) and print in red for the last 10 seconds.

I show 65 so that you can start this and when it gets to 60, start your 1 minute video.

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.