JPEG XL

I compiled a jxl_from_tree that sets orientation to 3 :)

Could expose that too, it can be nice to change orientation

Is it possible to transpose (mirror around x=y axis) a jxl_from_tree description?

just swapping x with y, and N with W

Not completely

e.g. NE can be used but not SW

In some cases it can be done, but not in general

But you can do it via orientation

Transpose the whole image, that is

All the 8 orientations

NE would remain NE under transposition

Oh, no.

I'm confusing east with west.

NW remains, and gradient predictor is unchanged because N+W-NW = W+N-NW

But NE changes, and so does the Weighted predictor

Also for some reason we made WW a predictor but not NN

<@!794205442175402004> Can I ask you for something at least 7800x3300? Will be interesting see end result BPP)

that is a specific resolution, lol

``` RCT 21 Height 1024 Width 1024 Orientation 4 Alpha if y > 350 if WGH > 0 - AvgN+NE + 1 - AvgN+NE - 1 if c > 2 - Set 255 if W-NW > -1 if NW-N > -1 if N > 254 if c > 0 - Set -255 - Set 0 - W + 1 - NW + 0 - Select + 1 ```

adding alpha support

Also adding support for bitdepths that are not the default 8

as well as reinterpreting the integers as floating point with a given number of exponent bits

``` RCT 0 Height 1024 Width 1024 Orientation 1 Bitdepth 11 FloatExpBits 6 if y > 0 - N + 1 - Set 0 ```

11-bit means actually 10-bit because the first bit is the sign bit, and the first 6 bits are treated as a floating point exponent so the last 4 are the mantissa

this allows representing nonlinear gradients more easily

for example

```RCT 0 Height 1024 Width 1024 Orientation 4 /* Bitdepth 10 FloatExpBits 4 */ if y > 350 if WGH > 0 - AvgN+NE + 1 - AvgN+NE - 1 if W-NW > -1 if NW-N > -1 if N > 254 - Set 0 - W + 1 - NW + 0 - Select + 1 ```

add the Bitdepth 10, FloatExpBits 4 that was commented out, and you get

basically this gives a global poor mans gamma adjustment, kind of

How costly would it be to add animation, especially with the possibility of setting a delay between frames?

costly in bytes or in effort to add that to jxl_from_tree ?

In bytes

well I think N frames are basically N times 1 frame, roughly speaking

the global image header can be saved, but that's not a lot (and the frameheader gets slightly larger too in case of animation)

so you could do an animated version of the burning chessboard where the y threshold where the burning starts moves down in every frame, but you'd basically have to re-encode the tree for every frame (trees cannot be shared between frames)

let's say you could do 20 frames in 1 KB or so

could probably make a pretty nifty animated fire in a few KB

but making this convenient in jxl_from_tree is not so easy, that will require quite a bit of code plumbing

So roughly the same as combining multiple groups into one image? Because I think with animations it would be possible to do interesting things too, for example looped in 2-5 frames with size less than 256 bytes

yes, a few looping frames should easily fit in 256 bytes if the frames themselves are like 50 bytes

I want to just encode the difference from the previous tree <:kekw:808717074305122316>

it would just require jxl_from_tree to take multiple files as input or something, one per frame

By the way it seems like fire, clouds and other natural-looking gradients can be easily encoded in Modular... What do you think of removing those artificially from the image (cloud removal would be easier, because sky is uniform) and overlaying transparent cheaply-encoded Modular layer?

Of course it'd be done at lower bpp, because at higher qualities it'd be easier to just encode everything with VarDCT.

you could cheat and encode all frames in one big invisible multi-group larger-than-canvas frame, where each group represents a frame, and then blit the actual frames from it using patches... but signaling these dummy frames with patches will have some overhead

removing clouds and replacing them with similar-looking artificially generated clouds is a cool idea but likely very hard to implement, both the extraction step and the 'find a modular image that produces something similar' step

that's the kind of thing an AI-MozGuetzli-JXL from 2035 might do

Maybe something slightly different (and a bit easier), like encoding the lowest frequencies with VarDCT (so no removing clouds entirely) and overlay the high-frequency Modular gradient?

maybe a library of texture patterns (clouds, grass, brick walls, ...) could be collected, and an AI-based encoder could detect and extract regions that can be represented (with low fidelity but high appeal) using such a pattern blended over the LF, but it's a very hard problem...

for now, let's just explore it for the sake of the art 🙂

For automatic encoding this is a difficult challenge, but for some kind of handmade art to get the smallest image size (as created for demoparty) it is possible

``` RCT 5 Alpha if c > 0 if c > 2 if Prev > 50 - Set 255 if y > 0 - AvgW+N - 1 - Set 255 if PrevAbsErr > 3 - Set 255 if W > 20 - AvgW+N - 10 - Set 0 if N-NN > -1 if W > 238 - Set 238 if W > 2 if W-WW > -1 - AvgN+NE + 1 - W - 3 - Set 3 if N > 6 - AvgN+NW - 1 - Set 0 ```

this one you can blend against whatever background

that's actually the last thing I was doing during my internship (adding pattern generation to patches), but I decided to drop it in the end 😄

the above jxl is 10240x10240

I guess it's hard to make a png of it? 😛

the png is too big to fit on discord

weird though, it's fairly repetitive

can you make one with something more interesting? 😛

