JPEG XL

I don't remember what I did here, but glitchy it was.

this is what it was supposed to look like

this is what it looked like

behavior when attempting to do doing lossy animation in FUIF

also <@!799692065771749416> I don't know if you saw this: https://www.sabatobox.com/flif-databending-glitch-studies

so many beautiful bugs

it's involuntary jxl glitch? Maybe i will be fun to know how to modify file to have funny glitch. Few bits can destroy the files?

The above were all encoder or decoder bugs from quite a long time ago (basically the kind of thing I would typically get at the first attempt when implementing something new)

Not JXL, but it will pass

-c 2

Ah yes, -c 2

We never bothered to implement forward YCbCr

So iirc this just assumes the input is already YCbCr

well this might count as glitch art, Discord renders this image very differently from how it renders outside of Discord https://cdn.discordapp.com/attachments/173877869640941568/807035520655818752/65536colorgif.gif

Samsung Photo Gallery renders it exactly the same, but Google Photos "flash" the red picture and then jump straight to the green-yellow part

it was supposed to look identical to this image once all the layers had loaded:

<@!281958058190700546> That picture renders very differently on my laptop and on my desktop (both Ubuntu 20.04, Firefox).

Oh, maybe not.

I just saw only beginning on one, and the end at the other.

Ouch looks like discord keeps it as palette and updates the palette whenever the gif updates it? That's not what you're supposed to do....

Though I guess that is what would have typically happened in 1989

Allows nice cheapish palette rotation animations too

I believe that the GIF standard actually has some undefined behaviour regarding palette changes 😬

good old encoder bugs

DC is overrated

AC only images are the future

It's the ultimate Dark Mode

Or ultimate light mode

Increase the resolution and you get cyberpunk/neon images

changing color transform code...

Why does it do the weird rectangles of color?

because I'm doing the inverse color transform only on a part of the image 😄

I noticed that on some of my images too when messing with chroma qaulity

(Borders only added to make the color zones more noticable)

Can someone tell me why this happens?

Because you reduced chroma quality by a lot?

Probably the zones align with 256x256 groups

cool, I just wondered why it does that specific pattern

Subsample always go square, true?

Does this count as glitch art? <:kekw:758892021191934033>

Who LiVes iN a Pinapple in the v̶́͗o̵͛̀i̷̊͝d̷̿̉

oops

Mr. Stark I Don't feel so good

somewhat better but still oops

so random but so systematic

it's more fun to just try stuff even if you don't understand how exactly it is being used, and see what breaks

Now I understand

reducing decode memory scratch space a bit, <@179701849576833024> — I think we can get rid of half the scratch space

For DCT?

Yes

on nomacs dct is slow

maybe i'm using higher compression

It works, now checking if it does not make things slower

maybe dct is meant for more cores

the performance especially at creating preview is poor

still x4 faster than the plugin mozilla did

but not enough modular is fast enough for a dual core

modular with 0.3 and s 4 99.2 with 0.3.0 are faster

on my pc modular is 10x slower vardct in decoding

it's placebo effect?

i'm using nomacs with latest qjpeg

dll

the disk maybe is slow RPM, is not a SSD

but anyway i hope it will not be slower

for more compression

i didn't checked without antialiasing effect

but to me seem slow i need to try more with more files

<@!179701849576833024> see MR 3147

the glitch art is what happens if you reuse the wrong block (one that has a stride that causes holes)

modular is super fast to me i can't distinguish the modular to the s 4 q 99.2 of 0.3 in most of cases the decoding speed is enough

<@!416586441058025472> please move performance discussion to e.g. <#803645746661425173> or <#794206170445119489>, I want to keep this a channel with pretty glitch art pictures 🙂

ok

wrong channel i did

I don't know if it's just me, but when I tried encoding **progressive** JPEG XL with Squoosh, it doesn't show... DC (?)

Oops?

that looks like a problem...

Could you share the .jxl file?

I manged to reproduce it in squoosh with another file, so got a jxl file with the issue now. I don't yet know if it's an encoder bug, decoder bug, or possibly something that's only in the jxl version in squoosh and not in latest version

It happens with all input files, no matter what I upload here, progressive JXL encodes are broken.

right, I think it's an old encoder bug

Oh true. Progressive JXLs look fun in Squoosh right now 😄

