JPEG XL

From 2019 but quite interesting

https://www.cambridge.org/core/services/aop-cambridge-core/content/view/5972E00494363BE37E3439FAE382DB10/S2048770320000025a.pdf/an-overview-of-coding-tools-in-av1-the-first-video-codec-from-the-alliance-for-open-media.pdf

I'm in the process of writing something like that but for jxl and with a lot more detail — it will probably be 50-60 pages by the time I'm done. It will take a while 🙂

I've just been playing around with avif(enc) and tune=ssimulacra2 and it's really insanely good at lower quality like q=30 for comics but keeps the lines mostly intact and pretty

Is there a way to "simply" add the ssimulacra2 image metric tune to libjxl to get an improvement for lower bitrates?

So my fork of the fork is "SVT-AV1 super-placebo" **The most overpower AV1 encoder in the world** (of the free ones) source code and ffmpeg executive file for linux (with AVX512 support) Changes: —The size of the motion search window has been hardcoded up to 512x256, making the perfect calculation of shifts when encoding first-person games and everything that is possible. —Expanded the search areas for all other things like straight lines and division into sub-blocks. —Compression of dark areas now depends on the average brightness of the frame, so now sooo dark frames will not fall apart as before. —The number of iterations for color prediction has been increased from 2 to 32 (there were no changes in the frame by a pixel after 22-25 iterations, but I did a little more for placebo). —For compression parameters 1 and below, the wm_level (Warped Motion level) function is disabled due to the super complexity of encoding, the output video contains an incredible amount of micro-movements and the division of blocks into sub-blocks. Which causes the decoding speed to drop 2-3 times when using wm_level. Which is critical in the absence of hardware decoding. Now there is no such problem. —The size of the largest block was changed to 64x64, since I was making adjustments for compression in resolutions from 640x360 to 1280x720. It is possible to use it for 1080p, but not higher. —Look for other minor changes in the file .\Source\Lib\Encoder\Codec\EncModeConfig.c by entering DZgas into the search The fork is not intended for compression at parameters lower than 7 and is not intended for streaming. The actual speed of the parameters of this fork and the parameters of a conventional encoder is about 2-3 times lower.

<:Stonks:806137886726553651> I actually made it to compress how my streamer plays minecraft and what would it be 600-700 kbit for 720p -- But I also tested it on fragments of movies and cartoons, it looks good, the best of all. better than SVT-AV1 (-1) and better than AOM. But the compression rate is literally weeks. Literally the AV1 stndard limit. Like x264 tesa me=256

minecraft ```ruby ./ffmpeg-placebo -i M_1-3.mkv -vf "fps=60,scale=1280:720:flags=spline+full_chroma_inp" -c:a libopus-b:a 96k -apply_phase_inv 0 -frame_duration 60 -vbr on -c:v libsvtav1 -crf 63 -g 600 -preset 4 -svtav1-params lookahead=120:tune=2:scm=1:irefresh-type=2:enable-cdef=1:enable-dlf=0:enable-mfmv=1:enable-qm=0:enable-restoration=0:enable-tf=0:enable-tpl-la=1:fast-decode=0:enable-dg=1:startup-mg-size=4:tile-columns=0:tile-rows=0:enable-variance-boost=1:variance-octile=1:variance-boost-strength=4 M1HP_1-3.mkv ```

Probably yeah. https://discord.com/channels/794206087879852103/805176455658733570/1300874895692927016

Well, they were both written completely separately from the ground up and don't share any code in common.

libaom and libjxl have no shared lineage

That being said similar improvements and optimizations are possible and libjxl barely scratches the surface of efficient and effective use of lossy jxl

Perhaps https://discord.com/channels/794206087879852103/805176455658733570/1300876428186747012

it turns out that XnView does not want to play apng if it is uncompressed <:SadCheems:890866831047417898>

Well I only have a very naive idea of how all this works. Maybe a "Tuner" is just a class and you can just create a subclass called "SSimulacra2Tuner" and then instantiate and plug it in haha

I wonder when we'll be able to train a generative ai model on various image codecs and coding tools and generate an code version for a codec, then test against errors, profile and tune automatically for various image metrics and subjective test evaluation data... people smarter than me must be working on this

And then the ultimate image format would be like a container with a torrent / IPF hash for the codec code that can be downloaded and run sandboxed.

Like a dictionary you download to decompress a text document. Or a font file for a web page. Or a visual dictionary that can generate visual elements (like text glyphs or speech bubbles)

This will never be. Machine learning is not a miracle worker.

This on the other hand already exists kinda

https://en.m.wikipedia.org/wiki/ZPAQ

> To preserve forward and backward compatibility between versions as the compression algorithm is improved, it stores the decompression algorithm in the archive.

Yeah zpaq was what I was thinking of. Basically defines a sandbox you could write new extensible codecs for

In order for machine learning to be applied to a problem it has to be fit into a harness where it's able to optimize a specific and well defined problem

"General purpose" ai designed to "improvise" without any prior training like an LLM is just a random number generator that predicts the most plausible-sounding continuation of random nonsense

Saying completely made up nonsense as if it were fact, impressing a lot of people at a superficial level

Yeah I know we're not there, but I imagine in the coming decades we'll see more progress

BTW "the most plausible-sounding continuation of random nonsense" would be a good title for a philosophy book about the current state of human civilization

It does sound a lot like human social structure, yep

It isn't miraculous. It can only optimize well defined problems that you can build a well designed ML harness for

