pito-codecs, measured

First frame 12× to 28× faster than ffmpeg, whose time includes starting its process, and decode on the card level or faster, with every place ffmpeg still wins kept on the page. One machine: AMD Ryzen 9 9950X, AMD Radeon RX 9060 XT on Mesa's radeonsi VA-API driver, Linux, ffmpeg 9.0.1, public-domain NASA footage. Every chart drawn by pito-compare from pito-codecs' own data.

Against ffmpeg

Times faster or slower per job, then each job on its own chart.

Balanced ratio chart, pito-codecs against ffmpeg 9.0.1. Faster: first frame H.264 on the CPU 20×, first frame HEVC on the GPU 28×, filmstrip HEVC 1440p 11×, filmstrip H.264 1080p 9.0×, smart cut 1440p 2.0×, H.264 1080p GPU decode 1.2×, HEVC 1080p one-thread CPU decode 1.0×, H.264 and HEVC GPU encode 1.2×, scaling 2.1×, EBU R128 loudness 6.0×, AAC encode 1.7×. Slower: H.264 1080p CPU decode 1.3×, AAC decode 1.7×.
Every job against ffmpeg 9.0.1 Times faster or slower on a balanced log scale: right of 1× is faster than ffmpeg, left is slower. Both sides are shown. One run of examples/bench.rs on 2026-10-15.

Open and see

Paired bars, milliseconds, lower is better. CPU: H.264 4.2 ms against ffmpeg's 85.2 ms, 20× faster; HEVC 7.4 against 88.9 ms, 12× faster. GPU: H.264 3.5 against 87.4 ms, 25× faster; HEVC 3.2 against 88.9 ms, 28× faster.
Time to first frame, 1440p A cold file each time: opened, parsed, first frame decoded. 4.2 ms against 85.2 ms for H.264 on the CPU. ffmpeg's time includes starting its process.
Paired bars, stills per second, higher is better. H.264 1080p: 510 against ffmpeg's 56.9 on the CPU, 507 against 57.2 GPU first. H.264 1440p: 332 against 38.9, 340 against 38.8. HEVC 1080p: 486 against 51.0, 470 against 50.2. HEVC 1440p: 360 against 33.1, 369 against 33.3.
Filmstrip, 12 stills at 240 px 510 stills a second against 57 for 1080p H.264, and 9× to 11× more across the rows. Ours runs in one process; ffmpeg runs 12 processes (-noaccurate_seek), 8 at a time.
Paired bars, milliseconds, lower is better, pito-codecs 1.6.0 against 1.4.2. On the card: H.264 1080p 34.7 against 51.3, 1440p 39.6 against 51.9; HEVC 1080p 30.1 against 44.2, 1440p 30.2 against 49.4. On the processor: H.264 1080p 46.7 against 52.4, 1440p 63.0 against 75.7; HEVC 1080p 34.4 against 44.1, 1440p 47.9 against 70.9.
Open and first frame 10.5 s in, 1.6.0 against 1.4.2 A seek skips the pictures nothing refers to, with every shown frame unchanged: 30 to 40 ms on the card, 34 to 63 ms on the processor. Median of five A/B runs, load about 7.
Paired bars, frames per second, higher is better, all threads. 1440p to 1080p 3429 against ffmpeg's 1870; 1440p to 720p 3907 against 2121; 1080p to 720p 5489 against 2624; 1080p to 1440p 4124 against 2547.
Scaling, bicubic 1.6× to 2.1× faster than ffmpeg's swscale on all threads.

Cut and export