Lossless progressive looks fine though, interestingly enough

https://github.com/GoogleChromeLabs/squoosh/pull/963

<@!179701849576833024> <@456226577798135808> We published the update to Squoosh that should fix progressive encoding for JXL 🙂

does it support lossless jpeg transcode in the decode or in the encode?

No, in Squoosh we always go via a raw RGBA buffer (for now)

but the codecs are in the repo, that could be a rather easy thing to write as a one-off web app 😄

Which encoder does squoosh use for AVIF?

libaom

oops it was BGR, not RGB

BLUE CAR

I was hoping it would be like the magic bench and change when opened

it's easy to make more of those 😛

yes, the way that I made the green bench was by opening DisplayCAL’s “Synthetic Profile Creator”, starting from the sRGB preset, rotating the channels, and then using ImageMagick to convert the original bench.png to that colorspace with `convert bench.png -profile sRGB.icc -profile BRG.icc magic-bench.png`

I *think* they were referring to the XYB JPEG 🙂

oh :p

SPIHT with implementation mistake

mhhhh, all good to me

Pretty!

Nice, what is that?

Not mine, some phone software fail

Beautiful fail

really wonder what kind of fail 😄

looks like AC of a JPEG on the DC of another one, or possibly just applying exif orientation on only DC or only AC but I wonder how you would end up doing that xD

Maybe a broken progressive jpeg with a decoder that applies exif orientation on the coeffs directly after reading a scan, but forgets to do it if the scan prematurely ends?

not seem a rotatation

Flip is also an exif orientation

Looks like horizontal flip

does this count? (trying to add something to the benchmark)

Remember those dice?

https://discord.com/channels/794206087879852103/794206170445119489/822855207506673714

Here they are after being decoded from `-q 30` .jxl file (not a glitch art at all)...

..but it becomes glitch art when you brutally strip away alpha channel with `pngtopam` and convert it back with `pnmtopng` 😉

magnificent

those dice now look like super heroes flying to their next mission

they're zoomin

“a game of D&D needs our help”

POV: you're playing D&D on acid

the dice have joined the game as NPCs

That's my code that gives invisible pixels some value that is inexpensive and avoids artifacts in the non-invisible part

(just e.g. setting all invisible pixels to black can cause dct artifacts to bleed into the visible part)

This is only done in lossy mode, btw

You mean inexpensive from JPEG XL's point of view?

Yes

Inexpensive for dct, no high frequency stuff there

Because `pngcrush -blacken` (which makes fully transparent pixels black) reduced PNG's filesize quite a bit

<@794205442175402004> Is there something equivalent for modular?

For PNG, what is inexpensive is different, and lossless codecs don't need to worry about artifact bleed

Not yet, would be good to have something for that too, e.g. if you want to do lossless but don't care about the rgb at invisible pixels

that looks like something bad happened to the camera sensor or something

It's a bug with a wasm compiled libwebp

What are those lines?

They look like small greyscale versions of the image

We have no idea, someone was compiling libwebp in the AV1 discord and got that

It looks like its repeating a luma part of the image, but why would it do that?

Chroma upsampling bug?

Also this

the beautiful greens of Cb=Cr=minval

almost as nice as the beautiful pinks of Cb=Cr=maxval

https://www.hdblog.it/img/type99/id965637.jpg?hash=906f6e444bf688958283e41b02cac93d&skip_redirect=1

108 mpx oppo phone with snapdragon 720g

zoom and see the painting

Ugh...

I wish Juha Alakarhu from Nokia came back and showed those amateurs their place

Current phone manufacturers are getting worse and worse in terms of photo naturality

'Adobe RGB / ProPhoto RGB" ? What does that mean? Those are very different spaces...

Error

Ah so it is P3, that's yet another colorspace

interestingly, it doesn’t actually have an embedded ICC profile, though

how i see the jxl art small images made with predictors

https://ss-pics.s3.eu-west-1.amazonaws.com/files/921185/large-2497400_1533063999_saiwa_oro_ciok_al_latte_250_g.jpg?1566895629

Here's a very weird result I got when trying to convert an image to "lossless" HEIC with ImageMagick (converted to lossless WEBP for easy viewing)