My WSL2 ran out of RAM and crashed while trying to decode this thing...

thanks, I'm thinking to get myself a new wallpaper) or tile for wallpaper

I could have went full fabian and asked for 7725x3282 ))

Btw, I open-sourced the web app. PRs welcome 🙂

https://github.com/surma/jxl-art

starred

that's `9.91821289e-7` BPP <a:cooldoge:730176920162926793>

You know it's getting in cool zone when you start using notation)

Soooo... it should be easy to update it now to the new and more advanved jxl_from_tree?

after we opensource it... 😛

Oh.

8192 x 5120

Is the orientation flag (the 8 different ways) per group or for the whole image?

whole image

sadly

not even per frame

the above image needs to be seen at 1:1 to appreciate it

I wasted way too much time on getting the flames to kind of tile nicely despite the group boundaries

the sierpinskis at the bottom are kind of cool imo

it's of course still a pretty repetitive image

I liked the ones that looked less symmetrical, actually.

I really liked this one.

And this one.

When Discord starts embedding JPEG XL, this channel is going to look funny.

Agree. The second one you've mentioned is also good and "modern"-looking, but the first one is IMHO the pinnacle of this channel.

``` RCT 4 Width 3072 Height 4096 Orientation 6 Bitdepth 10 if g > 29 if y > 340 if x > 0 if x > 1121 - N - 1 if WGH > 0 - AvgN+NW + 0 - AvgN+NW - 5 - Set 0 if W-NW > -1 if NW-N > -1 if N > 1021 if c > 0 - Set -1024 - Set 0 if y > 0 - W + 2 if x > 0 - W + 2 - Set 0 - NW + 0 - Select + 2 if W-NW > -1 if NW-N > -1 if N > 1021 if c > 0 if g > 22 - Set -1024 if c > 1 - Set -1024 - Set 0 - Set 0 if y > 0 if g > 24 - W + 2 - W + 1 if x > 0 if g > 24 if g > 26 - W + 2 - W + 1 - W + 2 - Set 0 if g > 25 if g > 27 - NW + 0 - NW - 1 - NW + 0 if g > 21 - Select + 2 - Select + 1 ```

ok here's a variant on that theme

``` RCT 1 Width 1024 Height 1024 Bitdepth 8 if y > 0 if y > 511 if WGH > 0 - NW + 1 - NW - 1 if WGH > 0 - AvgN+NE + 1 - AvgN+NE - 2 if W > -400 if c > 1 - W - 4 - W - 5 - Set 500 ```

```RCT 4 Orientation 1 Bitdepth 10 if W-NW > -1 if NW-N > -1 if N > 1021 if c > 0 - Set 1024 - Set 0 if y > 0 - W + 1 if x > 0 - W + 2 if c > 0 - Set -1024 - Set 0 - NW + 0 - Select + 2 ```

"Xorpinski"

(I like jxl files that are exactly 42 bytes)

The Answer to Life, the Universe, and Everything ❤️

This one is more for gradient enthusiasts, while the "original" one is definitely for "cloud" lovers. They're still both nice, though, but each in their own way.

These look amazing, have the changes that allow these images to be made been merged into jxl_from_tree? I'd really love to play with the new features!

Also, for some reason, I get "Failed to write decoded image." when trying to decode xorpinski-p.jxl: ``` djxl xorpinski-p.jxl xorpinski-p.png Read 42 compressed bytes [v0.3.7 | SIMD supported: AVX2,SSE4] WARNING: failed to pin thread 2. WARNING: failed to pin thread 1. WARNING: failed to pin thread 3. WARNING: failed to pin thread 0. Decoded to pixels. Failed to write decoded image. ```

bigchessboard3-p.jxl also fails: ``` djxl bigchessboard3-p.jxl bigchessboard3-p.png Read 138 compressed bytes [v0.3.7 | SIMD supported: AVX2,SSE4] WARNING: failed to pin thread 0. WARNING: failed to pin thread 2. WARNING: failed to pin thread 1. WARNING: failed to pin thread 3. Decoded to pixels. Failed to write decoded image. ```

art31-p.jxl is fine, here's the output for reference: ``` djxl art31-p.jxl art31-p.png Read 44 compressed bytes [v0.3.7 | SIMD supported: AVX2,SSE4] WARNING: failed to pin thread 0. WARNING: failed to pin thread 3. WARNING: failed to pin thread 1. WARNING: failed to pin thread 2. Decoded to pixels. Done. 1024 x 1024, 4.21 MP/s [4.21, 4.21], 1 reps, 4 threads. Allocations: 244 (max bytes in use: 5.042558E+07) ```

Actually it looks like a bunch of art files fail to decode, no clue why. I won't continue spamming this channel any further with the same failure messages.

I am making some of them in 10-bit lately

You'll have to add `--bits_per_sample 8` to your djxl command

(or 16)

PNG cannot do 10 and it just fails instead of automatically saving as 8 or 16 bit instead

(will be fixed at the next sync)

For lossless compression, does the encoder detect that a 16-bit PNG e.g. is only using 10 bits?

It does channel palette in that case

``` Width 1024 Height 1024 CbYCr Bitdepth 10 Orientation 3 if c > 0 if c > 1 if x > 0 - W - 1 - Set 500 if y > 0 if WGH > 0 - AvgN+NE + 5 - AvgN+NW - 7 if W > -1000 - W - 18 - Set 700 if y > 0 - N + 1 - Set -500 ```