Paired bars, times real time, higher is better. 1080p: pito-codecs 16.5×, ffmpeg re-encode 9.9×, ffmpeg stream copy 78.6×. 1440p: 11.07×, 5.67×, 67.4×. Ours and the re-encode are frame-accurate; a stream copy encodes nothing and cuts only on keyframes.
Smart-cut export, 3 cuts Frame-accurate and 1.7× to 2.0× faster than ffmpeg re-encoding every frame. ffmpeg's stream copy is faster still, but it encodes nothing and can only cut on keyframes.
Paired bars, seconds, lower is better, on the card against CPU decode and blend. Wall time: 1920x804 130 s with a mark 10.16 against 12.8; with captions 10.06 against 12.97; 1080p 30 s with a mark 2.85 against 3.08. CPU time: 1.9 against 43.6; 2.4 against 44.3; 0.5 against 10.2.
Export with an overlay, H.264 Blended on the card into the encoder's input: 1.9 s of CPU time against 43.6 s for a 130 s file with a corner mark. Both encode on the GPU; one run each, load about 90.
Paired bars, seconds, lower is better. 120 s of 1920x804 VP9 exported to H.264: corner mark 6.4 s on the card against 24.1 s on the CPU; karaoke captions 6.4 s against 33.9 s.
Export a VP9 source with an overlay 120 s of 1920x804 VP9 to H.264: 6.4 s on the card, against 24.1 s with a corner mark and 33.9 s with captions decoded, blended and encoded on the CPU. One run each, back to back, load 17 to 22.
Paired bars, seconds for 30 s of 1080p30 H.264, lower is better, pcod against pconv 1.0.1. MP4 fast on the GPU 2.25 against 2.79, 1.2× faster; MP4 balanced 7.33 against 5.71, 1.3× slower; MP4 best 12.30 against 8.62, 1.4× slower; WebM 19.90 against 22.20, 1.1× faster; GIF 4.88 against 17.40, 3.6× faster; WebP 6.30 against 8.18, 1.3× faster.
pcod against pconv, the converter it replaced The GIF is 3.6× faster at the same size. On the CPU, pcod's H.264 runs slower than x264 and spends more bytes for more quality on this clip. pconv 1.0.1 is ffmpeg 9.0.1 with x264, libvpx and libwebp. Medians of three, load 22 to 46.

On the card

Paired bars, frames per second, higher is better. H.264 1080p on the GPU 1154 against ffmpeg's 1116, read back 879 against 709; 1440p 1082 against 1036, read back 539 against 478. HEVC 1080p 1121 against 1081, read back 806 against 684; 1440p 1054 against 1068, read back 477 against 435.
GPU decode through VA-API Bit-exact with ffmpeg; 1.1× to 1.2× faster when frames are read back, level when they stay on the card.
Paired bars, frames per second, higher is better. Encode at QP 23: H.264 1080p 648 against ffmpeg's 560; HEVC 1080p 836 against 702; H.264 1440p 411 against 369; HEVC 1440p 548 against 480. Transcode with frames on the GPU: H.264 1440p 314 against 303; HEVC 1440p 385 against 374.
GPU encode and transcode through VA-API Encodes 1.1× to 1.2× faster than ffmpeg's at the same settings, and a transcode keeps every frame on the card.
Paired bars, times real time, higher is better. AAC decode 1010 against ffmpeg's 1703; AAC encode at 128 kbps 231 against 133; EBU R128 loudness 3276 against 544.
Audio, 48 kHz stereo EBU R128 loudness 6.0× and AAC encode 1.7× faster than ffmpeg; ffmpeg's AAC decoder is 1.7× faster.

Where ffmpeg still wins

Paired bars, frames per second, higher is better. H.264 1080p one thread 384 against ffmpeg's 586, all threads 2018 against 2613; 1440p one thread 221 against 332, all threads 1230 against 1667. HEVC 1080p one thread 468 against 450, all threads 1653 against 1803; 1440p one thread 269 against 252, all threads 832 against 1294.
CPU decode ffmpeg's hand-written assembly still decodes H.264 1.3× to 1.5× faster; HEVC on one thread is level to 1.1× faster here.
Paired bars, frames per second at CRF 23, higher is better. 1080p: pito-codecs 212, libx264 medium 354, libx264 veryfast 664. 1440p: 137, 167, 292.
CPU H.264 encode against libx264 libx264 is hand-written assembly and runs 1.2× to 3.1× faster; this encoder has no hand-written SIMD.

