FFmpeg 6.0

What is the the "right" preset? SVT-AV1 has a wide range of presets, from being about as fast as x264 veryfast onwards. And for any given speed level it should provide significantly lower bitrates at the same quality than x264, x265 or libvpx.

For example if you pick speed 6 on SVT-AV1 it should take about as much time as x264 veryslow while still being 30-40% lower bitrate at the same quality.

Have you tried the faster presets of SVT-AV1?

I dont have a card to test, but the last VMAF bench I saw shows hardware AV1 is slightly better than veryslow x264.

Which is way better than hardware h.264... but also terrible compared to svt-av1, lol.

Try using av1an to parallelize (and improve the quality of) your encode. And TBH you should not re encode your library unless it has raw rips or something like that, and you are short on space.

Thanks for watching the talk :)

This is very nice. I've been surprised how many people don't know HN, it can definitely use some promotion.

“Did you know that Dennis Ritchie wrote macOS? Just look at stdio.h, it’s still there.”

... before being absorbed into his own AI and is now ascended in the Ethernet plane silently generating endless frames of international scandi-noir thriller serials for Netflix.

I'd love to borrow FB's brain for one week so that I could get an entire year's worth of work done.

“Even in death, I serve the Omnissiah.”

Chuck Norris once opened Windows and created the Macintosh.

Blessed be His bits.

Amen.

https://smartbear.com/blog/fabrice-bellard-portrait-of-a-sup...

Sorry, windows 98 running in JS is way way WAY more impressive. It's just insane.

Also LZEXE back in time...

The most impressive thing is the LTE modem

If we studied Fabrice from the perspective of "how can all be more like him/as productive as him/as innovative/as smart", do you think the findings would basically come back "he's just genetically gifted"?

He's like the Lebron James of the tech world from what I can deduct.

He's been gone from ffmpeg for many years.

I don't see anything wrong with this. It's like saying "Apple is built by Steve Jobs" even though obviously a lot more people are involved, and even if Jobs is no longer even around.

Dot zero releases basically signify major bumps of the core libs, and are not really synced with user-facing feature changes.

I am still using 4.2. Does it make any difference if all I care about is h264 and hevc?

It really works! With few interactions, ChatGPT was able to create a not so obvious -filter_complex pipeline, like:

  ffmpeg -ss 00:01:00 -t 00:02:00 -i input1.mp4 -ss 00:03:00 -t 00:02:30 -i input2.mp4 -filter_complex "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a];[v]eq=brightness=0.3[outv]" -map "[outv]" output.mp4

Yes, chat GPT excels at comprehending and explaining things that have a consistent structure, restructuring, and and synthesising variations. If you keep it in its lane, it’s an excellent tool.

It’s really really bad at counting though. For example, try asking it to produce a line of 40 asterisks.

Just be sure to thank all those stackoverflow repliers for this!

Agree! I used ChatGPT to explain some (uncommented)ffmpeg scripts I wrote few years ago. Scripts where created by going trough many websites and adapting to my needs. Explanation from chatGPT was spot on.

crf: "Constant Rate Factor" for x264 among other encoders. Think it like a output quality (higher = lower quality). I'd say 28 is way too high especially when you're using preset=veryfast (too bad quality). Since it's only 640-480, most of computers can handle fast or even medium in real-time. If not sure, I'd say just use default (by not giving anything).

pix_fmt: pixel format. 99% videos use this format, and it has best compatibility. FFMPEG will try to keep the original format when do transcoding, so in most of time you don't need to specify. However, in this very case, since the input is from a webcam, the chance it uses some weird format is high. And you don't want to keep that in your final result. So it's good to specify it out here.

My 2c: ChatGPT is great, but I recommend to read the comments it gives about each parameter, try to understand their purposes, and adjust accordingly if needed.

Also having a rough idea about how FFMPEG pipeline works (mainly the order of input, output and their associated switches in arguments) helps a lot.

Video process is a very complex thing and lots of time it relies on experience. Just be prepared sometimes your "typically works" command would break.

> Never used the `crf` or `pix_fmt` flags personally, but seems correct (

Let me translate: the AI might or might not be bullshitting, I have no way to know but I decide to believe in it. Why ?

You need `-pix_fmt yuv420p` for an iPhone to recognize a ffmpeg-encoded video file.

Yeah, crf sets the quality and 28 will make your video look like a blurry over-compressed mess. Congrats :)

I was looking for ffmpeg.guide the other day and couldn't remember what it was called, thanks!

The ffmpeg cli supports multiple inputs and multiple outputs, so there needs to be a way to unambiguously map an option to its target. Position is looked at, to group options for the same target together.

argument order is definitely a feature. with -ss being one that behaves differently depending on it's location in reference to -i. it's not an accidental thing and the desired outcome dictates where you place it. not understanding that just means you're not using it enough to grok it.