"The Smoke Machine"

HOLY SHIT

I NEED TO SEE A 16:9 WIDESCREEN VERSION OF THIS

``` Width 1024 Height 1024 CbYCr Bitdepth 10 Orientation 6 if c > 0 if c > 1 if y > 800 if N-NN > 0 - N + 0 - N + 1 - Set -80 if x > 500 if x > 501 if y > 0 if WGH > 0 - NW + 3 - AvgN+NE - 5 - W + 1 - Set -200 if WGH > 0 - Gradient + 6 - AvgN+NE - 5 if x > 0 - W - 1 - Set 511 ```

"The Abstract Hills of Super-Jixel-Land"

this is too much fun

I need to prepare for the upcoming JPEG meeting instead of making these

it's addicting though

this feels cool

🚭

``` RCT 1 Bitdepth 10 if c > 1 if y > 0 - N - 1 - Set 500 if y > 0 if WGH > -10 if WGH > 0 if WGH > 10 - AvgN+NE + 3 - NE + 300 - NE - 200 - AvgN+NW - 3 if c > 0 - Set 500 if W > 1200 - Set -200 - W + 9 ```

"A Perfectly Normal Cave Wall In Hell"

some previous sketches of this:

This trick of selecting on `WGH` and basically throwing off the weighted predictor by kicking it in the nuts whenever its subpredictors are getting good is just great for creating randomish textures of different kinds

http://sneyers.info/jxl/art/

simple test page

displays on chromium snapshot :>

All seem to render fine, including when there's alpha or if it's 10-bit

Apparently ML-based codecs aren't entirely crazy: https://opensource.googleblog.com/2021/04/lyra-enabling-voice-calls-for-next-billion-users.html

Still waiting for JPEG-XL2 which uses an ML model for the predictor, and produces cat pictures with empty data stream.

i suspect that doing actual cat pictures in jxl-art way wouldn't b that hard if patches were involved

make fur texture, then other features, use them as patches to make up whole images

should make server properly give `Content-Type` of `image/jxl`, as right now "Open image in new tab" saves instead of actually opening it

1600 bytes, who can do more? 😄

i need to force modular because it use vardct, it's not smart ^^

Just use `-s 9` instead of `-s 8`?

-s 9 -E 3

who can make the coolest JXL logo in jxl art ?

s 9 E 3 I 1 g 3

``` Width 1000 Height 1000 Bitdepth 8 RCT 1 if y > 420 if x > 500 if WGH > 0 - AvgN+NW + 2 - AvgN+NW - 2 if WGH > 0 - AvgN+NE + 2 - AvgN+NE - 2 if c > 1 if y > 0 - N - 1 - Set 300 if c > 0 if y > 0 - N + 1 - Set -500 if y > 0 if y > 220 if x > 499 if x > 500 - NW + 0 if y > 280 if N > -100 - N - 10 - Set 0 if N > 300 - Set 200 - N + 10 - NE + 0 if x > 500 - NE + 0 - NW + 0 if W > -100 if W > 300 - Set 200 if x > 960 - W + 10 if x > 822 - W - 10 if x > 628 - W + 10 if x > 340 - W - 10 if x > 175 - W + 10 if x > 0 - W - 10 - Set 255 - Set 0 ```

JXL logo

hmm one of the offsets isn't right

tweaked it a bit

This is a single standalone 4 kb HTML file: http://sneyers.info/jxl/art/

i reduce the size and format 287bytes, i'm smaller than a 0 pixel avif :p i'm happy :p

for %i in (C:\Users\User\Documents\m\*.png) do cjxl "%i" "%i.jxl" -I 0.344 -X 8.21 -P 1 -Q 25.6 -m -s 9 --num_threads=2

the second is lossless

this is not jpeg xl art i made it with paint

i don't know how raysar drew the cat

but i think this is a bug not a cat

it's a pixel cat, not a coded cat 😄 but the result is the same ^^

162 bytes, cat with 3 colors

it is so small!

102bytes cat in white and black

i need to to go sub 100bytes !

remove jxl conteiner?

if there is one

i don't know

the smallest cat in the web 60 bytes (16*16px) 😄

this crash wic

it's a 1-bit image, probably the application isn't dealing well with that

<:logo:829708783336816671>

the emoji version is a lossy JPEG, the lossless PNG was too large

how you do that? ^^

`-q 100 -s 9 -v -P 0 --override_bitdepth 1`

ok ty, in modular i don't understant what are lossy option, -palette can't fixe max number of colors?

there are few lossy options in modular, only -Q and --lossy_palette

ok

nyancat symplifed 252bytes -q 100 -s 9 -v -P 0 --override_bitdepth 2

Wic fail also on this

xnviewmp read it correctly.

simple version of the logo:

``` Width 900 Height 450 Bitdepth 1 RCT 0 if c > 0 if y > 0 if y > 225 if x > 448 if x > 449 - NW + 0 if y > 300 - Set 0 - Set 1 - NE + 0 if x > 449 - NE + 0 - NW + 0 if x > 898 - Set 1 if x > 749 - Set 0 if x > 599 - Set 1 if x > 299 - Set 0 if x > 149 - Set 1 if x > 0 - Set 0 - Set 1 - Set 0 ```

