JPEG XL

Oh wait. I did Lemme see why it's not on the one online.

I'll make the edits to the star ratings mentioned above as well.

Before I upload it, any more discussion on the stars? I made them mathematically match the lines below, up to a 1/4 of a point.

Maybe we should add text to the right of the jpeg xl column or maybe onhover cause otherwise people might get suspicious on why JXL is the best for everything and it looks like we are just patting ourselves on the back

Not sure if what I just said makes sense hope you understand

Yes, but it's currently an SVG. Maybe that can wait until it's HTMLized?

what exactly do you mean by HTMLized? like converting it to a html table?

isn't svg already part of the html spec?

It was on the list to be converted to HTML and CSS, we just hadn't gotten around to it. I have some code started somewhere. We wanted to pin the header column and the JXL column at the left so the others could be swiped to compare.

oh like an actual table

Isn't lossless AVIF even worse than PNG?

only sometimes

jpeg2000 and png should be about the same lossless wise right?

JPEG and PNG are both equally not parallel

Like this: https://stackoverflow.com/questions/1312236/how-do-i-create-an-html-table-with-a-fixed-frozen-left-column-and-a-scrollable-b

PNG with strong (and very slow) optimisations could be smaller than lossless AVIF

I also switched AVIF to 10/12 Bit

Also isn't the HEIF container good for authoring workflows and storing multiple layers etc?

I don't know why the JXL container would be any better for authoring

HEIF stinks at lossless? I guess I could move it up one?

My own tests told me that lossless HEIC is even slightly larger than lossless AVIF

I would not be surprised if avic or whatever the avc one is, beats avif at lossless rn

the issue with avif is that aomenc keeps changing shit, not as bad as svtav1, but it does need regularly retested and rechecked what args do

We should also put a footnote about when this was done I guess…

I haven't thought about that angle. Lossless is important for authoring I guess... But can't it contain PNG layers too?

AVIF is based on MIAF which is a subset of HEIF, I'm not sure what it allows in terms of layers.

HEIF does support layers, so in that respect it's in principle good for authoring workflows. Layer support is already separately in the table as "Overlays".

For authoring workflow suitability, I was thinking more about things like "does it have a fast lossless encoder?", "can it do CMYK?", "can it store selection masks, spot color channels, etc?", "how does it handle potentially large amounts of metadata?", etc

fast probably the only one that matters because programs use their own formats anyway

so they all suck except for png

I suppose it could make sense to add TIFF to the table

oh yeah tiff is the best

tiff's qualities rely a lot on which specific subset / configuration of TIFF is being used

also might be worth mentioning tiling as an asterisk for HEIC and AVIF

as iPhone's HEIC files are 8064x6048

jpg, png, tiff[1], tiff[2], tiff[3], tiff[4]

argh

DNG is also TIFF 🙂

even Exif is really just a small TIFF

so yes, TIFF can mean a lot of things, and it's a moving target

you can just stuff a `jxlc` into a tiff and say "look how good TIFF's compression is"

yeah, TIFF can do anything, but I guess for the sake of comparison I would look at something like baseline TIFF 6 or something

we need a "yo dawg. I heard you like tiff so I put a tiff in your tiff..." meme.