Every row of the run

All 49 jobs of the 2026-10-15 run, as pito-codecs' README lists them, the slower ones kept.

Job pito-codecs ffmpeg pito-codecs is
H.264 1080p decode, CPU, 1 thread 384 fps 586 fps 1.5× slower
H.264 1080p decode, CPU, all threads 2018 fps 2613 fps 1.3× slower
HEVC 1080p decode, CPU, 1 thread 468 fps 450 fps about the same
HEVC 1080p decode, CPU, all threads 1653 fps 1803 fps 1.1× slower
H.264 1440p decode, CPU, 1 thread 221 fps 332 fps 1.5× slower
H.264 1440p decode, CPU, all threads 1230 fps 1667 fps 1.4× slower
HEVC 1440p decode, CPU, 1 thread 269 fps 252 fps 1.1× faster
HEVC 1440p decode, CPU, all threads 832 fps 1294 fps 1.6× slower
H.264 1080p decode, VA-API, frames stay on the GPU 1154 fps 1116 fps about the same
H.264 1080p decode, VA-API, frames read back 879 fps 709 fps 1.2× faster
HEVC 1080p decode, VA-API, frames stay on the GPU 1121 fps 1081 fps about the same
HEVC 1080p decode, VA-API, frames read back 806 fps 684 fps 1.2× faster
H.264 1440p decode, VA-API, frames stay on the GPU 1082 fps 1036 fps about the same
H.264 1440p decode, VA-API, frames read back 539 fps 478 fps 1.1× faster
HEVC 1440p decode, VA-API, frames stay on the GPU 1054 fps 1068 fps about the same
HEVC 1440p decode, VA-API, frames read back 477 fps 435 fps 1.1× faster
H.264 1080p encode, CPU, CRF 23, against libx264 medium * 212 fps 354 fps 1.7× slower
H.264 1080p encode, CPU, CRF 23, against libx264 veryfast * 215 fps 664 fps 3.1× slower
H.264 1080p encode, VA-API, QP 23 648 fps 560 fps 1.2× faster
HEVC 1080p encode, VA-API, QP 23 836 fps 702 fps 1.2× faster
H.264 1440p encode, CPU, CRF 23, against libx264 medium * 137 fps 167 fps 1.2× slower
H.264 1440p encode, CPU, CRF 23, against libx264 veryfast * 139 fps 292 fps 2.1× slower
H.264 1440p encode, VA-API, QP 23 411 fps 369 fps 1.1× faster
HEVC 1440p encode, VA-API, QP 23 548 fps 480 fps 1.1× faster
H.264 1440p GPU transcode, frames stay on the GPU 314 fps 303 fps about the same
HEVC 1440p GPU transcode, frames stay on the GPU 385 fps 374 fps about the same
H.264 1440p time to first frame, CPU (ffmpeg includes starting its process) 4.2 ms 85.2 ms 20.2× faster
H.264 1440p time to first frame, GPU (ffmpeg includes starting its process) 3.5 ms 87.4 ms 24.9× faster
HEVC 1440p time to first frame, CPU (ffmpeg includes starting its process) 7.4 ms 88.9 ms 12.1× faster
HEVC 1440p time to first frame, GPU (ffmpeg includes starting its process) 3.2 ms 88.9 ms 28.2× faster
H.264 1080p filmstrip, 12 stills at 240 px, CPU 510 stills/s 57 stills/s 9.0× faster
H.264 1080p filmstrip, 12 stills at 240 px, GPU first 507 stills/s 57 stills/s 8.9× faster
H.264 1440p filmstrip, 12 stills at 240 px, CPU 332 stills/s 39 stills/s 8.5× faster
H.264 1440p filmstrip, 12 stills at 240 px, GPU first 340 stills/s 39 stills/s 8.7× faster
HEVC 1080p filmstrip, 12 stills at 240 px, CPU 486 stills/s 51 stills/s 9.5× faster
HEVC 1080p filmstrip, 12 stills at 240 px, GPU first 470 stills/s 50 stills/s 9.4× faster
HEVC 1440p filmstrip, 12 stills at 240 px, CPU 360 stills/s 33 stills/s 10.9× faster
HEVC 1440p filmstrip, 12 stills at 240 px, GPU first 369 stills/s 33 stills/s 11.1× faster
Smart-cut export 1080p, 3 cuts, against ffmpeg re-encoding every frame (both frame-accurate) † 16.5× real time 9.9× real time 1.7× faster
Smart-cut export 1080p, 3 cuts, against ffmpeg's stream copy (keyframe cuts only, not frame-accurate) † 16.5× real time 78.6× real time 4.8× slower
Smart-cut export 1440p, 3 cuts, against ffmpeg re-encoding every frame (both frame-accurate) † 11.1× real time 5.7× real time 2.0× faster
Smart-cut export 1440p, 3 cuts, against ffmpeg's stream copy (keyframe cuts only, not frame-accurate) † 11.1× real time 67.4× real time 6.1× slower
Scale 1440p to 1080p, bicubic 3429 fps 1870 fps 1.8× faster
Scale 1440p to 720p, bicubic 3907 fps 2121 fps 1.8× faster
Scale 1080p to 720p, bicubic 5489 fps 2624 fps 2.1× faster
Scale 1080p to 1440p, bicubic 4124 fps 2547 fps 1.6× faster
AAC decode, 48 kHz stereo 1010× real time 1703× real time 1.7× slower
AAC encode, 128 kbps stereo 231× real time 133× real time 1.7× faster
EBU R128 loudness, 48 kHz stereo 3276× real time 544× real time 6.0× faster