simplicity also has its elegance

fancy version:

``` Width 1000 Height 1000 Bitdepth 8 RCT 1 if y > 400 if x > 500 if WGH > 0 - AvgN+NW + 2 - AvgN+NW - 2 if WGH > 0 - AvgN+NE + 2 - AvgN+NE - 2 if c > 1 if y > 0 if N > -10 - N - 1 - N + 0 - Set 300 if c > 0 if y > 0 - N + 1 - Set -510 if y > 0 if y > 220 if x > 499 if x > 500 - NW + 0 if y > 280 if N > -100 - N - 10 - Set 0 if N > 300 - Set 200 - N + 10 - NE + 0 if x > 500 - NE + 0 - NW + 0 if W > -100 if W > 300 - Set 200 if x > 960 - W + 10 if x > 800 - W - 10 if x > 628 - W + 10 if x > 340 - W - 10 if x > 175 - W + 10 if x > 0 - W - 10 - Set 255 - Set 0 ```

come to think of it, maybe there is a niche for splines in jxl-art

Yep https://discord.com/channels/794206087879852103/824000991891554375/826457184539508786

Yes, please update jxl_from_tree to add some spline description syntax :)

This is a lot of fun, but also somewhat useful to produce test bitstreams

xnviewMP don't decode well this image :/

<#805007255061790730>

it's important to find where is the problem, all decoder need to be perfect for all type of jxl.

Interesting. I suppose it's a clamping issue?

it probably ends up ignoring the bitdepth

``` RCT 1 if c > 0 if c > 1 - Set 50 if y > 200 if y > 800 - N 0 - N + 1 - Set -300 if y > 0 if y > 500 if x > 509 if x > 510 - AvgN+NW 0 - AvgN+NW - 1 - AvgN+NE 0 if x > 510 - AvgN+NE + 0 - AvgN+NW + 0 if W > 580 - W - 2 if W-WW > -1 - W + 3 if W > -370 - W - 3 - W + 0 - Set 0 ```

Another jxl logo

Relly nice, much cleaner than <:Xjxl:822166843313225758>

we are nearly to a good logo :p

I was wondering if that logo was accidentally HDR, and I think it is

we don’t intrinsically clip when decoding

I indeed used out of bounds values, which I guess is the same as HDR if it's above 255 in 8-bit sRGB

Values go from -370 to 580

Instead of 0 to 255

/wraHOh/aCAmCCYAHAewAEYAALQASzhCpsOyYX6dloe+uCwRfCRSkHGgyjiAu8Ly1CtXlBscgv+I bqAMMgCShAMA

(I don't know how to upload a jxl on mobile discord, I am on my phone, this is the base64 encoded version)

"Smoke on the water, fire in the sky"

https://twitter.com/jonsneyers/status/1381219800299491328?s=19

```Bitdepth 8 Orientation 7 RCT 1 if y > 0 if x > 500 if c > 0 if c > 1 - Set -150 if x > 501 - W + 1 - Set 0 if WGH > 5 - AvgN+NE + 3 - AvgN+NE - 3 if c > 0 if c > 1 - Set 10 - Set -100 if WGH > 0 - AvgN+NW + 1 - AvgN+NE - 1 if W > 150 - Set 50 - W + 4 ```

But I also hacked jxl_from_tree to crop 100 pixels on the top (right after orientation)

(another thing to expose: frame offsets. Very practical to hide ugly initialization rows or columns)

(but on my phone taking a bath now and hacking it in Termux was already painful enough)

Show this message to anyone from a century ago. Living in 2077 be like:

Without the frame offset cropping stuff, it looks like this:

``` Orientation 3 RCT 15 if WGH > -7 if WGH > 6 - AvgN+NE + 1 - N + 30 - AvgN+NE - 1 ```

"Ice Cavern"

For some reason, people are suddenly liking 'The Smoke Machine' and following me on twitter

hah

I really didn't expect this when I wrote that tree thingy xD

Branching on the weighted predictor MA property and using an offset depending on its value is great for natural-looking art

It's also almost a symbol of the collaboration: WP was by Alexander Rhatushnyak, MA trees by me, and integrating them and allowing predictors per node and offsets is by Luca

i'm somewhat interested in what use this could have in game textures, especially inorganic textures

a game using this for some inorganic textures would be neat

```Width 1000 Height 500 Bitdepth 8 RCT 1 if c > 1 if WGH > 0 - AvgN+NW + 1 - AvgN+NW - 1 if y > 0 if y > 249 if x > 498 if x > 499 - NW + 0 - N - 2 - NE + 0 if x > 499 - NE + 0 - NW + 0 if x > 938 - W + 6 if x > 749 - W - 2 if x > 499 - W + 2 if x > 249 - W - 2 if x > 60 - W + 2 if x > 0 - W - 6 - Set 255 - Set 0 ```

Yet another logo

/wqYfxAJCAYBAOwASzhDdMN03Tlqxgcmu4FdmEe+PKrLJV+ueVlSnnblmtehwwIyKde8BYyJFMqR l0n5cSkUsoPjjyThAAA=

```Bitdepth 9 Orientation 1 RCT 1 if c > 1 - Set -200 if c > 0 if y > 0 - N +1 - Set 0 if N > 600 if y > 250 if y > 500 if y > 750 - NW - 200 - NW - 800 - NW - 3000 - NW - 400 if WGH > -36 if WGH > 35 - AvgN+NW + 1 - AvgN+NE + 250 - AvgN+NE - 2 ```

"Tissue Sample #1337"

65 bytes

I gained over 60 twitter followers today because of the jxl art I am tweeting

Still a few orders of magnitude fewer followers than <@799692065771749416> 😅

<:Stonks:806137886726553651>

<@794205442175402004> I don't want to know how many of them are bots.

Why would bots follow you?

You should ask them.

Lots of usernames don't look very real.

Updated 6 years, 1 month ago?

That cannot be right, or did you already have that many followers back then?

No, certainly not.

Only reached 2^16 recently.

I guess it is because of this retweet (more than 200K followers): https://veg.by/z/2021-04-12-00-23-47-4c573293.jpg

also just asking, how does one compile jxl_from_tree?

i've tried `clang -I/mnt/ScientiaStor/Software/Source/Visual/jpeg-xl tools/jxl_from_tree.cc` and `gcc -I/mnt/ScientiaStor/Software/Source/Visual/jpeg-xl tools/jxl_from_tree.cc`

but i must be missing something because it has errors

nah i think i got it

having this issue now, this is the same issue i've had with the online tool too, which is strange since i assumed it would work

The online tool is the same as the git, only the private dev version has new features

Ohhh

) :