It will never be good at solving problems outside of its scope

That's the nature of ML

And in order to "learn" a new skill you need a lot of man hours and expensive hardware and electricity to create the ML harness and run the trillions of simulations with high quality test data!

These are innate limitations that will never be overcome

Everything needs to be perfect, and it's very expensive

And requires a lot of human work

Yeah sorry I don't know much about ML either 🙂 I was wondering if image coding tools could be modularized and more easily combined and generated as a more simple programming language to train on. But that is probably very naive, and the compression techniques are at the upper end of intelligence and creativity to use and come up with

If all those ingredients are there, then you get an AI that works like "magic" - otherwise you get a useless random nonsense generator

Well, the problem here actually, is assuming that there are standard modular interfaces for programmers to use

There aren't and so different teams of programmers reinvent the wheel every time

Oh? I thought object oriented programming had solved all that! 😉

That's what it's supposed to solve but in reality everyone defines their own completely unique classes with completely unique interfaces that can't be plugged into a separate project made by a different team of people

Object oriented programming is just an abstraction that marketing-savvy businessmen with no programming experience somehow tricked the world into wasting a ton of time with.

Because for some reason that was a bullet point when trying to sell Java to people and it was sold as some incredible new modern programming panacea

Yeah I was making fun of that /programmerhumor

Well I was also responding to this here too

People still don't have any standardized and modularized interfaces and code is usually very monolithic and not designed in pluggable modules

That's why I prefer simple procedural programming these days, it's at least easier to read and doesn't generate 200% boilerplate and overhead

Everyone has to pretty much reinvent the wheel from scratch every time they do anything because modular code is not common and not what most programmers think of when starting a project

Yep. Way faster to do_something() rather than to define a class first and a useless interface that will never be re-used, just so I can do_thesame.thing()

OOP is definitely an interesting fallacy or trap many people fell into thinking it would lead to significantly better software design

The fundamental problem is that writing code is fun, but reading other people's code isn't

It's good when a programming language makes it easier to keep code organized and segregated but it should be unobtrusive and obvious, not waste developer time and mental headspace

There's nothing wrong in theory with oo design, if it's used in situations where it makes sense and is obvious. Not artificially shoehorned into places where it's not natural

plan9 and the 9p filesystem is a pretty good example of simple and obvious oo design

Everything is a ~~object~~ file

And message passing is just reading and writing to files

It saves a lot of time since all you have to know is how to read and write to files on a filesystem

And that's the standard IPC mechanism

It even replaces dynamic linking with file based ipc

NuShell and Powershell have an interesting new programming paradigm variation with the pipeline operator. It has a better reading order compared to functional programming, is compact / saves overhead not needing so use so many temp variables

But this is really getting off-topic 😄

Just uploaded a photo to Discord from my phone, sat down at my computer and noticed the dark areas had random colors like WebP sometimes does. Check the link to the file, and it got uploaded as a 12MP, quality 40, Baseline JPEG.... You would've thought they'd just resize it at least instead of ruining the quality

when I upload to Discord, I use my script that bisects the highest JPEG quality that yields a result below a given size (10MB for Discord)

Discord still ruins the preview, though

Do you have many JPEG that aren't already under 10MB? Or do you mean uploading arbitrary images

I mean photos I’ve taken, where I start from a processed raw file that I export losslessly to TIFF

but yeah, it’s not uncommon for the script to pick a quality close to 100 in the end, or sometimes even 100

it seems that taking the photos with a dedicated camera helps in that regard, because (1) less noise (although this depends on the situation and on how much noise reduction is applied) and (2) potentially blurrier backgrounds that are easier to compress

Riiight, using jpegli? Because I know we found that disabling AQ actually helps at the high qualities you're hitting

For those using KDE Plasma, you can create a custom service menu for dolphin to i.e. use cjpegli, targeting the 10MB file size limit

actually often just imagemagick (so libjpeg-turbo), but I don’t remember exactly why (reading TIFFs might have had to do with it)

(maybe also the corresponding EXIF and XMP data)

Was just thinking about squeezing in the extra bits from the camera into the JPEG ;P

But either way, good enough for looking at Discord, with the scuffed previews anyhow

Which reminds me, I need to try and process my RAWs from Spain sometime...

Is anyone watching them?

Experimental (failed)

how would it work? based on vp9?

it's its own thing, even contains a lot of compression tools borrowed from AV1

indeed, it would be better if it were just vp9. because the main webp advantage now is the compression speed and decoding speed

webp2 doesn't do anything better, not like webp or avif

WebP2 is to WebP and AVIF like JPEG XR is to JPEG and JPEG 2000: its goal is to be somewhere in between two existing formats in terms of speed and compression.

(JPEG XR ended up being worse than both)

WebP2 is roughly speaking, the AVM of image codecs

I don't think they intend to cut a V1.0 out of WebP2 though

> WebP 2 is an experimental image codec based on WebP. WebP 2 will not be released as an image format but is used as a playground for image compression experiments.

So basically it’s instantly obsolete, by design?

In my opinion, yes, trying to be a trade-off between two things that already exist is a niche that is generally too small to get substantial traction. Which I guess is why they decided it is just a "playground" now.

webp is an uncompromising hardline replacement for jpeg in all standard cases, except for 4:4:4 or when the quality need is higher than webp q100. The identical decoding speed, which nowadays works perfectly with now era large monitors. Indeed, I think that if them were to make an alternative for AVIF, then they should have made webp2 as a codec with a decoding speed identical to jpeg 1992. And in the current implementation, this is an almost useless codec for nothing. In addition to webp, which surpasses jpeg only in technology, there are other similar examples. AAC/VORBIS - MP3 Zstandard - Deflate