I'd been working on this but hadn't fixed the scrolling issues on mobile. Maybe if someone has some time to sort it out ( I don't right now). Also this is old and doesn't have the current star and bar ratings correct. In fact, they might be random from when I built it.

In the Figma file (where the SVG is from), we'd only set it up for 1/4 stars. This does anything, obviously.

In the mean time, I've replaced the current SVG with the changes discussed.

Ah, makes sense

OK, I created a the new page on the site: https://jpegxl.info/resources/battle-of-codecs-new.html Still isn't working properly on mobile (I cannot get that first column to stick). Maybe someone can help it out and then we can swap with currently one? I know you will, but check the bars and stars again. I _think_ I copied over everything correctly…

you should more professional formats like EXR, and also add at the bottom something like *Tiff is not mentioned here. There are many competing forms of tiff, of which there are differing degrees of support and compression, It is not possible to make a meaningful comparison, <Format here> would be the closest competing format which can be used as a baseline. <format here> likely being EXR it may also be worth specifying what forms of alpha as you have <Associated/Premultiplied alpha> <Straight alpha> APNG should have both an X and a check because APNG is not part of the official PNG spec, and some applications will just out right not work, and many will still only display the first frame.

APNG is part of the PNG spec now

https://www.w3.org/TR/png-3/#apng-frame-based-animation

wait what [av1_woag](https://cdn.discordapp.com/emojis/852007419474608208.webp?size=48&quality=lossless&name=av1_woag)

well, strictly speaking, I guess it’s still a draft

wait, is w3c the official spec now? I thought libpng spec was still the official one. last I checked libpng doesn't have apng yet. or are they still having a spitting fight over standards? Im willing to say w3c is official spec since w3c is what most people actually care about, but still curious

oh it seems like it is 0.0

interesting times, right?

don't the libpng people still claim that straight alpha is a good idea and totally wasn't a mistake? On that basis alone I'm inclined to go with w3c

well its good on low end hardware

What is the difference?

the difference is that straight alpha is bad, and associated alpha is good (actually, it's 1am, I am too tired to talk about it, so hopefully someone else can give insight)

I’ll put this here again (PTGui):

chad associated alpha [av1_woag](https://cdn.discordapp.com/emojis/852007419474608208.webp?size=48&quality=lossless&name=av1_woag) the best term

"straight" alpha is cheap to compute, associated alpha actually works more or less the same way light does

with straight alpha pixels are just that, RGB = color, A = visibility. however with associated alpha RGB = energy, A = how much energy gets imparted on the background

“straight” alpha: blended = alpha × fg + (1 − alpha) × bg associated alpha: blended = fg + (1 − alpha) × bg

consequence: with associated alpha, you can have complete transparency (alpha = 0) that still adds stuff on top

associated alpha:

with straight alpha, that’s not possible because whatever pixel data you have will be multiplied by 0

straight alpha:

So in associated alpha the A is more like an “opacity” where as in straight it’s a lerp factor?

yep

So true “don’t add anything” transparent for Associated has to be 0,0,0,0?

Otherwise it’s just adding?

yes

I wish more formats supported 3-channel alpha

so with straight alpha, discarding the pixel values of `alpha=0` pixels is a valid compression technique

with associated alpha, it’s not

Which does jpeg xl use?

either

Can you make tinted glass using associated?

that’s sort of independent from that, AFAICT

but EXR does support separate r, g and b alphas

Can jxl?

the demo is janky but it gives the gist http://distantsoulsdev.blogspot.com/2013/02/premultiplied-alpha-online-interactive.html

brb joining the swedish standards org to become a jpeg committee member with the power to veto future versions of the jxl standard unless they specify standardized extra channel names for per color alpha

yes

you can also represent things like candle flames which have lots of energy, but no physical opacity

(hm, this could be specified in a way that sorta works with older decoders and viewers. just need to make the current alpha be "average alpha" and then have two different chroma-alpha channels that can be combined with the regular channel to give you red, green, and blue alpha...)

it can to the extent that you can add extra channels and decide that they represent those, but as Lonnie alludes to, I believe that’s about the current extent of it

there isn’t a dedicated enum value in `JxlExtraChannelType`

Is there anything that straight alpha can do that premultiplied can’t?

be cheap

if you are doing compositing on a low end cpu like embedded, straight alpha performs better

That seems unlikely

It sounds like more work though?

it is also less efficient to compress as alluded to earlier

There is now an extra multiplication

no, that is a misnomer

this is why premultiplied is a dumb term

Associated should have smaller color values, which would compress better ;)

the math looks linger, but hardware can optimize it better

That seems unlikely

With Associated don’t you also lose quality in low-opacity sections?

How? It’s literally just 1 less operation, how would a multiplication be faster than not doing one?

Sure, but it's not like your low end 8 bit pipeline could use that precision anyway

I almost always use rgba16 or rgba32/hdr

then the precision of the pixel values should also be just fine

it goes both ways

(well, especially with EXR, which is floating point anyway)

Can jpeg xl EXR data losslessly?

JXL should be able to do floating point iirc

yes

albeit maybe only the 16-bit variant

(which is the default and, iirc, the only one exposed by EXR’s basic API)

Why not 32bit? Isn’t it just ieee754?

EXR’s default is half-precision

I mean EXR to JXL

yes, I meant that JXL can losslessly compress 16-bit EXRs

Can it not compress 32bit losslessly?

https://openexr.com/en/latest/TechnicalIntroduction.html > HALF: 16-bit floating-point numbers; for regular image data.

I am aware of the different data types

I’m a bit fuzzy on the details (<@794205442175402004> should be able to correct me / elaborate), but from what I recall, lossless can do up to 24 bits

I thought it was 24 bit int or 32 bit float iirc

ah, could be

but anyway, from what I remember, in the current code, when we read OpenEXR files, we do so using the basic API, which gives us half-precision values

Yes, JXL modular does 32 bit floating point losslessly

Not sure why it can’t do 32 bit int lossless

Because it uses fp32 math and fp32 can only represent integers up to that limit

Isn’t modular in the integer domain not in float domain?

It does a bit of both as I recall

lossless float32 works, lossless uint32 doesn't because 1) we use int32 internally in modular buffers, 2) libjxl uses float32 internally (also in modular mode, since there are still things like frame blending that are only implemented with float32 buffers)

Also does libjxl only use floating point operations that are guaranteed to be the exact same across architectures?

Some modular transformations increase the bit depth, right? So you can't store 16 bit int data in level 5 images due to it allowing 16 bit buffers. So even without the fp32 stuff, int32 wouldn't work or would at least work poorly.

not sure — if you just want to do lossless float32 without frame blending or any other things that require operations to be done in float arithmetic, then there is no problem, but I dunno what happens if there is stuff happening, I assume there might be differences between platforms...

really simple reason, DRM planes work like that

at least they used to

How does this stay lossless then?

yes, lossless float32 can only use simple modular, no RCTs or Squeeze — though in principle you could use those if the image is in [0,1] range, since then the first two bits are zeroes so you only need 30-bit numbers...

Never knew Widevine made A350s

[av1_dogelol](https://cdn.discordapp.com/emojis/867794291652558888.webp?size=48&quality=lossless&name=av1_dogelol)

Maybe (eventually in the far future) some kind of “JXL Custom” thing can be added (like Opus Custom) that adds a bunch of these hacks for applications that might want them

Looking forward to the day when DICOM shows up like "hey we need 38 bits of precision if we're going to replace j2k with jxl" and we end up with Extended JXL with fp64

oh shit, actually it looks like they may do both now 0.0

I guess it would be hardware dependant then

pfm -> jxl -> pfm should be lossless. But I'm not sure what happens if you have e.g. a two-layer float32 image with alpha blending, it's possible that the exact outcome of the blended image will depend on the platform.

It is in principle to have exact reproducibility across platforms that are ieee 754 compliant, but there are many practical annoyances

Like any random library running in the same process may flip some flag that controls how fp math works

I'm not aware of any type of imaging sensor where float32 is not plenty of precision to store the data. That limit of 38 bits in j2k has always puzzled me: why would anyone want to work with such an impractical bit depth?

The requirement came from medical imaging

I have no idea why they wanted 40 bits with 2 lost due to transformations, but that's why j2k has that limit

My unsubstantiated theory is that medical people haven't heard of floating point, and so store wide ranging low precision data in high bit depth

> The upper limit of 40 on Bits Allocated (0028,0100) and 38 on Bits Stored (0028,0101) reflects the maximum JPEG 2000 sample precision of 38 and the DICOM requirement to describe Bits Allocated (0028,0100) as multiples of bytes (octets). that's a really weird-ass requirement. I guess they wanted to be able to store 32 bit data, but the reversible color transform requires extra bits, but extra bits had to be added in full byte increments, thus resulting in 38 bits.

Can jxl store a 24 bit float?

what's a 24 bit float?

not a specific defined thing

you could give 17 bit mantissa, 6 bit exponent, 1 bit sign

or some other arbitrary combination

yes, bits per sample and exponent bits can be set and the samples are interpreted as in IEEE 754 (see Section D.3.5)

how does it upsample it?

just pad the mantissa with 0s?

It's like a 32 bit float but with more zeroes

Is negative zero a mathematically significant thing?

I don't think it is

in floats it is

a 0 doesn't mean *0*, it just means "smaller than any other number that's representable"

so let's say the smallest number you can represent is 0.125

1/16 will equal 0

but -1/16 will equal -0

But not mathematically meaningful or distinct from 0

Only in computers

HDR test page from <@794205442175402004>'s personal site added to the site: https://jpegxl.info/resources/hdr-test-page.html

So this section on the front page bugged me a bit but I never fixed it:

**High Bit Depth Support** Up to 32 bits per channel for higher precision image representation, enabling more accurate color reproduction — billions instead of millions of colors. Ensure your images maintain their vibrancy in the most demanding applications.

Since it's obviously a lot more than billions… or trillions…

How about something like Not just millions, billions or trillions of colors… 7.92 x 10²⁸ to be exact. Move beyond the limitations of 8, 10 or 12 bits — capture every subtle detail with an extraordinary range of shades. Perfect for applications that demand the highest fidelity and realism in visual content.

Octillion is the word you are looking for

either way its around 21 orders of magnitude more colors than typical a 8 bit image

which is completely unfathomable

Oh yes, I'd looked it up and forgot about it.

So that's 79.2 Octillion?

Yes, its an insane number. To put that difference in to perspective, that is like comparing the speed of bedrock erosion to the speed of light.

Another example is the size of a human compared to the milky way galaxy That's how big of a difference 21 orders of magnitude is

It's float so you effectively get even more orders of magnitude difference. But that's pretty much just theoretically, in practice it's just "there is no limit" since I don't think there will ever be any sensor that is precise enough to be limited by float32.

I thought 32 bit could be integer and float. Does it only do float at that bit depth?

Currently libjxl uses float32 internally, which can only handle int24 losslessly. It can be raised with a spec addition in future but for now there's no reason to

Advanced Profile anyone?

That does limit my theoretical idea for an astrophotography format with crazy dynamic range *somewhat*, but 2^24 with a linear luminance profile is still 65536 "orders of sRGB" to work with for the dimmest and brightest objects together in an image

but you still have the floating point exponent for dynamic range

you get 24 bits of precision, and a lot of dynamic range

Basically doing linear in float32 is like doing something like HLG in int32

My main concern with float was that values near zero would have more precision. This is an issue because the goal is not for users to view the image as is, there would be an exposure slider or bracketing range which could be adjusted to bring different luminance ranges into 'focus' (a range that your display can handle). It would mean you get a lot of precision on for example a planet, but when you adjust the exposure to the star next to it, you find there's a lot more banding because its values are on the higher end in the float range

Still, usually a log space makes more sense for light than a linear one, if you want to allocate precision in an optimal way.

Hmm I guess it would be possible to compensate for the size/precision trade off in the float range with a profile

If you adjust exposure that's a multiplicative thing, not an additive thing. So log space will be better than linear.

Whether you get to a log space via a transfer function or via the numerical representation matters less.

no, all values would have 24 bits of precision!

If I understand correctly, I could use a log transfer function to make it so that it can represent about the same amount of values between 1 and 20 as between 10000 and 10020?

floating point gives you a 24 bit "window" that you can slide up and down

Oh, that works

Well I've got a long way to go before I can even attempt a project like this for sure. Eventually I think a screenshot mod for SpaceEngine would be plausible, as the game natively has an adjustable exposure settings and space objects have accurate relative luminance. Then forking a decoder/viewer would be harder still. I just got started with QOI yesterday, which seemed like a good "first few steps" on a journey about image en/decoders

You don’t really need to understand the actual format to use it, the API will handle most of that for you

Ah, that's good to know I suppose

You just chuck it some pixels and information about the colours and it should handle the rest

There was someone where who also needed higher bitdepth, so they ended up splitting it into 2 channels and adapting their viewer to interpret it

Why would you need more than f32 depth?

Almost the same use case, satellite imagery with location coordinates

Maybe jpeg xl satellite profile with f64?

I don’t see an inherent reason why it can’t be done, the spec is mostly bit depth agnostic apart from the headers

Obviously the decoder would have to use f64 buffers but it should work

Although this would probably not be very high priority as this seems like a niche use case

where are the nightly libjxl builds link in the new website ?

can't find it anymore [⠀](https://cdn.discordapp.com/emojis/654081052108652544.webp?size=48&quality=lossless&name=av1_Hmmm)

Like this ? https://artifacts.lucaversari.it/libjxl/libjxl/latest/

yeah

but this link was on the old website on the new one, I cannot find that link

not just nightlies, official binaries for the reference library libjxl themselves seem to be not linked or downloadable anywhere on new site

same for the github page and issues iinm

Where were they on the old site? I'm sure we can find a good place on the new site.

nightly dev builds on main page, section `Software`

asian website vs western website

Done

this reminds me that I still have changes I've wanted to submit to the site but I keep getting distracted by other things. mostly cleaning up links and other small things

though I have thought about maybe restoring the extra affects for the main big JXL logo at the top of the site such as the glow and pixels but in a way that doesn't degrade performance as much, doesn't have visual issues, and is a bit more subtle'ish

the testing I was doing went well but I got distracted by other things lol

iirc the glow effect was removed because it had visual issues and didn't work right on mobile or something? and the pixel effect(s) where removed due to concerns about performance and being a bit over the top

Not really. The glow wasn't supposed to be there in the end, but it was still there at certain sizes (so it came and went as you resized the browser). We'd been testing various iterations of it it, but it's fine without it. We thought the pixel effect was fun, because like the the animated wave, it kind of gives a nod to the underlying tech – it was meant to look like pixels. But I was testing it on Safari, where it performed perfectly. On the chromium browsers it was a hot mess. <@794205442175402004> wasn't a fan, so I was fine removing it all together.

thisa makes it look like jxlatte/oxide/coder are part of the reference implementations,

Well... They kinda are, if you want to use them as reference :P

Is there a title above them that would make you happier?

not off the top of my head, ill keep thinking on it

possibly just split it using 3rd party implementations, coder is more of an api bridge though,

I made a mockup

Following the formatting of the jpeg foundation: https://jpeg.org/jpegxt/software.html

contributions is really... awkward for this?

third party implementations and bindings would probably be better here

third party software

wouldn't that just be under "software"?

well implementations is also wrong

libraries

Theyre libraries that implement the JXL standard

would implementation also be wrong? it sounds right to me hmmmm

I would go with reference / third party implementation(s)

Same

so like this?

Maybe the implementations title at the top is redundant

isn't `libjxl` also an implementation?

from `libjxl/README.md`: `JPEG XL reference implementation`

libraries and apis

as a dev that's what i look for

Maybe: ```# Libraries and APIs ## Reference Implementation ## Third-Party Bindings ## Third-Party Implementations ```??

more separations is YAP

Too much, if a dev really wants to look for something specific, they would just look at the github pages

fair

what part of the webpage is this in?

Supported software

libraries and apis libjxl: C++ reference implementation jxlatte: Java decoder jxl-oxide: Rust decoder etc

I think this works

yeah I like that, tho nightly dev builds should be moved

or just aligned with libjxl

AV IF

I was trying to keep the old JXL logo attached to libjxl, since <@794205442175402004> was going to keep using for that. The other don't have logos…

Yes, I would propose to use <:JPEG_XL:805860709039865937> for the official JPEG XL standard created and maintained by the JPEG committee <:jxl:1300131149867126814> for the .jxl image file format and the broader community around it <:JXL:805850130203934781> for libjxl (and I guess other implementations can make variants of it and use that as a logo?)

Maybe jxl-rs could have a brownish, rusty version of that logo? 😛

How about this Discord server

I guess <:jxl:1300131149867126814> might make more sense for the discord server, I like the current rotating server logo though...

I did not realize that it rotated until just now lol

I updated it again.

That would look cool

Im wondering what logos the third-party jxlatte and jxl-oxide would be

also would the existance of jxl-rs kind of defeat the point of jxl-oxide or will they both co-exist?

Ooo I like this idea a lot

Like combining brown from Rust plus orange from those old timey terminals, or something

Ohh, an amber display to make it a rusted retro version

Yess exactly

I like the last one best

Could we make jpegxl.info IPv6-compatible? It is No NAT November after all :p

Jokes aside this is not super important or anything but it's probably a relatively simple task so I thought I'd bring it up

It's hosted on GithubPages if I recall, so might not be possible

I think I set my main pc to prefer IPv4 over IPv6, I would see no difference 😅

IIRC GitHub Pages does support it, just GitHub itself does not

You can probably enable them both! Browsers will prefer IPv6 by default and use "happy eyeballs" aka fast fallback to downgrade to IPv4 if IPv6 fails despite the endpoint supporting IPv6

Depending on where you live IPv6 can also avoid carrier-grade NAT congestion. Typically there's no reason to not enable both IPv4 and IPv6. Unless you have some very specific situation? If so I'm quite curious what it is

hmmmm, I use a windows debloat tool called [winutil](https://github.com/ChrisTitusTech/winutil). And it recommends preferring IPv4 for less latency and packet loss. I already have quite a bit of a packet loss problem so I just turned it on.

I also have a pihole acting as a recursive DNS. The guide told me to disable IPv6 I think.

This isn't my field of expertise so I just read guides and follow them. 😅

Ah, I found this in their docs: > To set the IPv4 preference can have latency and security benefits on private networks where IPv6 is not configured. They give no further information or sources. I am either knowledgeable enough to know that this makes no sense whatsoever, or not knowledgeable enough to know why it would. Virtually all networking equipment produced in the last 25 years has IPv6 support. It also sounds like they're talking about LAN ("private networks") in which network delay is basically a non-issue even if one was indeed marginally faster than the other. The real benefits are in actual internet traffic where IPv6 benefits from, for example, not having to go through several layers of overloaded NAT because your ISP has long ran out of IPv4 addresses

Fair enough!

Oh, interesting. Maybe I got the number wrong? I'll see if I can find the statistic again

1. Could be true depending on the networks you're interacting with. Commonly though, providers that offer both IPv4 and IPv6 (dualstack) are IPv6-only internally and 'emulate' IPv4 on top of it, making IPv6 the more direct option. 2. This true, however this does not present a case for not enabling native IPv6 if you also still have native IPv4. These transition mechanisms only apply if either you only have IPv6 and need to access IPv4 endpoints or vice versa

The other points are sorta arbitrary points not directly relevant

True dualstack in the sense that you have a public IPv6 and IPv4 address can still be IPv6-only internally. My ISP has enough public IPv4 addresses to serve one per home network, but it takes in IPv4 at the edge, translates it to IPv6, does... ISP things... to that, then translates it back to IPv4 when leaving their network.

That's what I was referring to. I think it's common, but it's been a while since I delved into this

ah crap, the website uses grid for the test page but servo doesn't support it yet

Had a fun little idea. An addition to the banner that says how much data you've saved as you scroll down the page and load more images (Assuming you have JXL support)

Or if you don’t it could switch to “How much you could have saved”

Yeah

I only just realised... Is this AI generated? The lines on the gold disk are nowhere near straight, and I have no clue what this would actually *do* either

https://discord.com/channels/794206087879852103/1256302117379903498/1282763762738139290

Ah yeah

The longer you look the more wrong it looks

I agree it's kind of cringe

If AI-generated is allowed something like JXL-chan should be better

Do we have a jxl-chan?

With funny jxl hairties

It's not advisable to do AI art here specifically because: 1) Many models were trained mainly on JPG images, so they would try to reproduce JPG artifacts, negatively impacting compression. 2) AI hallucinations can be confused with lossy encoding artifacts (lines suddenly getting blurry midway, etc)

Agreed. It's s terrible idea to use as a showcase

Also people may see AI art and click away due to anti-AI sentiment.

PNG art with artefacts = AI generated

Not really.

I think they could be replaced with high quality Blender renders

Or just look for freely licensed art and photos on wikimedia

That's what it's there for

Or maybe some of the images that are part of a testing corpus

Or, hear me out... We take some photos ourselves, or ask any photographers we know if they have any they'd like to submit

That assumes you have something beautiful to photograph and that you're smart enough to capture it well...

NASA has some nice lossless JWST pictures. They might make good use of patches/dots too

there was a thread about that in /g/ a few years ago haha

an anon suggested there be two for lossless and lossy, with the lossy one having jpeg artifacts

oops wrong reply, meant for this

We have this

lol

honestly

...i don't like it

it does not spark joy

yeah, this figure is a bit loaded these days

I mean, I somehow ended up with this artwork for Halloween of me 'making' JXL art

honestly i'm all for a furry mascot

and if we get furries to adopt jpeg xl, that's basically the world

I like dragons. But jxl-tan should probably be pretty tiny, to represent small file sizes, and pretty colorful, to represent good color gamut.

And I like the idea of having a lossless one and a lossy, artifacted one, that seems funny

Maybe a 3rd one for recompressed jpeg

Is there already a jpeg-tan?

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

Ideally, we could represent them in JXL art

i didn't really have any expectations when i clicked that link, but ISIS-chan would not have been one of them

I asked ChatGPT to create an anime girl with jpeg xl hairpins. it didnt look great, but more interestingly, the image was shared as lossy WebP. I asked ChatGPT to provide a PNG. ChatGPT told me that the image was a PNG. When I answered that it was really a WebP, it just converted the WebP to PNG. So now I have a lossy WebP as a PNG created and converted by ChatGPT

It just works™

yesterday I asked it to rank lossless image formats based on compression ratio alone and it looked completely arbitrary. i asked for clarification and it kept spewing complete nonsense. every message had at least one major mistake and it did the "you're right, i apologize" thing every time. it's incredibly concerning, imo

And now realise that many students exclusively use ChatGPT until they graduate

that was the first time i'd used it in like a year or two. it doesn't seem to have improved

yeah it's crazy

It can be very helpful to get a first idea with complex problems, but trusting it blindly is a very bad idea

I have access to Enterprise ChatGPT now, some of its models are better than others. They can all be wrong in hilarious and concerning ways, but it can also be useful. Using it as a source of inspiration is OK imo, using it as a source of truth is obviously not at all OK.

Please be cautious as they can be more subtly deceitful than most advertise. I asked R1 to rearrange data in a table and it silently modified the data as well. Unprompted and undisclosed, it changed strings like 'ΛОК' to 'ΛΟΚ'.

Prior to that, the worst example I'd witnessed was asking for an edit in a code sample which happened to include a comment describing why the order of two lines mattered. Those lines were unrelated to the prompt, but ChatGPT removed the comment and flipped the order of those lines.

It did it for the lulz

People don't seem to understand how to use random number generators aka "language models" aka "general purpose """AI""""

I'm still in favor of replacing the AI images with real ones. This decision is baffling to me.

It just feels too corporate and fake honestly

Random number generation is a good description. I have also heard 'digital hallucination engine' used in the context of 'generative image' AI.

As I understand it, all the current AI tech does is regurgitate parts of whatever data it was trained on.

The correct way to use a neural net is to train it for a very specific and well defined domain. Anything else is just... a bunch of cavemen shaking a magic 8 ball.

There is no such thing as "general purpose" neural net, it's just a random number generator inside of a language coherency evaluator!

"best-of-breed" adds to this sentiment too for me > Unmatched in quality-per-byte, JPEG XL delivers best-of-breed image compression from web quality through lossless.

A lot of it reads like it's a presentation for shareholders

or like a page where you'd find "contact our sales team for pricing" at the bottom

Which doesn't make sense because Jpeg XL is free and open source! Like what are we selling here??

It's hard to find a tone that works for a broad audience spanning different cultural conventions and levels of technical background. The same words can sound like an overly enthusiastic sales pitch to one person while looking pretty neutral to someone else, or like a complicated technical description to one person while looking like an oversimplified, dumbed-down marketing blob to another.

A word like "nice" can be pretty positive to a European audience while in the US it's more like "one star out of five"

okay, that's fair

I still feel like it can do without some of the words that make it sound like i'm supposed to invest money in it though 😅

that's just my personal preference, I don't know which vibe the website is trying to go for

how would you guys describe the old website's tone

you can still see the old site here https://jpegxl.info/old/

I mean, it kinda was. The website was made to be a sales pitch after the Apple launch. To convince companies to switch to JPEG XL and invest in the infrastructure changes for it

i prefer the old one but if the new website is more likely to make companies adopt it i can understand

just like how sites have a dark mode toggle, maybe we should have a corporate mode toggle /j

and just turn it on by default for all requests that don't come from consumer ASes

message above but not j

whats a consumer AS?

That's just https://jpegxl.info/old/

autonomous system, a portion of the internet controlled by some body. you're a consumer so you're on a consumer AS, the one from your internet service provider. larger corporations often manage their own network infrastructure, and so instead of having an internet subscription like we do, they pay a fee to connect their network directly to that of other transit providers and internet service providers. basically, they are their own internet service provider. so the ASes operated by Verizon, T-Mobile, etc. are 'consumer networks' (or 'eyeball networks' because their users mostly just look at content instead of providing it)

fun fact: if you fill out some paperwork you can request an autonomous system number as an individual and then you can also become your own internet service provider. you will have to ask other organizations to peer with you though, or you won't be able to connect to anything, and they're almost definitely not going to let you do that for free

X))

maybe xqc will do that to combat ddosing

just set up a global anycast network with hundreds of endpoints all around the globe so DDoS traffic is distributed among them and nothing gets overloaded

worked out well enough for cloudflare

I haven't been seriously considering this, but there are residential areas here in the netherlands that have *two* fiber lines from competing companies, so technically you can obtain an autonomous system number, peer with both of them, and then you can have a *tiny* anycast network: the same IP addresses can be on two different endpoints which are directly reachable from both providers, so traffic will automatically seek the 'shortest' path, which depends on which provider you're with or where you're geographically located

would it be useful? no. would it be cool? yes.

are you from nl?

yeah

Yes, in my head when I wrote the copy, it was a pitch to the entire world to start using it. I know lots of people don't like marketing around here, but the object of the game was to sell its feature set, performance, and capabilities. Not unlike a paid product…

It's a lot easier to sell something when it's free, after all

Not really easier to sell when it's free as it doesn't sound premium aka revolutionary, innovative, creative...

e.g. HEIF being not free but revolutionary because of Apple

So we describe it as being revolutionary; with unmatched efficiency, ripping fast speeds, able to both perfectly replicate existing lossy jpeg images, and reduce their filesize with no loss, with all that for the low low cost of completely free. While pushing for adoption in both open-source and proprietary avenues.

For fans, being used by Apple = revolutionary

Short and sweet and let the demos speak for themselves.

The hard part is showing good demos

Maybe even with zoom/enhance to show differences in compression artifacts

Which is scientifically questionable but good for demos

All the words don't matter. Nobody is going to read or care what it says. All that matters is results. Show impressive demos, that's literally all that matters when making a good impression.

You know what will impress people? Show timing comparison with avif

Show how much faster it is

Side by side

Better compression in 1/10th of the time

Then show 1 or 2 graphs of speed/bpp/ssimu2 since libjxl is overfitted for metrics compared to libaom

That will give people the impression that libaom absolutely sucks

(Even if, in reality, libaom looks better and libjxl is just overtuned to have better ssimu2 scores instead of for human vision)

And replace the AI images...

Are there AI images left?

Ah, updated 2 weeks ago. Guess I hadn't checked in a while

The goal of the website should be to quickly wow people with the minimum boilerplate text no one is going to read. Just numbers and results that make libaom look like a joke. Even if some of those numbers (ssimu2) are meaningless or misleading

It doesn't matter if it's meaningless or misleading if it works and somehow still impresses people

I may be cynical but it's true, that's how things are...

there's no need to show meaningless/misleading numbers, the actual data is impressive enough but the amount of published data with actual subjective results (which is the only 'real' data) is limited so far

I'm looking at some very recent not-yet-published data from a subjective experiment on HDR images, where at the 1 JND point, JXL beats AVIF by about 35%, depending on the image — only 5 source images were tested, the gap is about 20% on one of them, about 35% on two, about 40% on one, and almost 60% on one. I hope this data will get published/released within about 2 months.

People will be impressed if they see how much faster libjxl is compared to libaom

Faster and better at the same time

Especially at lossless compression. That comparison is mind bogglingly extreme

People love seeing those kinds of numbers side by side

JPEG XL wins in efficiency, if not density. Usually lower memory usage and faster for equal or better density

We don't need to, but we could still cherry pick some visual results. Like the 0.8 lossy regression, or resampling being better around quality 20

Show what the format can do, rather than the current state of libjxl

Generally jxl performs well on portrait photography. Video-based codecs tend to apply generous layers of foundation makeup to human faces.

Also cloudy skies are often a lot better in jxl than in video codecs, which tend to turn clouds into Spandex...

I was really impressed by the graphic from your paper showing the same gradient in four different image formats

Good thing I just arrived in London, should be plenty of cloud

JXL would probably do a lot better for skies with gradients than AVIF just based on that

Wow lol, that is true

libaom might have improved with faces I think maybe? But jxl has always excelled at pure skies and clouds

libaom = avif?

Libaom did improve but still, whether it's avif, heif or webp, faces tend to get autobotoxed

Modern video codecs have no more blocking but they have botoxing artifacts instead

That should become a scientific term academics use

libaom is the AV1 reference encoder

libavif is the AVIF reference encoder IIRC

libavif handles the container-level AVIF stuff (such as dealing with transparency and ICC profiles, which are things AV1 does not support), it depends on libaom which handles the payload.

I'm partial to the word "vaselining" 😂

(it also works with other implementations than libaom, libavif can also work with svt, rav1e, dav1d etc)

vaselining works too, but I like how blocking and botoxing both start with a b

blasticky look

yeah, it also didn't help that libavif defaults to using zero adaptive quantization even for still images, not sure why

`--tune iq` makes clouds/faces/delicate textures better due to usage of variance AQ, but at some point you can only do so much with the format

this makes sense, nothing in libaom is tuned for HDR photography, so JXL will really shine <:BlobYay:806132268186861619>

looking forward to seeing the comparison and results

I forgot to take any photos... Guess it was a busy day

this graphic from the upcoming paper is pretty eye catching imo, maybe something that could be added to the website?

My personal analysis: JPEG cheats by being such a large filesize, JPEG XL is remarkably smooth, AVIF seems to have just given up and resorted to 1 DC value per macroblock (so acting like JPEG but worse), WebP seemed to add dither noise (?)

although it may not be fair to AVIF as its header is so large that it probably only got 100 bytes or so of actual payload, whereas JPEG XL only needs 8-12 bytes of header WebP only need 12-20 bytes of header

I love it. This is EXACTLY the kind of thing the website needs. Clowning on webp and avif

Once you see an image like that, the seeds have been planted. 🌱

What jpeg encoder is that though? If you can make JPEG1 look better than avif, like with jpegli, then it's even funnier

clowning on other formats is going to lead to defensiveness and tribalism imo. much better to put the focus on "jpeg xl good" rather than "[other format] bad." if you're trying to convince people, being condescending probably has the opposite effect. the target audience isn't people who are already JXL fanatics

I think my preferred option would be to highlight facts about all formats, talk positively about JXL, and let people come to their own conclusion about the other formats without demeaning them and their users and developers

An image codec can only be good in comparison to the alternatives. Showing demos of jxl outperforming webp and avif is a strong way to promote jxl adoption. Especially if you can show realistic situations where the alternatives are seemingly, utterly outclassed or outright out-of-the-question, unable to compete at all.

In some situations there actually IS no alternative, and jxl is the only option.

Due to inadequacies of other formats.

For example, lossless compression of high bit depth images

there is no alternative to jxl there

some of jon's old videos were massive eye openers (ie generational loss, how skin detail/color is better preserved, progressive loading)

Might be worth revisiting since videos are more easily spread around for awareness. Some of the material in videos and articles details paradigms the average imaging enthusiast never knew were important - always focusing on files giving disproportionate weight to kilobytes without real visual quality

Exactly. Demos that show jxl utterly outclassing alternatives, or situations where there are no alternatives at all, are a powerful argument for jxl standardization

That decode time chart that Jon made is also good. The one that shows how jxl can decode at the same time as its downloading while avif has to wait for it to finish downloading before decoding can even begin.

yeah I agree completely. I might have misinterpreted what you meant with clowning

Tbf, the image is a bit misleading because it's in the order of byes and AVIF wastes about 150 bytes on a header so it has about half the bits to work with. which is not that much wasted in the grand scheme of things

like you can show direct comparisons of visuals and data. I was referring to more like, dunking on other formats if that makes sense? I think that would just trigger people into defending their opinions rather than feeling welcome to try out a new format

when images are actually proper web quality (order of kB or MB) the wasted bytes are kind of irrelevant

I think it's better to emphasize highly relevant features JXL has like progressive decode

I mean "the other alternatives aren't even an option on the table here; they're outclassed so utterly and completely that they're either unusable or would never be considered."

This is a really good graphic that demonstrates that. Only JXL looks acceptable at all here

The others aren't even on the table as an acceptable option

In that case, those images look unusably ruined

Those make for extremely powerful demos to display on the website

It plants seeds in people's minds I think. That maybe, the alternatives are not even acceptable or even competing on the same playing field at all.

And creates demand for a higher standard that only jxl can provide right now.

:)

bench times for reference conversions would be good too since big user/pro migrations typically expect long times (quasi instant jpg->jxl being an anomaly in need of awareness). I dont recall seeing times for server-class machines or even typical desktops

I feel like this could be clarified in the graphic

Maybe it's kind of dishonest... but it's also kinda their fault that the header is so ridiculous.

Well yes, I do mean dunking on them. But not verbally. Merely by providing scenarios and examples where the alternatives are not even on the same playing field.

Using powerful demos like that

That's the best way to clown/dunk on other formats

Dunking with data!

Not with words.

Show, don't tell.

ah okay, I understand

:)

the file sizes are not really the point, it's not meant to be representative. For all codecs I used very low quality settings (e.g. -d 12 for jxl, -q 5 for avif and webp) that are lower than what you'd use in reality, just to show what kind of banding artifacts you get, but in a more obvious way than the more subtle banding you'd get at higher quality settings — mostly because otherwise the illustration would just not work when printing the paper or even viewing it on screen in a PDF viewer that is reducing the banding by rescaling the images.

this is 209 byte jxl vs 450 byte avif so now they're spending about the same amount of bytes on actual image data

that's cjxl -d 20 and avifenc -q 30

now it looks less like blocking and more like green waves on top of the blue part of the gradient

Wow so the header actually takes up the majority of the file lmao!

This isn't a problem unique to avif, is it?

HEIF in general?

https://discord.com/channels/794206087879852103/822105409312653333/1351512632976343040 https://docs.google.com/presentation/d/1LlmUR0Uoh4dgT3DjanLjhlXrk_5W2nJBDqDAMbhe8v8/edit#slide=id.gde87dfbe27_0_43

What slide?

90

I'd argue JPEG XL actually has an opposite problem

the header is so overengineered/bitpacked that parsing it is somewhat difficult

for example, there were a few mistakes made in design, like sometimes needing to implement an entropy decoder to find the frame start

yeah jxl went a bit too far — then again having overcomplicated header syntax is only a problem until the implementations are done, while having simple but overly verbose header syntax may save some implementation time but then you're stuck with it forever.

I'm sure the small header would go appreciated by platforms like Discord or Twitch that serve many super tiny custom images in the form of emotes

This is a pretty annoying flaw though