Hope these get pushed to the git

public git repo when

At next sync

``` Bitdepth 10 Orientation 1 RCT 1 if c > 0 if y > 0 - N + 1 - Set -500 if W > -1000 - Weighted -10 - Set 2000 ```

"Alien Art"

36 bytes

/wr6H0GRCAYBAGAASzgkunkeVbaSBu95EXDn0e7ABz2ShAMA

What's the signalling cost for noise? Might be interesting to add some noise to jxl art

noise?

Noise generation. Can probably signal some rather extreme and weird noise that could be artistic, but I forgot how much it costs to signal

It's a lookup table of noise intensity for X and B depending on Y, right? Or I suppose channel 0 and 2 depending on channel 1

The table is signalled as uncompressed half-floats though, right? So not super cheap, something like 32 bytes or so

Your jxl art use the modular decoding? Is there noise generation in it?

Yes, it's all Modular exclusively. Modular generates MA tree and encodes only the difference between the value predicted from that tree and the actual pixel value. You want this difference to be the smallest for best compression. JXL Art assumes that the difference between tree's prediction and "actual" value is exactly 0 so you're seeing only predicted values.

16 bytes, more or less

Thank you, that's clear 🙂

_now wonders about a hypothetical JPEG-XL2 that has a jxl\_from\_tree like language to encode predictors for DCT coefficients._

I actually thought about doing it

and tried it

it was basically the same as the current context model though

which means either our ctx model is very good, or our tree learning heuristic is very bad xD

although I did use (in my PhD thesis) a jxl_from_tree-like language to compress graphs 😛

how are the DCT coefficients encoded in JPEG-XL, actually?

IIRC Modular encodes DC (1:8 scale) coeffs

DC, yes

DCT, just ANS (or huffman) + context model

The ctx model for AC does have some degrees of freedom though

Not full MA, but there is some expressivity there

AC coeffs are encoded roughly as follows: first the number of nonzero coeffs is encoded, with its own ctx model

Then coeffs are encoded, with a ctx that can depend on amongst others the coeff index, nb of nonzeroes left, DC values

Once the last nonzero coeff is encoded the decoder will know that and starts with the next block

And DC is encoded as modular?

Yes

With any restrictions on features or so?

So you could do a jxl art in DC and get it 8x upsampled

No restrictions, but the encoder doesn't do fancy stuff

So there are specialized decoder codepaths that are faster if the encoder was tame

VarDCT means that the DCT areas can be variable size, right? How is the "DC image" to be encoded with modular determined then?

DC image is always 1:8

Bigger blocks also have low freq AC in the DC image

I'm confused

We do fancy math, e.g. a 16x8 block has two 'DC' coeffs

Interesting.

that was *a tad* tricky to get to work right...

I can imagine something like taking the 2 "DC" coefficients, then using their average as actual 16x8 DC, and their difference as 8,8 AC coefficient, and then consuming all other AC coefficients from the decoder.

yes, you'd take the DC and the coeff that does lowest freq horiz, translate them to two "DC" coeffs

``` Bitdepth 10 Orientation 3 RCT 1 if c > 1 - Set -200 if c > 0 if y > 0 - N -1 - Set 500 if y > 400 if WGH > 0 - AvgN+NW 80 - AvgN+NW -80 if W > -1000 - Weighted -5 - Set 2000 ```

"Self-assembling Alien Art"

`/wr6H1FQTAgGAQCQAEs4JJp3vWxBBeeRkvKCFAUXPRs03vN6A0JvPlh24IMeScIBAA==`

`data:image/jxl;base64,/wr6H1FQTAgGAQCQAEs4JJp3vWxBBeeRkvKCFAUXPRs03vN6A0JvPlh24IMeScIBAA==`

That would be fun to animate, with that y coord just changing every frame

would it be very hard to add a time variable to the language?

just encode everything as a single frame, with separate group(s) for every timeslot, and then use sections to extract frames from it?

Probably not really, but probably easier to have something that takes multiple trees as input and does one frame per tree (and then a simple bash script can produce the input files)