Thanks. Looks like the input in question was an .avi file. That's a container format I don't know anything about (and don't particularly care to). I suspect then it's not relevant for anything more modern.

It’s used heavily by professional broadcasters and TV/movie studios. AWS run it, satellite TV services use it, some VFX studios use it, etc. it’s become pretty foundational industry tech.

Google must be using it for Youtube. Wikimedia is using it as well.

I can tell you it’s heavily used in professional settings within the entertainment industry. There is no better tool, thankfully!

YouTube appears to have used ffmpeg, at least in 2011: https://news.ycombinator.com/item?id=2831292

After some more digging, I'm realizing the same. Fingers crossed soon.

ffmpeg and ffprobe are built against the exact same set of libraries, so they could certainly be combined into a single program if the ffmpeg maintainers chose to do so.

Two possible options to reduce the size of your application:

(1) Instead of using ffprobe, just call "ffmpeg -i <filename>" without specifying an output file, then parse stderr:

    $ ffmpeg -i https://download.dolby.com/us/en/test-tones/dolby-atmos-trailer_amaze_1080.mp4 >/dev/null
    ffmpeg version 4.4.2 Copyright (c) 2000-2021 the FFmpeg developers
    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
    Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'https://download.dolby.com/us/en/test-tones/dolby-atmos-trailer_amaze_1080.mp4':
      Metadata:
        major_brand     : isom
        minor_version   : 512
        compatible_brands: isomiso2avc1mp41
        encoder         : Lavf58.76.100
      Duration: 00:01:03.55, start: 0.000000, bitrate: 4537 kb/s
      Stream #0:0(und): Audio: aac (LC) (mp4a / 0x6134706D), 48000 Hz, 5.1, fltp, 128 kb/s (default)
        Metadata:
          handler_name    : sound handler
          vendor_id       : [0][0][0][0]
      Stream #0:1(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 1920x1080 [SAR 1:1 DAR 16:9], 4404 kb/s, 24 fps, 24 tbr, 12288 tbn, 48 tbc (default)
        Metadata:
          handler_name    : video handler
          vendor_id       : [0][0][0][0]
    At least one output file must be specified

(2) Link both ffmpeg and ffprobe dynamically, in which case they'll share all but a few hundred kilobytes of on-disk code.

For example, consider ffmpeg and ffprobe as installed from package repositories on a variety of systems:

ffmpeg 4.4.2 installed by MacPorts on macOS Monterey (x86_64):

    $ du -hA /opt/local/bin/ff{mpeg,probe}
    339K  /opt/local/bin/ffmpeg
    260K  /opt/local/bin/ffprobe

    $ diff -s <(otool -L /opt/local/bin/ffmpeg) <(otool -L /opt/local/bin/ffprobe)
    1c1
    < /opt/local/bin/ffmpeg:
    ---
    > /opt/local/bin/ffprobe:
    72d71
    <  /usr/lib/libobjc.A.dylib (compatibility version 1.0.0, current version 228.0.0)

    $ du -h /usr/bin/ff{mpeg,probe}
    284K  /usr/bin/ffmpeg
    176K  /usr/bin/ffprobe

    $ diff -s <(ldd /usr/bin/ffmpeg | awk '{ print $1 }') <(ldd /usr/bin/ffprobe | awk '{ print $1 }')
    Files /dev/fd/63 and /dev/fd/62 are identical

    $ du -h /usr/bin/ff{mpeg,probe}
    276K  /usr/bin/ffmpeg
    176K  /usr/bin/ffprobe

    $ diff -s <(ldd /usr/bin/ffmpeg | awk '{ print $1 }') <(ldd /usr/bin/ffprobe | awk '{ print $1 }')
    Files /dev/fd/63 and /dev/fd/62 are identical

    $ du -h /mingw64/bin/ff{mpeg,probe}.exe
    320K  /mingw64/bin/ffmpeg.exe
    184K  /mingw64/bin/ffprobe.exe

    $ diff -s <(Dependencies -depth 1 -modules /mingw64/bin/ffmpeg.exe | tail -n +2) <(Dependencies -depth 1 -modules /mingw64/bin/ffprobe.exe | tail -n +2)
    Files /dev/fd/63 and /dev/fd/62 are identical

This is true. Do you have a use case where being off by a few frames might be a deal breaker?

Personally I've created dozens of clips using this method and it always turns out ok. It gives you about ~1 second precision on where you want to make your cuts. After I create the clips I can play things back normally, complete with an ability to seek to specific points successfully.

Fundamentally (ignoring ffmpeg incantations), I think there are four options:

1. re-encode the whole thing

2. re-encode just the first GOP

3. start a bit early or late

4. include the full first GOP but use an edit list to instruct the player to skip to the timestamp of interest

Thanks! At least changes look recent so there must be some plan to upstream it.

That's been there for a while. AV1 decoding also exists. But I'm curious what's going on with AV1 encoding.