It's especially funny how the Linux community abandoned the most powerful household algorithm LZMA just to reduce the unpacking time if Zstd. It's scary to imagine how many terabytes the package database has become up

Oh LZMA, my favourite!

`7z a -m0=lzma2 -mx9 -mmt6 -mfb273 -md128m -r -t7z` DO BRRRR

My favourite version was liblzma 5.6.1

💀 wait

https://www.openwall.com/lists/oss-security/2024/03/29/4

> webp is an uncompromising hardline replacement for jpeg in all standard cases except for 4:4:4 or when the quality need is higher than webp q100. Not to mention the forced TV range (16-235), the smaller maximum image dimensions (WebP's 16K vs Jpeg's 65K), and ~~complete lack of progressive decoding~~ only scan line decoding.

If you don't care about any of those downsides then yes, WebP is objectively better than jpeg

WebP has block-linear decoding during download. This is already better than AVIF and in this case JPEG XL - because jxl decoder does not support block linear display at the moment. But yes, it supports real progressive decoding

at resolutions like 250x250, webp also shows better results than jpeg and also jpeg xl in some cases. At the moment, this is due to the fact that JPEG XL still does not work with blocks smaller than 8x8 which artifacts of lack of advantage

I forgot WebP had scan line decoding, still isn't comparable to JPEG's proper progressive mode though

You gave me an idea. Currently libjxl isn't doing lqip decoding, for some reason, and cjxl is putting LfGlobal at the end of the file instead of the start... Could we decode the HF groups onto a plain background like Jon described for damaged files missing an LF group? Then you at least get the texture before the color, instead of nothing until the end

so LfGlobal is going right at the end of the file, why ??

TL;DR: Chunked encoding https://github.com/libjxl/libjxl/issues/3823

is it possible to cache the output before writing?

as in like buffer it in memory then write everything at the end

So I got the names a bit mixed up but yeah, that's what I said in my comment

Since streamed output is only with a flag anyway

Actually, I wonder if <@810102077895344159> has been subject to this on The Guardian without realising, asuuming they use progressive

im gonna test that

here's a random JXL

so its ``` LfGlobal LfGroup(0) GroupPass ... GroupPass LfGroup(1) GroupPass ... GroupPass ... LfGroup(n) GroupPass ... GroupPass HfGlobal ```

im guessing HfGlobal is required to decode the GroupPasses?

yep

Huh, I could've sworn it didn't show anything for me, but maybe I'm thinking of my lqip tests...

it seems to load all the 1:8 group-by-group and then everything loads

wait doesn't it already have to buffer the output to write the TOC?

or does the TOC go at the end

It's at the beginning

How does libjxl write it then?

Either the output file is seekable, or maybe, gotta double check if the spec allows the toc to be missing or at the end, but if it's at the end it's essentially as useless as not having one at all.

I don't know. It's meant to be at the beginning though otherwise it serves no purpose

I’m guessing file is being seeked like how formats like FLAC write TOCs

It goes FrameHeader, TOC, LfGlobal

Yes, TOC is just after frameheader and before any of the data sections.

```c codec | decode speed JPEG 4:2:0 x 1 TIFF raw x 1.4 GIF x 2.9 AVC key 420 x 3.0 WEBP lossy x 3.2 HEVC key 420 x 3.3 BMP x 6.3 JPEG 2000 x 7.5 VP9 key 420 x 8.4 AVIF 4:2:0 x 11 PNG x 12 WEBP loseless x 20 JPEG XL lossy x 26 JPEG XL loseless x 66 ```

for which image? or is it a dataset?

how did you test the decode speed?

meh

I run ffmpeg decoding 20 times in a row, I get the average decoding time python subprosess ffmpeg -i IN -f null

Single-threaded ?

with 4 threads, jxl in one thread was 30% worse. at the same time nothing else codec has changed in speed. so it the multithread test

that is, technically, multithreaded (keyframe) decoding in ffmpeg has only jpeg xl

I understand that the video is decoded multithreaded because there is not only a keyframe. but They didn't give a damn on all other image codecs. still FFMPEG is an acceptable encoder

Is there any *usable* tool to find looping portions in videos to be turned into GIF, APNG, AVIF, JXL, ect? Got some friends who have 'looping' videos that have some extra frames that mess it up, but I don't want to have to pixel peep every one to find the correct point, and any existing tools are either proof of concept or dead links on websites

are the frames at the beginning and end?

it's really difficult if you need to remove a frame from the middle without recoding. at the moment, it can only be jxl due to the lack of frame dependency. apng is possible, but I'm not sure. gif is also possible, but I'm not sure either. There are no such tools. you'll have to program them according to the documentation

Notably absent: rgb avif, 4:4:4 avif, lossless avif (lmao)

6 years ago it was the best codec..... I don't use it anywhere right now... even Google uses webp and not avif

Which image viewers for Windows (not counting video players) support playing animated HEIF files? https://forum.doom9.org/showthread.php?t=185875

I have bad news for you, only (some) video players can open animated HEIF files. Not really surprising when you shove an entire video in a image format. No known image viewer can play animated HEIF files.

Well it's just an mp4 video file with specific layout and metadata

Pretending to be its own format

Same with avif

Avif is also just mp4

Also known as isobmf or whatever

Also known as quicktime mov