oh, right, you have separate MA trees per frame?

You can even have separate ones per group, but we just tend to use the global one since group id is a property you can split on

what is the difference between having a separate MA tree per group, and permitting a global tree with groupsplits are at the top?

Global tree is more efficient since the trees tend to be similar between groups so there is less signaling overhead with a global tree

So what is the use for per-group trees, as those can be emulated by a global tree with group-based splits at the top?

Probably no use, current encoder does not do it

But I guess it _could_ be more efficient sometimes

Like if all groups except one use tree A while group 57 uses tree B

Then with a global tree you'd have to do ``` if g > 57 Subtree A if g > 56 Subtree B Subtree A ```

If tree A is a big one, signalling it twice is not so good

Ah you can have both a global one and per-group ones, I see.

That's equivalent more or less to allowing "if g == C" branches, but only at the top level of the tree.

Yes

``` RCT 1 if c > 0 if W+N-NW > 1200 - Set -1200 - Weighted 30 - Set 0 ```

/wr6HwGRCAYBAEwASzhE5i3dQXEaWAD7CupzJAkHAA==

``` Bitdepth 10 Orientation 1 RCT 1 if c > 0 if W+N-NW > 1200 - Set -1200 - Weighted 30 if N > -400 - Weighted - 1 - Set 1100 ```

/wr6H0GRCAYBAGQASzhE3C1PyMeqYMn/kX4F8TjiQDGBJOEAAA==

"The Glitchy Dunes of Cyberia"

The weighted predictor is fun. And we're only scratching the surface here: this is all just the **default** weighted predictor. Custom weights could be signalled to get whole families of different weighted predictors...

<@179701849576833024> what does WGH mean? It's the weighted predictor max-amplitude subpredictor error, so I know what the W means but not the G and H...

WeiGHted 🤣

<@!794205442175402004> you could try to sell a picture like this https://twitter.com/jonsneyers/status/1379158649478713349 as an NFT token 🙂 Who knows, maybe the technical background behind this picture will make somebody interested, and it will collect loads of money for further development of the codec.

In my opinion, the NFT is a quite shady hype thing, which is more likely to bring a bad reputation to Jpeg XL than give something positive and useful (except for money from someone who then also wants to make money on it when reselling it at a higher price later)

If it's done without energy-burning proof-of-work, I don't mind NFT as a method for selling art. Of course it's overhyped and silly, but in that sense it is not different from traditional, reputable art auctions.

We don't need money to develop jxl, afaik. I have a job at Cloudinary, the others have a job at Google, we get paid sufficiently already :)

The point is that this is not a sale of some unique thing with all the rights to obtain and collect as in the real world, it's just a sale of a unique hash that works only on a particular platform, which is associated with some thing

It's like selling a unique Eiffel Tower in some computer game and only in this game it will be the only and unique or for example a soccer player from some team, but their owner will be only in this computer game (as long as it will exist)

Also, most big and high-profile NFT sales are advertisements for various services related to the NFT promotion or charity (when the buyer does not care what to buy), the rest in the hope of reselling it at a profit

``` RCT 1 if N > -200 if W > 0 - NE -1 if c > 0 - AvgN+NW -1 - AvgW+N - 1 - Set 400 ```

"Stairway to Heaven"

/wr6HwGRCAYBAFQASzhC3O09qH6PCzxI9BB2wQyShAMA

+ `data:image/jxl;base64,` like `data:image/jxl;base64,/wr6HwGRCAYBAFQASzhC3O09qH6PCzxI9BB2wQyShAMA` and it will be convenient to view when copying directly in the browser address bar

Right. Doing that on twitter now

I have no clue where those stairs are coming from at the bottom

<https://github.com/mathiasbynens/small/issues/114> https://twitter.com/mathias/status/1381889698226917376

data:image/jxl;base64,/wqaGeh/oEgIBgEAFAELgItlK8bI1pigmwgqcJDEAINY63n4j32HzZAbSvhPopdjbEKq0wxZNOG/ /9cG6Ofan39symrgv4bOyKH2HwEm+ZMkHAA=

``` Height 820 Bitdepth 10 Orientation 1 RCT 1 if c > 1 - Set 100 if c > 0 if y > 0 - N + 2 - Set -1000 if y > 0 if x > 1022 if y > 200 if y > 620 - Set 0 - Set 1023 - Set 0 if x > 0 if y > 410 if x > 509 if x > 510 - NW + 0 if y > 510 - Set 0 - N 0 - NE + 0 if x > 510 - NE + 0 - NW + 0 if y > 200 if y > 620 - Set 0 - Set 1023 - Set 0 if x > 822 - Set 1023 if x > 199 - Set 0 - Set 1023 ```

Yet another logo

Similar to this one, but the X is going all the way here

```RCT 1 Squeeze if c > 31 - Set 0 if W+N-NW > 100 - Set -200 - Weighted 7 ```

data:image/jxl;base64,/wr6HwGRCAYBAFAASzhBvO15IutBdUj+EWONJGEBgAA=

"Alien Message"

``` RCT 1 if PrevErr > 0 - Set 0 if W+N-NW > -500 - Weighted -1 - Set 300 ```

data:image/jxl;base64,/wr6HwGRCAYBAEgASzhC5i390BNw2nk1MCxIEg4A