* libx264 is hand-written assembly; pito-codecs' CPU H.264 encoder has no hand-written SIMD. † The export copies the middle of each piece and re-encodes only around each cut, so it is frame-accurate; a stream copy encodes nothing and cuts only on keyframes.

How it was measured

Against ffmpeg: one run of examples/bench.rs on 2026-10-15 at commit 743f2d0, each job back to back with the system ffmpeg on the same file, on an AMD Ryzen 9 9950X (16 cores) and an AMD Radeon RX 9060 XT on Mesa 26.2.2 radeonsi through VA-API, Linux, ffmpeg 9.0.1. The input is 20 s of NASA's public-domain "A Message of Resilience from the International Space Station" (720p60), scaled to 1080p and 1440p and encoded with libx264 at CRF 20 and libx265 at CRF 23. The card was the bench's alone, and the load average was 1.4 at the start and 7.1 at the end, on 32 threads.

The two overlay charts were each measured once, back to back against the baseline named, on the same machine while it was busy with other work, at the load given beside each: their absolute numbers are floors and their ratios same-run comparisons. The seek chart ran 1.6.0 and 1.4.2 alternately, A B A B, five runs each after one warm-up, medians taken. The converter rows are medians of three, run in turn, at load 22 to 46.

Every command, input and load is in pito-codecs' README at v1.16.3.

Read it. Run it. It's MIT.

Download pito-codecs 1.16.3 Linux, Windows and macOS Get it on GitHub github.com/gmrdad82/pito-codecs Read the docs docs.pitomd.com/pito-codecs

The code is MIT licensed, © Catalin Ilinca: read it, fork it, ship it in your own work. Its name and logos, and PITO MD's, are © Catalin Ilinca, all rights reserved, and are not covered by the MIT licence.

Credits

The charts are drawn by pito-compare from pito-codecs' data files and from numbers its README states.

Set in Archivo by Omnibus-Type and Atkinson Hyperlegible Mono by the Braille Institute, both under the SIL Open Font License.