A horrible horrible hack you can do to get HEIF files to play on windows is to rename the .heif extension to .mp4. If you have the windows HEVC addon installed, it will decode and play in the windows media player (which is still a video player). 💀 <:tfw:843857104439607327>

Or .mov

.mov is what it was originally called and known as so if you want to be extremely pedantically correct we should all just call it .mov

Wow, renaming .heif to .mov actually gets it to play in the default windows image viewer

Don't bother remuxing HEVC to HEIF, just remux the .mp4/.mkv to .mov and it will play in any image viewer that supports decoding h265 payloads. `ffmpeg -i inputVideo.mkv -c copy -an outputVideo.mov`

Moral of the story, stay far far away from HEIF, it sucks

this stuff works with a large number of applications, the same thing with avif before wide spread support

Should be. I imagine it's a "simple" case of comparing frames and finding the points with a minimum difference between each other, but it'd be slow

The joys of renaming every video to mp4 in hopes that it suddenly worked on my old Android phone

mpv-android [av1_chad](https://cdn.discordapp.com/emojis/862625638238257183.webp?size=48&name=av1_chad)

I didn't quite get it. Are you talking about skipping similar frames?

No, imagine someone creates a looping animation, but when rendering it they don't set the duration correctly, so it loops 1.5x times and abruptly stops, ect. You could find the identical start frame and 1x loop frame that match, and remove the excess

Or in a video to make loop, search a duration for the most similar frames to crop to

and... so it's easy to do it through ffmpeg cropping use -c copy

Would be interested in such a thing too For something more crazy, but sorta similar this oldie (Windows only) is still working well. I never found anything similarly good (would love to be proved wrong!): https://hhoppe.com/proj/videoloops/

It's not one of the other older techniques I had seen before, but ouch... > Also, creating new video loops requires 8 GB of memory.

After asking around and receiving many different answers, I been wondering if AVIF is really an image or just a AV1 video. So, which is it, an image or a video format?

both

they are not exclusive

a video is just a series of images

AVIF is AV1, there's nothing really image specific for it

its a single frame of AV1 video

packed in the High Efficiency Image File Format

(same one used by Apple and HEIC)

Also known as .mov

Also .jxl is an extension of .mov too

But not like heif

Heif is closer to an actual traditional .mov file

Also only some .jxl files are .mov files

Some are raw containerless files

technically ISOBMFF files, so .jxl and .mov are more like siblings

In theory HEIF can use any video codec, including MPEG1, MPEG2, XviD, VC1, AVC etc.

Isobmff is just a .mov

Huh, so my ProRes Image Format idea isn’t off the table?

Yeah, I thought why wouldn't they ditch lossless AV1 and use FFV1 instead.

a bit late but moviepy has this: https://zulko.github.io/moviepy/reference/reference/moviepy.video.tools.cuts.FramesMatches.html

if you want to keep the resizing with the example given there, `.resize(width=200)` has to be changed to `.resized(width=200)`

apparently ffv1 isn't actually that great in my experience

lossless x264 or x265 has great performance.

ffv1 is mostly used/intended for proper archival after all

I wonder how this https://github.com/dropbox/avrecode compares to ffv1 🤔

That's not the same thing

avrecode is like JPEG transcoding to JXL, ffv1 is just another video codec for lossless

x265 lossless is quite bad, ffv1 beats x264 only on noisy content where not much inter frame compression is possible

I know I still wonder how good it compares <:KekDog:805390049033191445>

but rn my drive is full <:SadOrange:806131742636507177>

I'm at 160 GB free myself

just because REDacted was freeleech last w-e, so I took what I could lol

what do you guys do to get max png compression?

Max within reason, or absolute max?

Max without waiting forever

like what software and params i guess or other tricks

or would it not matter if i convert to webp in the end

Just do `oxipng -Z --fast`. With option `-s` to strip non-essential metadata.

Sometimes I do `ect -30035` afterwards to get it even smaller.

how do i do that ect thing?

https://github.com/fhanau/Efficient-Compression-Tool

Worse than x264?

I thought it had slightly better compression in lossless mode

And ffv1 was left in the dust in both speed and compression ratio

x265 is always worse than x264 in lossless mode. Maybe because it doesn't have a dedicated lossless profile and thus compromises were made to not unnecessarily increase decoding complexity for hardware decoders? Idk.

x265 is always worse than x264 ✅

<:feelsbanman:1075509898512707665>

Alright thanks guys. It don't go more compressed though so it's joever for lossless

WebP actually has a pretty good lossless mode

And JXL does almost as well in a lot less time and memory

🎀 <:jxl:1300131149867126814> jxl is best for loseless works in 2025

Would love to use jxl instead but browsers moment

`cwebp -z 9` for highest lossless compression

you are forgetting `-alpha_filter best`. also something not related to compression strength that should probably be used as well is `-mt` and `-metadata icc`

still crazy to me that `-metadata` defaults to `none`

I wonder if `-alpha_filter best` is implicitly turned on at `-z 9`

I haven't checked but I kinda doubt it

I'll do some testing when I get the time

But z9 isn’t always best for WebP lossless, ideally you want to brute force all of the effort levels

z9 is a sane best option

You could go completely crazy and brute force all -q and -m options

Not that I'm speaking from experience or anything haha 😅

tbh I never managed to compress better with `-q` & `-m` bruteforce than `-z` bruteforce tested on a few dozens files

perhaps I was just "unlucky"

Somehow i didnt think that the very HD cat picture in that screenshot wouldnt compress to 300kb

this is what im doing btw https://github.com/catppuccin/simplex/pull/11

the individual images for the theme flavors are ok in size in now, but the preview combining them in a grid is like 70% bigger than the one in the repo originally

going through `oxipng --opt 6 --fast` didnt matter before doing `cwebp -lossless -m 6 -z 9 -alpha_filter best -mt -metadata icc -progress preview.webp -o preview.webp`

and i did try before with `oxipng -Z --fast` and that was quite not fun and did not get meaningful results

cwebp is from brew if that matters

Reading the Valve game compositor PR where they added AVIF and it hurts ```// We are not actually using YUV, but storing raw GBR (yes not RGB) data // This does not compress as well, but is always lossless! pEncoder->quality = AVIF_QUALITY_LOSSLESS; pEncoder->qualityAlpha = AVIF_QUALITY_LOSSLESS; pEncoder->speed = AVIF_SPEED_FASTEST;``` https://github.com/ValveSoftware/gamescope/pull/1068/files#diff-452db373032f99b8c4bd2ed8b40bbd2bab7bed63bf8c51714acc025ea9b6200fR3190

Why would they bother to add AVIF if it is restricted to lossless. 😕 If lossless compression is the main goal, there are better image formats for that.

WebP lossless and (oxi)PNG quite often work better 💀

AVIF is also a slow codec (at least libaom). I had to use several tricks to improve the UI responsiveness in my Paint.NET AVIF plugin.

https://github.com/ValveSoftware/gamescope/issues/1525

I don't use gamescope it is an incredibly buggy and poorly designed peice if software

I assume it may be due to the fact that Valve wanted 10 bit due to the HDR capabilities of gamescope. WebP and PNG do not support 10 bit

They shouldve started with jpegli. Their existing jpg encoder generates screenshots of ludicrously bad quality in the first place

I dont try to understand why they choose to do the stuff they do

Like png, avif seems to just be an additional format exported to and not the primary screenshot generated

Export to jxl similarly should be just as straightforward

but you can easily fit 10 bit data into a 16 bit png either properly (via multiplication) or slightly wrong for better compression (via bit shifting)

and if you add an `sBIT` chunk, it can be interpreted as 10 bit data by applications that support it (though the only one i'm aware of is `cjxl`)

I mean technically, someone should be able to make a PR swapping AVIF for JXL, or changing the jpeg to jpegli *cough cough the abi compatible library*

??

Is it?

yeah, people are constantly hitting bugs with it that often times don't get fixed, regressions are common, key combos to control gamescope when nested are all *super+key* combos etc.

iirc, the coreutils devs added rm --no-preserve-root option because of valve doing rm -rf / in one of Steam's bash scripts

Specifically in response to valve

They aren't exactly known for their coding proficiency. The Steam client is an ugly, resource hungry electron app

But gamescope always seemed like a clever idea...

Emulating a virtual monitor so it can't screw with the rest of your session, or get screwed

Reducing latency somehow too

As an avid paint.net user I'm interested, you mind sharing some of the tricks you used?

https://0xc0000054.github.io/pdn-avif/using-image-grids.html

That technique breaks AVIF rendering in Firefox, but only because Mozilla has had [image grid support](<https://bugzilla.mozilla.org/show_bug.cgi?id=1696090>) on their AVIF decoder backlog for 4 years.

This is why I don't like it when functionality like tiling or orientation is left as an application responsibility, instead of being part of the codec itself.

Wondering if someone can help me with this, I *think* I've been accurate with my explanations so far, but I'd rather have someone familiar with DCT to handle these latest questions https://github.com/Beep6581/RawTherapee/issues/7125#issuecomment-2558249779

I think there might be some misunderstanding between the context of jpegli's high bitdepth output compared to just scaling it

Yeah. I think that's sometimes called a "layering violation"

Basically expecting software on one layer to do something that should be done on a different abstraction layer

It's very bad

My understanding is that going from low to high bit depth is not lossy and does not require requantizatization or dithering and adding noise is totally pointless

Huh

I think Github might've sent you to the wrong comment

Probably

https://www.rfc-editor.org/info/rfc9639

RFC 9639 Free Lossless Audio Codec (FLAC), DECEMBER 2024 PROPOSED STANDARD

what?? FLAC wasn't standardize yet ? I don't understand

the specification used to be here: https://xiph.org/flac/old_format.html

in the same way that the Vorbis specification is currently here: https://xiph.org/vorbis/doc/Vorbis_I_spec.html

[⠀](https://cdn.discordapp.com/emojis/654081052108652544.webp?size=48&name=av1_Hmmm)

what is the difference/advantage to have your specs as a RFC instead of `https://xiph.org/flac/old_format.html` ?

I thought it already was an IETF RFC

It's more official that way. So that way you know you're really real and acceptable and presentable and respectable like a vegetable.

Someone might even put an official looking stamp on it to make you feel even more safe and secure. And your fairy godmother will come to your window and assure you that you're really a real boy now

It's not enough that it's a stable standard that hasn't changed for years, or that it has good hardware/firmware support in a massive amount of popular commercial products. It's still not OFFICIAL, see. That's what ACTUALLY matters.

https://cdn.discordapp.com/emojis/872898333239279666.png?quality=lossless&name=av1_frogstudy&size=48

With that, is there any chance it might someday be used on Blu-ray discs?

Probably not, since FLAC does not support Dolby Atmos like channels IIRC. There are people working on a libre competitor to these formats, but it will very likely not be FLAC

I imagined it as a replacement for TrueHD and DTS-HD MA, not for Atmos and DTS:X.

Just like PCM is progressively being replaced (although maybe not on CDs).

I'm bothered by the fact that the standard supports variable-length blocks, which is why you can do sooooo long bruteforce on block sizes for each part of the sound. but no one has implemented it. but at least the original encoder has built-in the ability to change the length of a constant block size. this gives you an unforgettable opportunity to encode 1 track 16 thousand times with a block size from 1 to 16,000 bytes (and even more) to choose an option that compresses 0.1% better

just.

FLAC -e 11

`flaccid` my beloved <:KekDog:805390049033191445>

Made a script of Quick Action on macOS for converting images to JXR which most of people don't need. -q 15 is close to JXL's q1.0 `for f in "$@" do sips -s format tiff "$f" --out "${f%.*}.tiff" /usr/local/bin/jxrencapp -i "${f%.*}.tiff" -o "${f%.*}.jxr" -q 15 -Q 15 rm "${f%.*}.tiff" done`

You have to install jxrlib first and it doesn't support importing even PNG or JPEG

That's why I choose TIFF as a medium

No option for compression ratio and the sizes are impressively larger

For lossless JXR it can be either close to PNG or much larger

-q 15

IIRC, JXR uses floats instead of ints, and can actually be competitive with lossless JXL currently when given a float input

What a mysterious "sister format"

Is there any testing result about that?

does this count? https://discord.com/channels/794206087879852103/803645746661425173/1250101680620568727

So that's a big room for libjxl to improve

For digital artworks JXL definitely performs better

Windows 11 can still display JXR's preview and PowerToys' Peek can preview JXR as well. JXL is unsupported by both <:PepeHands:808829977608323112>

Oh here are HDR samples of JXR provided by Microsoft as well https://aka.ms/hdr-backgrounds-wip

Rate distortion optimization, whoo! Now, if only libjxl had such power...

One can dream...

hm, using ImageMagick to convert to JXL leads to a segfault every time

Converting to PNG works fine

Try using graphicsmagick then, or vips

vips cannot open the JXR file, vipsdisp cannot either. Same story for graphicsmagick. ImageMagick can convert to PNG first at least, only diectly converting JXR to JXL leads to a segfault

I tried to decode a Nvida JXR file, and even the official reference software failed to decode it

Had the same happening with some other JXR files, the reference libjxr tools don't seem to be able to handle edge(?) cases

how ironic

Especially amusing in the context of how few JXR files are out in the wild

ah, I was trying to joke about Edge

Yeah, I EDGE Educate Demographics in Graphics Expertise

Sure, I'm a GOONER Graphics-Oriented Original Novice Engineer-in-Residence

Another sample from Nvidia https://images.nvidia.com/aem-dam/Solutions/geforce/news/nvidia-app-beta-download/remnant-2-rtx-hdr-nvidia-app-ai-freestyle-filter-hdr-screenshot-download.jxr

Photos of Windows says it's a "128-bit" image

Honestly jxr seems cool in theory. It's a shame no one would ever touch it in a million years with a name like "Microsoft HD Photo"

Its association with Windows and Microsoft and JPEG was just complete and utter cringe at the time and no one wanted anything to do with that

It's getting its last light from Microsoft and Nvidia's HDR promotion

Now it works like the *de facto* standard HDR screenshot format

Even back then everyone knew JPEG looks terrible and blocky and so why anyone would want to have "JPEG" in the name seemed completely tonedeaf. Same with wanting to have "Microsoft" or "Windows" in the name of a photo standard

That combination of keywords in the name of their new format just set it up to fail

That's like trying to get the world to agree on a new standard and naming the standard "Web Pee"

The top search term for WebP: how to convert WebP to xxx

AVIF can reflect adult videos

Or naming it, I dunno, "Windows HD MP3 Premium Sound Format, Millenium Edition"

aka .wma

I've cleaned up this a lot and wow so many supports https://en.wikipedia.org/wiki/JPEG_XR#Software_support

wma sounded terrible, like all sound artifacts from all lossy formats combined, and it was an obscure and awful thing literally no one asked for when there were pre existing superior alternatives available

Vorbis wasn't perfect and was maybe slightly more memory hungry than other formats at the time, but it sounded at least on par with its competitors at the time.

But no corporation wanted to back it because they all had NIH syndrome

Monty Montgomery was a really talented guy too

fasted decode ever — use in all games — patent free — vorbis gigachad

The guy who designed vorbis

<:This:805404376658739230>

Yeah, it was great. It was really silly that no one could agree on a standard back then

MP3 was still patented, and no one could agree on a replacement. AAC-LC and Vorbis were the main contenders but I'm pretty sure AAC required licensing fees too

And AAC sounded better to me but most comparisons show them neck and neck

I watched the whole Chris Montgomery interview. It's so few views that it feels like you're watching a random video of someone noname know, there are literally a couple thousand views of his small lectures.

AAC encoders had a lot of lowpass filtering at the time that was the main reason why they sounded bad, and Vorbis artifacts were more subtle and harder for most to notice but when you notice what they sound like it annoyed me

It sounded less natural

Opus sounds scratchy whenever there is high frequency harmonics

opus win 🎀

It's a limitation with the small dct frame size in opus, it's inherently bad for preserving high frequency details...

Harpsichord music gets destroyed with opus

Like a scratched record

maybe large

Low latency = bad harpsichord

It's designed for low latency first, music second

I mean the blocks. opus also has a large bloks at very low frequencies, which is why the lows are worse at high bitrates than mp3

is this distribution chosen according to the study of the psychoacoustic model, some more, some less, like xyb jpeg

this may have been true initially, but as it was developed, it became the best of all and could replace absolutely all lossy compression codecs. in any case, and music too.

the exception remains very large bitrates, like stereo 256+ kbps, in which vorbis/aac will be better. And mp3 320.

but these are purely design features. at bitrates of 128-160 kbit, it makes no sense to use anything other than opus

<:Opus:805856410235437068>

I don't believe all the hype from people high off their own fumes. Harpsichord music still sounds obviously scratchy even after they tried to address it by increasing the bit rate when the encoder detects hf harmonics.

Believe your ears, not the press release.

Maybe I should do a head to head comparison between Opus and other lossy codecs... Listening tests are very fatiguing on the ears after a certain amount of time though

There is some public published listening tests data available comparing lossy codecs, and if you look at only the harpsichord sample, opus does really bad at that one

High frequency harmonics is not really common outside of harpsichord music

But it gets noticeably scratchy sounding with opus

You can hear it yourself on their release demo page

They tried to slightly mitigate it but it's still there

If it doesn't give consistent quality/fidelity at VBR for harpsichord music then it's not a good music codec

I know and shouldn't have written so much text. mp3 is better in this one. yes. use vorbis. although in 2025 the cost of data storage is so minimal, and the sound itself as a physical phenomenon has not changed, that you can store absolutely everything in flac

the problem is setting a priority, you're comparing opus with the best version of other. although when comparing opus 128 and mp3 128 kbps, you won't say that mp3 is better because some "special" sounds sound better

jpeg can yuv444, but that doesn't mean webp is worse

just use the bitrates for which opus was created, 96-160 kbps for music, not hider

if you want more, for any reason, use a different codec, which are designed with higher bitrates for anything but even comparing opus 320 and mp3 320 is not structurally objective

Yeah it does 😂

<:NotLikeThis:805132742819053610>

jxrlib is actually really tiny! It's way smaller than libjxl

JXR is claimed to be close to JPEG's performance and J2P's functionality

libjxl can't be small as it wants all

You could probably make a limited version of JXL like a simple profile

If code size is a problem

So some people are developing jxl-rs

... yes?

are they in the room with us now?

also what function does jxl-rs use for srgb -> linear? I noticed the pr but didnt check the code, does it uses a pure 2.2 decoding or the inverse oetf?

I didn't know the codes either

it's a rational polynomial approximation of the "real" srgb transfer curve

icic ~~time to complain about reference displays and what not~~ I can't wait till srgb dies

What's the best replacement of sRGB?

well we could just use pure gamma2.2 and pretend the other stuff doesn't exist

PQ

that or HLG

Rec.2100 can use one of them

yes, it can use both

bt.1886 is good enough, it uses a 2.4 power function, the issue is you will actually probably find more monitors that support PQ then you will bt.1886 now.

bt.1886 is only reliable for TVs

it's also fairly important to note that rec2100/rec2020 is just that, reccomendations, they aren't actual specs in and of themselves, hence I have taken to calling them "pseudo colorspaces" because while they do define white point, gamut, and transfer, they are only reccomendations, and since they define multiple transfers it muddies the water a bit

But pq and hlg encoded images always look totally whacky with ludicrously bad tone mapping

On most displays

100 nits bt.1886 in a dimly lit room is the common mastering environment

for SDR movies

although I think there is a Dolby recommendation of 160 nits for that

Yes lol...

I mean, on SDR displays. but HDR displays will look good :D

When jxl-rs is feature complete I am sure it will be a LOT smaller and simpler to read/understand than libjxl, since it's a clean room implementation, and libjxl is a merger of 2 old c++ projects that somehow ended up WAY more badly organized and chaotically jumbled up than either of them originally.

https://github.com/Traneptora/jxlatte/tree/main/java/com/traneptora/jxlatte

This is what a complete jxl decoder looks like when it's well organized and not a jumbled soaghetti mess

It doesn't need so many randomly placed files in so many confusing subfolders

nit: that's not what clean room means

Yeah, I guess that's not the appropriate use of that term... but I'm glad you figured out what I was trying to say anyways

on the other hand, if you refer to “Rec. 2020 primaries / white point”, at least that doesn’t leave much room for ambiguity – it’s these:

It's mostly what you get when using the code as a tool to design a codec, where encode/decode speed also was a major consideration, so proposed changes in the coding tools / bitstream were judged not just on compression but also on speed impact. Which often means sacrificing clarity for speed. And then a library API was retrofitted over it. And then a render pipeline architecture was retrofitted. And then streaming/chunked decode/encode.

Yeah, it's pretty difficult to keep the clutter and complexity under control throughout all that... and managing complexity probably wasn't a priority at the time either, while all that stuff was happening.

What tools can trim the length of an APNG or animated WEBP file?

ffmpeg probably can

FFmpeg can trim APNG, but still has no support for animated WebP

really odd that FFmpeg supports animated WebP encode but not decode <:kekw:808717074305122316>

And annoying, seeing as players with FFmpeg backend cannot play animated WebPs

But dwebp can't decode animated WebPs either 😅

Yep

For WEBP, try <https://developers.google.com/speed/webp/docs/webpmux>

How?

https://tenor.com/view/webp-webp-moment-png-webp-file-download-gif-27014724

Now it's the society with low- to medium-quality AVIF

still use jpeg

Honestly I really don't like the macroblocking and chroma subsampling artifacts of jpeg, but a good encoder like jpegli doesn't need to have terrible artifacts

jpegli is gorgeous

It's like comparing xvid with x264

where are digital cameras on the jpeg encoder quality spectrum

Like, DIGIC 8 or something

I suppose those chips are responsible for much more than just jpeg encoding actually

But I do wonder how much better the images from my camera would look if it used jpegli

It should depend on what quality the system sets

HEIC from iPhone shouldn't be higher than quality 90

Most phones produce 4:2:0 images, including the iPhone. IIRC the 4:2:0 subsampling should only come into effect under 90? Regarding real cameras (just a few cameras of which I have pictures at hand): - Fujifilm GFX 50S - 4:2:2, quality 97 - Sony Alpha RMIV - 4:2:2, quality 95 - Sony Alpha RMIII - 4:2:2, quality 100 - Nikon D750 - 4:2:2, quality 99 - Nokon Z6 II - 4:2:2, quality 99 - ancient Canon Powershot - 4:2:2, quality 68 - three more modern Canon cameras are around - 4:2:2, quality 95 - Nintendo 3DS lol - 4:2:2, quality 80 lol

Lol, appreciate the inclusion of the Nintendo 3DS

I sometimes stream my 3ds over wifi at jpeg quality 96. Choppy but good enough for screenshots.

What software are you using?

ntr-hr

Like twice as fast as the old ntr

Funny what the homebrew community comes up with

damn no av1 hardware encode on the 3ds

DOA

I haven't used mine in probably about 8 years

I turned my DS on again after 8 years and it still had full battery

I recently decided to get into Zelda so I'm playing the early games on emulators on my 3ds

Oh cool!

I'm really into Zelda myself as well

I mean if they did it properly, you'd have the full dynamic range ;P

Yeah good point

Canon hasn't invented anything other than 8-bit jpeg on this 2023 camera model yet, though some of their older models have it

I'm struggling to understand that message

I turned my original DS on the other week too, booted fine and then said the battry was low. No kidding when I last used it 2014

Also, fuck the 2DS... Made it a complete nightmare to find any second hand games for the original 2D-not-3D DS

I'm holding onto my red 3DS for dear life

it's such a precious console for me

It's a shame that Nintendo hates their customers. Granted, that's most companies in the video games industry nowadays, but still

I wonder how well dav1d runs on that console -- can it at least decode low fps 64p AV1 video?

yeah, at least they didn't actively pursue the 3DS modding scene like they did with the Switch, so that's something

It is totally fair that the dev of Ryujinx took the money offered by Nintendo, but it's still sad

I don't think you can really compare the quality of cameras in terms of baseline libjpeg quality levels... A lot of different things determine the quality. Like what filters are used to convert the sensor data to an RGB bitmap, and then each camera usually uses its own custom quantization matrix. You can even ID the camera by looking at the quantization matrix.

The libjpeg quality level is just an estimate if anything

While true, I personally do not care for OOC JPEGs, because I don't save JPEGs lol

I can't find any review about -near_lossless of cwebp so I tested. I found some results are underwhelming when comparing with tools like dssim and ssimulacra2

Although <@532010383041363969> recommended using it over real lossless for most use cases, I found that -near_lossless 40 is very close to d0.5 of JXL while -near_lossless 60 is slightly higher on ssimulacra2 (lower on dssim)

But the WebP files would be much larger than counterpart JXL files

I'd suggest comparing it to `--modular_lossy_palette` with JXL

What would this do?

Also JXL is just the metric in this test

WebP near_lossless works by reducing colors and removing entropy by using predicted values more. modular_lossy_palette does similar but can mix colors too

https://fixupx.com/jyzg/status/1329067794995011585?s=20

https://x.com/jyzg/status/1329078139700428813

https://x.com/jyzg/status/1329079576274763781

JXL d0.5 without `--modular_lossy_palette` is already much smaller than WebP with `-near_lossless 60 -m 6 -q 100`.

Could JXL be even smaller with it?

I'm also not sure about if near-lossless WebP is a good idea

A real review about near lossless but in Japanese https://qiita.com/yoya/items/a000c2e123d448a37f47

personally doubt it 😛

The Japanese review also clarified about lossless is not lossy unless the source file is over 8-bit

Went back home and tested. No difference with `--modular_lossy_palette`

wasn't lossy palette non functional?

So that's why no difference

Also found that WebP near lossless 60 is around at the level of JXL d0.3, not d0.5

Ah, right. I wanted to test Krita's export and check that libjxl is working and it's just cjxl that's broken

ssimulacra2 shows scores of WebP `-near_lossless 60` between Jpegli q 99 and 100, or even higher

All converted to PNG when using ssimulacra2 and dssim

The jpegli files decoded with it too?

No just simply with -q

I mean did you use `djpegli Test.jpg Test.png`

Uh I just used the same software that produced the original PNG files, to export again

Maybe I should try djpegli later

It usually scores a bit higher, sometimes up to 1 higher or more in ssimulacra2 ```jpegli q99 JPG 92.91381675 FFMPEG PNG 93.00604649 jpegli PNG 94.04023829 jpegli 16bit PNG 94.19572467```

For fairness I didn't test photographs

No matter JXL d0.3, WebP near-lossless 60, or Jpegli 100, they didn't reach 93

That was a game screenshot

game name?

Deep Rock Galactic