More Alien Art

with all these data urls i think you are winning the discord message encode challenge that i had proposed in the av1 server

What was that challenge?

i proposed it here https://discord.com/channels/587033243702788123/612960210570575900/823425406475436032

a couple small avif encodes starting here https://discord.com/channels/587033243702788123/610740411723546635/823475615650152471

Ah, I see. Yes the avif header overhead is kind of silly

yeah i used avif since i had heard it was better than jxl for small images, but i didn't realize there would be so much overhead. and this was before chromium had jxl support which defeated the purpose of making them data urls

``` RCT 1 if c > 0 if c > 1 if W > 200 - Set 0 - Weighted 13 if Prev > 50 if Prev > 70 if Prev > 100 if Prev > 120 - Set 0 - Set -400 - Set 0 - Set 400 - Set 0 if W > -80 - AvgW+NW - 1 - Set 320 ```

"Alien Architecture"

data:image/jxl;base64,/wr6HwGRCAYBAKAASzgiOnfKLyl1NObT+JCRR2oVLCCAa5TIMEBkkCxIIgMHgP2IJOEAAA==

data:image/jxl;base64,/wr6HwGRCAYBAGwASzhCtjlvwCvy9NvFPsJhYfCVLD2mQW1IEg4A

``` RCT 1 if c > 0 if c > 1 - Set -200 - Set 300 if N > -350 if W > 101 - AvgAll - 1 - Weighted - 3 - Set 250 ```

"Cupid's Factory" 💘🏭

Cool, girls will go nuts. 😄

overhead of sending this over internet is equivalent of having large box for wedding ring

data:image/jxl;base64,/wr6H7FATAgGAQBcAEs4QrztoTB2LKCxxwE8epRBK0gSDnAC

``` Orientation 6 RCT 21 if PPrev > 150 - Set 0 if W > -100 if WGH > 0 - Weighted - 1 - AvgW+NW - 1 - Set 500 ```

"Alien Farmland"

data:image/jxl;base64,/wr6H0GRCAYBAIAASzhEtjntAcQjNd/5QVtY4uMOCZx/VOD8460xBknCAVw=

``` Bitdepth 10 Orientation 1 RCT 15 if c > 0 if c > 1 if x > 0 - W -1 - Set 511 if y > 0 - N -1 - Set 511 if N > -500 if WGH > 10 - AvgN+NW -2 - Weighted -1 - Set 1500 ```

Not sure if it should be oriented like that

This has something curtainy

But upside down it maybe is more interesting

Now it looks like huge flames behind mountain silhouettes

Very different image depending on orientation imo

🤔

Going for orientation 3

data:image/jxl;base64,/wr6H1FQTAgGAQCAAEs4RLY57QHEIzXf+UFbWOLjDgmcf1Tg/OOtMQZJwgFc

"Alien Bushfires"

Polar lights?

Yes, that too

data:image/jxl;base64,/wr6F9NATAgmAP0jgAUwAgDwAEs4Ijp3nmrJz1LyQwg0i74M3nhg1CzrimbRawsWEGYNholRckCz 6JtVL0aI05gFhgX3wINQBZ8FScIBAA==

``` Bitdepth 8 Orientation 7 RCT 1 if y > 150 if c > 0 - N 0 if x > 500 if WGH > 5 - AvgN+NW + 2 - AvgN+NE - 2 if x > 470 - AvgW+NW -2 if WGH > 0 - AvgN+NW +1 - AvgN+NE - 1 if y > 136 if c > 0 if c > 1 if x > 500 - Set -20 - Set 40 if x > 501 - W - 1 - Set 150 if x > 500 - N + 5 - N - 15 if W > -50 - Weighted -1 - Set 320 ```

"Unusually Cloudy Desert Sunset, Part 1"

ok, that's pretty surprisingly realistic...

data:image/jxl;base64,/wr6H9FATAgGAQDwAEs4Ijp3nmrJz1LyQwg0i74M3nhg1CzrimbRawsWEGYNholRckCz6JtVL0aI 05gFhgX3wINQBZ8FScIBAA==

Same code as above but no crop

"Unusually Cloudy Desert Sunset, Part 2: Aliens' Earth Simulator Revealed"