I was using "convert (name).png -quality 100 -compress Lossless (name).heic" (this creates similar results for all images I've tested). Here's the original heic file for those interested.

...plus the original image.

oh, *that* level...

I actually stumbled into this room pretty soon after I started playing VVVVVV, and I then proceeded to spend several hours trying to beat it because I occasionally get stubborn about this sort of thing. I eventually got through, I'm pretty sure it's not one of the intended "beginners rooms" of the game, although I had alot of fun trying to beat it!

definitely not 😄 there's crazy people that even do it in "no death mode"...

was trying to figure out how to reproduce the xor pattern using a tree-only jxl

``` if W-NW > -1 /* W >= NW */ if NW-N > -1 /* W >= NW >= N */ if N > 254 - Set 0 /* W = NW = N = 255 */ if W > 0 /* N < 255 */ - W + 1 /* OK */ - W + 1 /* NW < N && NW <= W */ if W-WW-NW+NWW > 0 - NW + 0 /* OK */ - NW - 1 /* W < NW */ - Select + 1 /* OK */ ```

almost there 🙂

Is this image wavy and distorted just for me? Lmao

jpeg xl and jpeg artifact together

Where is the glitch?

i don't remember i did a first modular filtering

but this quality 60.4 faster decoding 3

This channel is for glitch art.

Again, this channel is for glitch art. Completely incorrect encodings/decodings that somehow look artistic.

Compression artifacts are not glitches. Encoder/decoder bugs can be glitch art.

The lastest imagemagick viewer glitch with 16bits pictures It's always the same ref picture that i use on discord ^^

terminating an encode part of the way through a frame produces interesting results: https://cdn.discordapp.com/attachments/587033245061873759/837001025311080488/SPOILER_this_is_fine.webp

Is this jxl?

Or webp/2

neither, AV1/AVIF

You can interrupt it's coding and still get a usable image?

Never knew that

Actually wait yeah I just realized I think

That pattern is similar to video packet loss right

Possibly, but it's more like a connection suddenly dropping. For encoding for lossy transmission (e.g. broadcast), you'd use different settings.

*"Usable"* is a bit debatable, but yeah 😉

Well

Able to be decoded

At least

yeah, I'm not sure but some of that image might be just uninitialized memory being dumped to the screen from the decoder

You can make any decoder replace returning errors with returning the image it has at that point

https://tenor.com/view/reaction-my-eyes-cant-unsee-burn-gif-7225082

look at that video on tiktok, it's an amazing glitch video: https://vm.tiktok.com/ZMe4GExof/

just remembered there's a <#805007255061790730> channel and since I was last here I have more instances of Discord just failing to display GIFs https://cdn.discordapp.com/attachments/834896676170629190/836777290637377566/floofy.gif https://cdn.discordapp.com/attachments/515895985520771075/837084812488605706/cycle.gif

alright wtf is happening in the second one

hmm discord's low-resolution preview has the animation ||https://media.discordapp.net/attachments/515895985520771075/837084812488605706/cycle.gif?width=400&height=192||

I feel like I've seen that effect elsewhere.

guess the file is broken in a weird way so only discord's image resizer sees there's an animation

weird if the domain is media.discordapp.net instead of cdn.discordapp.com the animation plays in a browser

Incorrect

The image's actual animation is a single pixel outside the image boundary for every frame except the 1st, each with its own local colour palette. Discord then applies the local colour palette to the entire image

while other viewers do not

so all viewers know there's an animation, Discord is the one that influences the pixels you see using the animation

> Discord then applies the local colour palette to the entire image yes, "Discord" = "Discord's backend"

the image that discord actually renders (||https://media.discordapp.net/attachments/515895985520771075/837084812488605706/cycle.gif?width=400&height=192||) displays the animation in all viewer's i've tried

and discord's desktop app isn't its own image viewer, it's an electron app. browser discord in firefox also displays the color cycle in your message, because it is asking firefox to render that resized image i linked instead of the actual file that was uploaded

but the bit about the color pallete probably applies to discord's image resizing service

Samsung Gallery cycles through colors, too, just like Google Photos app.

that's wrong though - at least the conventional interpretation of the gif spec is that local palettes apply only to the frame they belong to, and that it is possible to make gif images with more than 256 colors that way

this one works though

On 255 color version I can see steps on all colors except green top and top left square 🤔 <:NotLikeThis:805132742819053610> am I ok?)

yes

same

any guesses what is going wrong here? 🙂

progress

Chroma subsampling.

trying to check if modular YCbCr 4:2:0 / 4:2:2 works properly (it probably does, but I am messing up how I pass the data to the encoder)

some alpha-related mess ups... (trying to implement extra channel upsampling)

amazingly, that image was off by a factor of 255, but it still looks reasonable-ish

Aomenc (not mine)

<:WTF:805391680538148936>

there is many content like that it's so cool but i don't understand how they do it. Maybe in removing I-frame on specific part of video 😄

changing some things in YCbCr chroma upsampling...

From now on, this is how 'lossless' jpeg will look like 😂

I got nearest neighbour upsampling *slightly* wrong xD

https://tenor.com/view/mr-rogers-nightmare-clown-gif-19645113

I have something cool https://cdn.discordapp.com/attachments/587033245061873759/849029570362605598/MORSHU4k_aom.mkv

This is just what happens when your PC isn't powerful enough to decode the video

I believe, I've seen artifacts like this on other vp9 and av1 videos that I couldn't decode in realtime

It's just an encoding bug though <:kekw:808717074305122316>

Bug reports are fun 😆

https://user-images.githubusercontent.com/15923635/120330408-15942480-c2ed-11eb-820c-6c059609529f.png

beautiful

interestingly, the combination actually does kind of work when doing `-e 2`

or not really, it just ignores the lossy palette in that case

ok so it actually works, but the combined artifacts of first doing delta palette and then doing quantization on the squeeze residuals of that are just very extreme 🙂

this is a -Q 95 squeeze applied to delta palette indices

can you guess the original image, <@!179701849576833024> ? 🙂

yes xD

problem is that an off-by-one in a delta palette index can basically ruin the whole image completely

Me too, watched a couple of your videos and slides 😉

Even at -Q 99.9 it's still extremely glitchy

cool artistic effect though

will this become something

this is what `-m --lossy-palette -Q 99.9 -e 4` currently does

like you can analyze something with this

or make a new feature

nah

It's a bug, it shouldn't happen in production software

this is basically like taking a JPEG file (which is already lossy) and then doing a 'mildly lossy' operation consisting of zeroing the least significant bit of every other byte

it's a bug, that combination of lossy things to do is not useful — not sure if it should throw an error, pick one of the two things, or just show a warning

I'm not sure either, that's exactly why I wrote expected behavior in the bug report that way.

maybe just showing a warning is OK, it's an experimental option after all...

Lena 😄

not quite

please use more male sample images 😜

AI fun

i have a bit of a bug to fix before I can make a pull request 🙂

jpeg compression

what you think

do you think jxl can do better at that bitrate

jyrki

wb

In general I think jxl is 30% better than the best jpeg encoder at low fidelity, and 50% better at medium to high fidelity

While avif is 50% better than jpeg at low fidelity, and 30% better at medium to high fidelity

Just roughly speaking, ballpark numbers, ignoring image-specific behavior

For comparison, I think WebP is maybe 10% better than jpeg at low to medium fidelity, same or worse than jpeg at high fidelity. JPEG 2000 maybe 10-15% better (but need a good encoder like Kakadu to get there)

I haven't been comparing it much against jpeg -- I just compare a new version jpeg xl to the current head of jpeg xl 🙂

Sami has occasionally compared JPEG XL to a 6 month or 12 month old (etc) version so that we get an idea that we are not just in hypnosis about many small improvements that actually do nothing

image quality is very subjective and sometimes increments are really small

but 100 0.1 % improvements is already 10 % 😄

(or 106 improvements to be more precise)

to be pedantic, it's only a 2.7% improvement 😛

assuming all those 0.1%'s are compounded

RetrOid, please explain

oh wait, I did math wrong

0.1% ^ 100 = 270%

or 170%

I did the math wong yet again

I'll just uh, leave

it depends on what you mean with 0.1% improvement - is the new size 99.9% of the old size, or is the old size 100.1% of the new size, or is it quality that is 0.1% better by some metric, or whatever

we traditionally measured success in BPP * pnorm (verified with manual viewing, sometimes feasibility only when it actually is a 0.1 % improvement)

RetrOid, 0.999 ** 100 = 0.9048, i.e., 100 0.1 % improvements lead to about 9.5 % improvement

and log(0.9) / log(0.999) ≈ 105.3

(hence the 106 above, I suppose)

?

just what quality i could find on internet

first is banding

Poor quality is not glitch art

glitch art is like those exagone you had while bug in gimp of jpeg

is interesting that no one of the three people did well an encode

Like that only on preview

I am trying to make progressive rendering of modular stuff work again

this is a 1.1 MB lossy modular image truncated to 2000 bytes

looks like it's not properly detecting end of stream and decoding a bunch of nonsense (or maybe showing uninitialized memory)

always funky images when you mess something up

ah lol

was giving the bitreader a range of bytes that went nicely into uninitialized memory

which it happily treats as input bitstream, haha

I was wondering already why it complained about ANS final state

always funny to just hack all error checking away and see what happens

this is the way

We need an option `djxl --berserk` that just powers through any fatal error

https://c.tenor.com/Ue0a6X1iRS4AAAAM/scratch-wound.gif

You'd have at least one user <:kekw:808717074305122316>

It's a fun way to make glitch art: just change a bit and have a decoder that ignores errors

https://tenor.com/view/slip-mood-robot-oops-boston-robotics-gif-17202212

It would actually be cool to do a little error resilience demo

Take a 100k image file in any codec

Make a video, where frame N has the byte at position 100N mutated

See what can or cannot be decoded

I have no Idea how to implement this but it sounds cool to see <:BlobYay:806132268186861619>

The tricky part is hacking decoders to ignore errors and let them just show whatever they can

That's something that is useful anyway though, for forensics and data recovery use cases

I once wrote a small tool to alter some bytes at random in a file, and ran it on ROMs of NES games

I don’t remember for sure but I think I got some amusing results

there was a sweet spot of amount of damage to generate

it seems I had a first version of the script written in perl6, which would only increment or decrement the bytes: ```perl #!/usr/bin/env perl6 use v6; sub MAIN(Int $n, Str $input = '-', Str $output = '-') { my @bytes = slurp(:bin, $input).list; @bytes.pick($n) »+=» (-1, 1).roll: $n; open(:w, :bin, $output).write: Buf.new: @bytes; } ```

and then wrote a ruby version (maybe perl6 was too slow) with a `--violent` flag that would replace the entire bytes randomly:

This abomination from <@!272986016242204672>

<:kekw:808717074305122316>

youtube vp9 1080p btw

<https://youtu.be/N9VPk44zM78>

https://youtu.be/I2OObOM3R_U

<@!224363555074342912> this one is even worse

It's the onion, it might me intentional

no it's not

it was just a normal video a year ago lol

https://youtu.be/b86SSlSJAoM

<@!224363555074342912> reupload lmao

what caused this

looks pretty neat as effect

experimenting with how low one can go with bit allocation in fixed point IDCT

this was too low 🙂

Full size: https://drive.google.com/file/d/1DClrM6XP5hZWcbDKC37qwcKNsnH7JkgJ/view?usp=sharing

This is glitches photo from 108mp sensor

Looks like a disco<a:RicardoRGB:681616487894876170>

What's this one? Another IDCT low bit allocation experiment?

To me it looks like something different

It's a currently still mysterious bug in some experimental fixedpoint idct simulation code

“oops”

is that just way too bright or is something else going on? it looks more funky than just too bright

~~Isn't that negative?~~ It's not. But... it *does* preserve saturation, I guess? 😄

trying to incorporate the HLG OOTF with saturation preservation

well, at least it seems to preserve saturation for sure

haha yes

ah, of course it works better if you only normalize max(r, g, b) to 1 if it is not already below 1

Guetzli bees image?

I accidentally 'optimized' the inverse delta palette transform in a not very correct way, haha

Looks like some Minecraft map I guess <:KekDog:884736660376535040>

i was thinking that too 😄

<:PeepoDiamondSword:805394101340078092>

so I got some RLE wrong...

a message from the deep ✍️

fast JXL opened in XnView. djxl works correctly so I guess I have to update or switch back to IrfanView.

trying a fast decode path for the RLE-only case

that was an off-by-one in the interpretation of the run lengths 🙂

that's pretty <:BlobYay:806132268186861619>

🎶 Every bug is pretty 🎶

did something wrong again

Does this count as glitch art?

https://static.ah.nl/static/product/AHI_43545239373431383534_1_LowRes_JPG.JPG?options=399,q85

https://www.ah.nl/producten/product/wi201961/chimay-tripel

Biggest grocery store in the Netherlands <:KekDog:884736660376535040>

Ok, that image is just cursed

The preview works, but when opened it looks like the image above

And when optimized then the preview looks like the image above, but it also reduces the size with 40%

Probably exif preview image

pretty

Please post that off-by-one bug, <@179701849576833024>, it's one of the nicest glitch-arts I have seen in a long time

LSD visualized? <:KekDog:884736660376535040>

I've managed to create my own glitch art

Is that the same glitch?

not quite working yet

Near-lossless, I would say

lossless 10-bit!

(modulo some bugs)

FTFY: s/modulo/modular/ >3

I did something wrong

again

https://tenor.com/view/the-matrix-reloaded-matrix-reloaded-neo-keanu-reeves-gif-4011236

Get this man a nobel prize for proving the matrix exists

https://twitter.com/richgel999/status/1489728156441448460

Not JXL, but looks interesting 🙂

the background that tried to escape

(this is an APNG)

sus

【ａｅｓｔｈｅｔｉｃ】

truly.

That looks like avant garde music

a large VarDCT image with multiple broken inverse transforms from jxsml 2022-07-01

well not *utterly* broken at least 😄

aesthetic

me trying to do some new smoothened image resizing method

some even earlier larger failure

Question, how do you lads generally do glitch art?

Removing/changing raw bytes in a file hoping to get a result that opens?

at least in my case, by changing the source code of a lib and inserting actual bugs (by mistake) 🤣

organic glitch art

Every bug is beautiful

Some of my older photos got corrupted from a bad SD card...

djxl output on different platforms

Wow, where does that happen? Looks like a big bug...

Ah or wait... That's a 10-bit image, right?

djxl is messed up right now when saving png when the jxl is not 8 or 16 bit

It happened on PowerPC (32bit BIG ENDIAN).

Problem disappeared after I rebuilt highway and libjxl.

https://discord.com/channels/794206087879852103/804324493420920833/1030947597810159717

well that's not what it's supposed to look like <:kek:857018203640561677>

intended output

oo, better

I believe the dark yellow are negative pixels that wrapped around

I have to figure out why the self-correcting predictor is outputting negative values

It can totally do that

Every predictor can

Modular is often storing negative sample values

And even when only used for storing uint data, after modular transforms (ycocg, squeeze, delta palette), the channel data does get negative values too

what happens if the final sample values are negative?

do I clamp them to zero?

in this context the problem is that the tree is outputting a difference of -164 on a prediction value of 65

There should be no clamping done, except in two cases: - alpha should get clamped before blending iff that blendingmode flag is set - when at the very end converting the resulting image to a uint type, out of range values need to be clamped

How am I supposed to present a sample with a value of -99 then?

see earlier art.jxl file that was uploaded

unless I have a bug somewhere I don't know about (which is very likely), the globalmodular stream of that outputs some negative values

when converting the final decoded image to 8-bit RGB (or any uint type), negative values should get clamped to 0 and values above 2^bitdepth - 1 should get clamped to 2^bitdepth - 1

(but conceptually, a value of of -99 is "blacker than black" and e.g. in the case of multiple frames that get blended, it should be treated as such, not clamped first)

better than a crash

every bug is beautiful

was this supposed to make a sierpinski triangle on the bottom <:bjorklul:1033954811839795240>

The bottom image represents desired output, the top represents an error.

This kids is what an XYB image looks like if interpreted as sRGB

don't do XYB drugs kids

well, something's clearly not being laied down in the right order

MMMMMM

Yummy patches

looks like I'm screwing up the DCT in one direction

better

still not perfect (supposed to be all white)

something's happening with the LF coefficients in the lower two groups

(I think)

wait there's only one group in that direction <:Think:813432262166970409>

fun!

fun with DCT

something happened to the HF coefficients <:KEKW:643601031040729099>

progress!

looks like every block is transposed

which, double checking the spec, is specified

Nice kaleidoscope effect

well then, something went wrong <:KEKW:643601031040729099>

in addition to only decoding a single LF group I mean

going around the server for once in a while and this reminds me of these game console firmware/bios corruption vids lmfao