(I don't see the crop in the code above)

Yes I haven't made syntax for it yet, just manually recompile it with hardcoded cropping, lol

ah 😄

I have some old version of the gtk plugin that breaks badly on this image btw xD

Clamping is kind of important for these images, I am heavily using out-of-bounds values

Orientation might also be broken in old versions

I think this might be using the wrong stride

(or maybe it is indeed orientation)

The hint of pyramids at the horizon is pretty cool imo

could one make that larger

or not with current tooling

Group size is limited to 1024x1024 so that kind of limits what you can do in a valid bitstream

well, we could upsample it, I guess xD

Can also spent bits or use clever tricks to do multi-group jxl art without boundary issues

data:image/jxl;base64,/wr6GOjgaCgmCGa/6BcBPIARAFwBAABAAAQAC4CjbVuVYsvIULAKAFEIv2JAFLEYRfEOYRxhfoAI qQEkn3W4b+piqIveY/kkD/3RLwdjfIAzC3y7o1EcCMmEF3p0TTmhiefnYhxhi+cHWiQzAGkgSTgA AwM=

``` Bitdepth 10 Orientation 7 Width 2048 RCT 1 /* Chroma */ if c > 0 if c > 1 if g > 21 - Set -50 if x > 40 if W-WW > -1 - W -1 - W 0 - Set 300 if g > 21 if x > 0 - W - 2 - Set 1000 if x > 400 - W + 2 - Set -900 /* Luma */ if y > 80 /* Sky and mountains */ if g > 21 if x > 0 if WGH > 3 - AvgN+NW + 5 if NW-N > -500 - AvgN+NE - 5 - NW + 1 /* extend mountain */ /* init mountains */ if N > -6000 - N - 20 - Set -1000 /* Sea */ if x > 1015 - W -100 if WGH > 1 - AvgN+NW +2 - AvgN+NE -2 /* Randomness */ if W > -50 - Weighted -5 if g > 21 - Set 1400 - Set 500 ```

how to read those where you copy those codes

base64 etc

Copy paste it into address bar of chrome canary

"Tropical Island Sunset"

add in sneyers info art

Yes, I will eventually add the nicest ones there

Tired of sunsets now

crash on xnviewMP nomacs and imagemagick ^^

Probably the orientation bug

Will fix itself once they sync to latest

How do you enable jxl on chromium canary?

Or is it only in chrome?

Ah, found the flags. The snap "edge" build of chromium 91 doesn't have it yet, apparently.

https://discord.com/channels/794206087879852103/803574970180829194/830826479662530610

Wow, this is probably the best piece of jxl-art I've seen! This is what makes you famous. 🙂 👍

Not very arty but just seeing what I can do on my phone:

33 megapixel image

data:image/jxl;base64,/wr6/+j/YSUSCAYBAPgAAABAAARAAARAAARAAARAAARAAARAAARAAARAAARAAARAAARAAARAAARA AARAAARAAAQASzhEnMMyvSSHiov5vzh+DQsA0sXcfy0eVCdY/iMggniY/T/RAPs/ohHmf6Ih/v9E YyAaZACABSAsAJAkHAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw==

160 bytes, but looks like it would be less when gzipped/brotli'd

0.000038 bits per pixel

A low quality (-quality 30) jpeg version of this is 2 megabyte or 0.5 bpp

how would i download this as JXL? The links seems messed up, what i get can't be opened with Squoosh for example

(i used the command-line `base64` tool)

https://squoosh.app/editor isnt able to load that 😦

iirc, it needs an orientation fix that is in the internal jxl codebase

should soon be reflected in the public repo

I'll wait then. I think that sunset image is another milestone in jxl art. Deserves spreading in demoscene~ish circles. But i want to give people something they can check themselves easily 🙂

It works in `djxl`, but the orientation is wrong, and it fails to decode to png (it can decode to jpg).

Works perfectly with Chrome Canary 😃

Okay, shared the twitter post for that image 😄 I like how google reverse search is like "did you mean sunset", that's a compliment 🙂

Orientation handling was buggy until recently, for a long time we never produced oriented images so the bug went unnoticed

data:image/jxl;base64,/wr6X0GRCAYBAGABAABAAARAAARAAARAAARAAAuAEwxViFIjH9lELZ3Ufp4qDghEeo47DNXGDzXJP7UaI5Jt18/+KCPuG+gvG8HVsCb9g8N8MntOyShnZTPR+qMdvoeP7/pZhK7tX9T7g/28HnhlSxIO4AIDAwMDAwMDAwM=

``` Bitdepth 10 Width 3072 Height 3072 Orientation 1 RCT 15 if c > 0 if c > 1 if g > 21 if g > 22 if g > 23 if g > 24 if g > 25 if g > 26 if g > 27 if g > 28 - Set -127 - Set 383 - Set -255 - Set -511 - Set 0 - Set 511 - Set 255 - Set -383 - Set 127 if y > 0 - N -1 - Set 511 if N > -500 if WGH > 10 if g > 21 if g > 22 if g > 23 if g > 24 if g > 25 if g > 26 if g > 27 if g > 28 - AvgN+NW -1 - AvgAll -2 - AvgW+N -2 - AvgN+NW -2 - AvgAll -1 - AvgW+NW -2 - AvgW+NW -1 - AvgW+N -1 - AvgN+NE -1 - Weighted -1 - Set 1500 ```

"Flame generation study"

Or maybe again better oriented if I call it flames

data:image/jxl;base64,/wr6X1FQTAgGAQBgAQAAQAAEQAAEQAAEQAAEQAALgBMMVYhSIx/ZRC2d1H6eKg4IRHqOOwzVxg81yT+1GiOSbdfP/igj7hvoLxvB1bAm/YPDfDJ7TskoZ2Uz0fqjHb6Hj+/6WYSu7V/U+4P9vB54ZUsSDuACAwMDAwMDAwMD

i'm converting to webp2

``` Bitdepth 10 Width 1024 Height 1024 Orientation 1 RCT 1 if c > 1 if x > 0 - W -1 - Set 511 if c > 0 if W > -1500 - Weighted -100 - Set 2500 if N > -800 if WGH > 10 - AvgW+N -2 - Weighted -1 - Set 1300 ```

data:image/jxl;base64,/wr6H0GRCAYBAJAASzglcne/WQlSGiGB45+Fd7v+/qjdR/iIw8AQD0WoFW2QJBwA

"Inside the Flying Spaghetti Monster"