JPEG XL

well, not on its own, it seems

but maybe now it will be better adjustable

yees, it aligns very well now

(that might make it sound like more thorough testing than it is)

“by a constant factor” was a brain fart – there might not be a direct correspondence

I don't think this command exist: --ignore-gain-map

don't seem it is legit.

it indeed works quite well unfortunately it is not keeping all the details

here it is loosing some grass

the complete scan for reference (should have sent it earlier...)

so I searched for quite some time, at first I did not know this was called halftone <:KekDog:805390049033191445> seems like `descreen` filter from G'MIC-Qt for GIMP is quite nice, got me that:

not completely removed, but keeps all the details

I can't say which one I prefer between 1x-Bendel-Halftone and descreen lol

Run the descreen result through an anime AI upscaler, it retains the small details while removing the noise

Here is an example

Processing completed: Screenshot 2014-09-13 15.36.38.png [202/] Processing the image: *.webp [203/] ERROR: unrecognized option --ignore-gain-map

AFAIK, webp does not support gain maps. Maybe that's why

https://arxiv.org/pdf/1803.09165 this work was done before AVIF format was scratched up, of course AV1 was thinking about noise before this, but imho, they parameterized other things that are interesting for image compression

I chose to keep the noise achromatic even though physical processes tend to create more R-G axis noise than luma -- this was by observing how photographers introduce noise into their creations, there were no youtube videos of how to add r-g or b-y noise, only luma, and there were quite a few videos on how to get rid of any chromacity noise, and the golden standard to create 'noisy' real looking photos was to add luma noise only and to complete remove chroma noise

or, iirc, there is a tiny bit of chromacity in the noise synthesis according to "my good taste" at that time

I didn't want to parameterize it as I am not a great friend of believing into super complex configurable systems -- better to build a simple system that 'just works'

if people need something complex they can still store it into an image or create an additional layer having those properties and blend it in ...

a photographer friend (who was a global-level fashion photographer ~10 years ago) used a stock image of a 256x256 tile that they used to create a credible grain noise pattern -- they had obtained it by photographing an empty film

A good read. Is that what `--noise 1` does in cjxl?

I think that flag only works if you specify photon noise too?

nah, it predates photon noise

Did a quick test encode, definitely more chroma noise in the original and larger 'chunks' for lack of a better term, but not bad. Original, `-d 3`, `-d 3 --noise 1`

I think I sorted it:

for i in *.{png,jpg,jpeg,webp}; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; avifenc -a tune=iq -q 60 -d "10" -y "444" -s "0" "${i}" "new_${i%.*}.avif"; echo "Processing completed: ${i} [$current/$total]"; done

for i in *.{png,jpg,jpeg,webp}; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; avifenc -a tune=iq -q 60 -d "10" -y "444" -s "0" --ignore-xmp --ignore-exif "${i}" "new_${i%.*}.avif"; echo "Processing completed: ${i} [$current/$total]"; done

It seems to work now, with all pictures.

In one folder.

Now I guess I have to find out the subfolder thing and run it.

tune=iq don't really know about the different settings.

But I guess it is less.......

of an issue maybe.

hmmmmm

when noise reduction is set to 'low' on my canon mirrorless, it doesn't seem to 'reduce' noise, instead it replaces RGB noise with luma noise. the higher noise reduction settings do start attempting to remove the noise. I can get behind your decision, personally I'm a big fan of luma noise, it can add so much to the atmosphere of an image. I don't like how RGB noise looks at all

hence also my message that started off this topic; viewing an image at a scaled down size causes the averaging filter remove the noise, changing the vibe of the image. I want to see if I can extract the luma noise and have the image viewer apply just the noise at a constant scale regardless of the scale of the image itself, so that no matter how small the image is, it'll always look the intended level of noisy

I live for images like this https://cdn.discordapp.com/attachments/151482247424376832/1335584728757043220/otdzarzwtrc41.png?ex=68209535&is=681f43b5&hm=2255d07344857bb77a362d85851244cc7118228f5cdc4a75f3ff429e366c011f&

I just realised, *technically* you can still get Chroma noise

Set way too high for this image, but just to demo

Lossless disables XYB, but the noise is still encoded as XYB, causing RB noise. Could probably be done for lossy using a dummy lossless layer but I don't have the tools for it

<:galaxybrain:821831336372338729>

hmm I wonder if you could create rgb noise in jxl by putting a copy of the r,g,b channels from an image into individual layers, then applying luma noise to those, then patching those back on to the original image

maybe with the right combination of blend modes. it'd be very hacky though

Also, vaguely related. <@207980494892040194> I stumbled across this https://discord.com/channels/794206087879852103/804324493420920833/1192234113223102535 Combined with this https://kampidh.com/whyjxl, maybe the real blue noise is the dithering we made along the way

Depending on the parameters, we might still be able to make some chroma noise https://discord.com/channels/794206087879852103/794206087879852106/1370760471140896771

thinking of nefarious possibilities like creating an image viewer that intentionally falsely assumes every jpeg xl image is requesting a lot of noise to be added

ooo, anti AI training measure! add a bunch of noise to the jxl images present on your website, but use a custom Wasm based decoder to render them that ignores the noise parameter completely. when the images are scraped and eventually decoded, they'll get the variants with the noise and it might not be immediately obvious that they can ignore the noise parameter to get the original back

wait, JXL's noise is fixed-pattern right? so two images will have identical noise patterns where they overlap? if true that makes it so much better

because I think in AI model training, the noise would usually just average out to nothing in the end, but if every JXL image that's protected this way has the same noise pattern they're going to "constructively interfere" and actually be captured in the image generation model

I've wanted a djxl option to ignore noise for quite a while. Wanted to explore lossless encoding without needing an entire second image/frame for the clean version. Though the XYB noise means it's a bit... Messy

It uses a LUT to modulate the noise, the current default is to mimic Luma photon noise

but the base difference between the noise in this pixel and the next is based on a fixed-seed SRNG no?

You gave me an idea :P ```Width 1024 Height 1024 XYB Noise 0.99 0.99 0.99 0.99 0.99 0.99 0.99 0.99 if g > 0 - Set 0 - Set 0```

https://embed.moe/https://cdn.discordapp.com/attachments/794206087879852106/1370901237792378882/art.jxl?ex=68212ec5&is=681fdd45&hm=3c786218b5fafbb0281901cdf5f3b6edc956f95289392920ef12e8c953e05e66&

I forgot you can use noise in JXL art

Seems this might work for multiple folders - although only for png files at the moment, have to figure out to fix multiple without it breaking - but it seems like it is working: find . -name "*.png" | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif;

Is there a way to have it choose multiple picture formats?

find . -name "*.jpg" | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif;

and an input and output folder with the subfolders.

darkijah<@892795132531838997>-USBSSD:~/downloads/images/D--Book images$ find . -name "*.jpg,jpeg,png,webp" | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif; darkijah<@892795132531838997>-USBSSD:~/downloads/images/D--Book images$ find . -name *.{png,jpg,jpeg,webp} | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif; find: paths must precede expression: `Frontpage1845.jpg' find: possible unquoted pattern after predicate `-name'? darkijah<@892795132531838997>-USBSSD:~/downloads/images/D--Book images$ find . -name *.{png,jpg,jpeg,webp}; | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif; bash: syntax error near unexpected token `|' darkijah<@892795132531838997>-USBSSD:~/downloads/images/D--Book images$ find . -name "*.{png,jpg,jpeg,webp}" | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif; darkijah<@892795132531838997>-USBSSD:~/downloads/images/D--Book images$

I don't know

lets try this: find . \( -iname "*.png" -o -iname "*.webp" -o -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.bmp" \) \ | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif

althouigh tried to make an input output thing but did not work.

darkijah<@892795132531838997>-USBSSD:~/downloads/images/M--Images/webp$ for i in *.webp; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif "${i}" "new_${i%.*}.avif"; echo "Processing completed: ${i} [$current/$total]"; done Processing the image: 037bfe49-5b6b-4f1e-b319-1ff37f039b90.webp [1/] Unrecognized file format for input file: 037bfe49-5b6b-4f1e-b319-1ff37f039b90.webp Cannot read input file: 037bfe49-5b6b-4f1e-b319-1ff37f039b90.webp Processing completed: 037bfe49-5b6b-4f1e-b319-1ff37f039b90.webp [1/] Processing the image: 04-19-05.webp [2/] Unrecognized file format for input file: 04-19-05.webp Cannot read input file: 04-19-05.webp Processing completed: 04-19-05.webp [2/] Processing the image: 0c4th5s2y0g71.webp [3/] Unrecognized file format for input file: 0c4th5s2y0g71.webp Cannot read input file: 0c4th5s2y0g71.webp Processing completed: 0c4th5s2y0g71.webp [3/] Processing the image: 16228.webp [4/] Unrecognized file format for input file: 16228.webp

It seems to have issues with webp file formates?

darkijah<@892795132531838997>-USBSSD:~/downloads/test/New Folder$ avifenc -q 60 "The world councils by Ian Paysley.webp" output.avif Unrecognized file format for input file: The world councils by Ian Paysley.webp Cannot read input file: The world councils by Ian Paysley.webp

It can't do webp files???

Is this buld not made with webp support?

build

Hoew retarded is that..... if it does not support webp

It literally heals some of the jpg damage

Much of the jpeg noise is gone.

So is there a way to combile it with webp support?

No, supporting webp would require coding effort on your part

sucks

how can a so popular format not be supported.

is png not lossless?

for i in *.webp; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; dwebp "${i}" -o "new_${i%.*}.png" -lossless; echo "Processing completed: ${i} [$current/$total]"; done I thought it was lossless by default

darkijah<@892795132531838997>-USBSSD:~/downloads/test/New Folder$ for i in *.webp; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; dwebp "${i}" -o "new_${i%.*}.png"; echo "Processing completed: ${i} [$current/$total]"; done Processing the image: H264-VP9-AV1-Quality.webp [3/] Decoded H264-VP9-AV1-Quality.webp. Dimensions: 1000 x 438 . Format: lossy. Now saving... Saved file new_H264-VP9-AV1-Quality.png Processing completed: H264-VP9-AV1-Quality.webp [3/] Processing the image: The world councils by Ian Paysley.webp [4/] Decoded The world councils by Ian Paysley.webp. Dimensions: 300 x 420 . Format: lossy. Now saving... Saved file new_The world councils by Ian Paysley.png Processing completed: The world councils by Ian Paysley.webp [4/]

PNG is in 99.99% of cases lossless, yes

for i in *.webp; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; convert "${i}" -quality 100 "new_${i%.*}.png"; # Enforcing lossless conversion (100 quality) echo "Processing completed: ${i} [$current/$total]"; done

ahh I guess it is the webp that is lossy.

how do I maximised compression of png?

oxipng -o max

with what app?

a little example would be nice.

https://github.com/shssoichiro/oxipng

It’s a command line tool

Yea I kinda guessed that.

the AVIF is 6KB better then the webp.... although not sure about the difference in the quality. Most likely not noticeble at all.

FYI your console output will be better formatted (and retain its `*`) if you write it as (let’s hope I don’t mess up the nesting): ```markdown ```console for i in *.webp; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; convert "${i}" -quality 100 "new_${i%.*}.png"; # Enforcing lossless conversion (100 quality) echo "Processing completed: ${i} [$current/$total]"; done ``` ```

well, I tried

the final triplet of ` should have been inside the block

you can use `bash` for pure bash code or `console` when it’s a mixture of prompts, commands and program output

this example with `bash` looks like this: ```bash for i in *.webp; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; convert "${i}" -quality 100 "new_${i%.*}.png"; # Enforcing lossless conversion (100 quality) echo "Processing completed: ${i} [$current/$total]"; done ```

*Processing the image: 01-01111TEXT.bmp [13/] Unrecognized file format for input file: 01-01111TEXT.bmp Cannot read input file: 01-01111TEXT.bmp Processing completed: 01-01111TEXT.bmp [13/] Processing the image: 01-1111TEXT.bmp [14/] Unrecognized file format for input file: 01-1111TEXT.bmp Cannot read input file: 01-1111TEXT.bmp Processing completed: 01-1111TEXT.bmp [14/] Processing the image: 01 - text.bmp [15/] Unrecognized file format for input file: 01 - text.bmp Cannot read input file: 01 - text.bmp Processing completed: 01 - text.bmp [15/] *

compile this and that and what not.

https://www.vanityfair.it/article/elmira-35-anni-mamma-avvocato-non-ho-mai-smesso-del-tutto-di-lavorare-mi-hanno-detto-che-ero-pazza-fatto-per-non-andare-fuori-di-testa

stinking linux. Always always and more always

What is this memory thing..... that seems a lot.

Size in memory

300 mb

Compressed images still have to be decompressed before they can be viewed, so they require Width x Height x Bitdepth (Total, not per channel)

<@794205442175402004> how does Cloudinary resize images? I’ve seen NN resizing stuff but I don’t know if any of it is used in practice

Like: https://github.com/Fivefold/SRCNN

We use a few different ones, all classic ones for downscaling (mostly just Lanczos or Mitchell, though we also have a fancier detail-preserving downscale method). For upscaling we have some AI stuff but I don't know any details.

I don't know if there's any image hosting service offering upscaling

any of the downscales proprietary?

I implemented two downscalers for Cloudinary that are not (or not yet?) open sourced, one is just Mitchell in linear RGB with some post-sharpening so you could do something pretty similar with imagemagick, the other is a fancier detail-preserving method.

both seem very cool, that's interesting!

“neural” would be less ambiguous than “NN” which for resizing could mean “nearest neighbour”

why is it saying that the AVIF images are 16 bit and the originals are 8 bit?

Like I thought I did 10 bit.....

Like this is a mess of confusion.

Like first one says 8 bit and the next says 16 bit

That's the canvas, the 10 bit image is displayed on a 16-bit canvas

aha.....

so even if I did 8 bit the AVIF would 16bit canvas.

so whether 8 10 or 12 it would show it as 16 bit canvas

By the way, 3 different images and yet each of them take the same size in the memory - apparently.

303.1MB

I guess it is as it is.... the images are bigger then the usual images I have in resolution so..... But still surprised it would take so much - maybe it is only when it is in Gimp.

like if it stores it in the RAM that is a lot.

oh well... we sure use a lot of RAM these days overall.

In ever thought I would use 24GB of RAM, but lo and behold....

If you are willing to provide a source image and target resolution(s), I'd love to demonstrate my own fancy detail-preserving downscaling method, which I think works extremely well. I wonder if it's a similar approach...

Some sizes test from the originals to AVIF

https://www.youtube.com/watch?v=R2ZWzaNCEVU

my biggest concern was the size of the files but 8 bit and 10 bit with the things I have on, the 10 bit are the smaller ones.

So the canvas is able to do 16 bit but the highest is 12 bit for avif and av1 and we can't even comprehend the many colors in 12 bit if used..... am I getting this correct?

Yes, 8-bit all-intra aomenc has some special optimizations that tend to produce larger files. 10- and 12-bit AVIF should be very similar in size, though...

Ahhh, okay - yea well I absolutely want the smallest files and getting the positive things of 10 bit as well then.

I have not tried 12 bit to check what I get, but I did note bigger files at 8 bit which I was surprised about.

Well, you want efficiency, size or quality is regulated through the user parameter. But 10-bit is more efficient for lossy encoding.

Yea I am doing lossy encoding.

Like 1/10 of the original sources for a lot of files. very good.

I did go from 50 to 60 as there was some square box issues.

I think 60 quality takes care of them all, at least not seen any as for yet.

What would you gain with 12 bit encoding, anything at all?..... Like if you are going from jpeg which apparently is 8 bit to 12 bit probably would do nothing I guess..... I have not checked any loading times yet.

Undithered 10-bit still produces some very subtle banding, which 12-bit would prevent. However, considering you're probably doing some substantially lossy encoding, those extremely subtle banding artifacts probably aren't very relevant. More importantly, most image viewers don't dither, and most people only have 8-bit screens, in which case all benefits of 12-bit encoding are practically eliminated anyway. What is relevant, however, is that 10-bit AVIF is easier to decode than 12-bit AVIF.

Definitely use 10-bit then.

Hmmm yea okay. Would be interesting to see if 12 bit would make any bigger loading time overall on the website..... But yea 10 But seems to be the way.

Minimally better preservation of smooth gradients. And only perceptible if your image viewer dithers or you're viewing on a high bit depth monitor.

Yea okay.... Probably not going to happen.

Web browsers don't dither high bit depth images to 8-bit. So, yeah, 10-bit is the way to go here. Or 8-bit for maximum compatibility I guess.

Many of the screenshots is low quality material as well.... Overall.... But just for fun I would like to test the 12 bit for the website. If any decoding difference can be felt.

I could do 85 Q but for my website.... I don't think it is even needed.

Like rather have some faster speed bandwidth then higher quality.

Wait, what settings do you use? Just wanna see if those could be improved.

Here is my latest upload: http://jesusgod-pope666.info/images.php

If you can wait 5 minutes, I am on the Pope throne at the moment 🙂

I am still looking into making an input output folder thing like I have working for subtitles app terminal thing.

find . \( -iname "*.png" -o -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.bmp" \) \ | parallel avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif {} {.}.avif

I don't think bmp is supported so probably going to take that off.

---

for i in *.{png,jpg,jpeg,bmp}; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif "${i}" "new_${i%.*}.avif"; echo "Processing completed: ${i} [$current/$total]"; done

again bmp should probably be removed.

no idea why avifenc would not support standard images, kinda sucks.

like webp and bmp

avifenc -a tune=iq -q 60 -d 10 -y 444 -s 0 --ignore-xmp --ignore-exif "${i}" "new_${i%.}.avif"

anyone know how to search for specific files like in windows *.avif - how you do it in linux in thunder filemanager.

Looks good, but you might want to consider using -s 1 as it's much faster but performs pretty much the same at good quality. Also, you might want to use `-y 420 --sharpyuv` instead of -y 444. Will probably give mixed results regarding efficiency, but will make decoding twice as fast.

Not sure about that.... someone said to use 444. And it seems to be the full flavour...... Although as I understand it makes files smaller.

Speed is lessor of concern but I have not tried 1 compared to 0.... I could check that out.

My computer is already so slow so it takes forever 😛

1 is just faster in encoding correct?

not decoding.

right

rogher.

what is sharpyuv?

It performs better chroma subsampling, scaling in linear RGB instead of doing that directly on the chroma planes.

Resulting in 4:2:0 subsampling that looks much closer to 4:4:4 than you would normally get.

okay, dunno.... hard to know all the different stats.

I'll try the speed of -1 and see how it goes and the output.

I am not sure the decoding is the issue overall, it seems to go pretty quick on those levels.

Overall on my website the biggest issue seems to be getting the data down - the decoding seems to go pretty speedely after it has downloaded the 200 images.

and I am running slow devices.... but overall as far as I can see it is the data stream that is the issue, how much it has to download.

for i in *.{png,jpg,jpeg,bmp}; do ((current++)); echo "Processing the image: ${i} [$current/$total]"; avifenc -a tune=iq -q 60 -d 10 -y 420 --sharpyuv -s 1 --ignore-xmp --ignore-exif "${i}" "new_${i%.*}.avif"; echo "Processing completed: ${i} [$current/$total]"; done So this would be closer to what you would want?

I don't know.... I did see something about 444 and it seemed to be better on getting the right colors.

does sharpquv work on all levels

sure, but that of course very much depends on the decoding hardware

yea but i am on really low hardware, and it still seems pretty good.

Chroma subsampling can reduce raw image data to half with minimal loss (on natural images at least), before the actual AVIF encoding is done. And sharpyuv performs significantly better chroma subsampling. Thing is, AV1 is primarily optimized for 4:2:0 chroma subsampling, so lossy 4:4:4 encoding is often less efficient, although tune iq mitigates a lot of that.

these type of images are good test images for detail-preserving downscaling.

https://upload.wikimedia.org/wikipedia/commons/6/60/Thrift_Store_Express_Jeans.jpg

this is what my method does with it: https://res.cloudinary.com/jon/image/fetch/w_300,f_png,q_100/https://upload.wikimedia.org/wikipedia/commons/6/60/Thrift_Store_Express_Jeans.jpg

(when downscaling to 300 px wide)

compared to simple lanczos downscaling, which produces something like this: https://res.cloudinary.com/demo/image/fetch/w_300,f_png,q_100/https://upload.wikimedia.org/wikipedia/commons/6/60/Thrift_Store_Express_Jeans.jpg

Not sure I need downscaling as it is for now.

chroma subsampling is what is used by standard and what I am using at the moment?

Since you specified `-y 444`, there is no chroma subsampling. Which is great for some types of images, or near-transparent target quality, but for your usecase, `-y 420 --sharpyuv` (4:2:0 subsampling means half resolution on the chroma planes) will probably perform slightly better overall, with the benefit of better decoding speed.

Not sure what the default is with avifenc.

``` -y,--yuv FORMAT : Output format, one of 'auto' (default), 444, 422, 420 or 400. Ignored for y4m or stdin (y4m format is retained) For JPEG, auto honors the JPEG's internal format, if possible. For grayscale PNG, auto defaults to 400. For all other cases, auto defaults to 444 ```

Going to make a test folder run. going to take some hours on my computer. but it is producing something at the moment.

here's mine:

I really liked this one for testing downscaling

half-resolution version

ooo, is that at all similar to this? I was thinking about this earlier https://discord.com/channels/794206087879852103/794206087879852106/1370349223173951518

the goal, for context https://cdn.discordapp.com/attachments/794206087879852106/1370338905995608114/image.png?ex=6823178e&is=6821c60e&hm=e2408b1cdbe29795e14f30f7ef9f983390a1e83e521bed335bad79d1611e1986&

My method basically attempts to preserve not just the average pixel value of each region that gets downscaled into a single pixel, but also the local stdev. Or at least it goes in that direction. So noise doesn't get smoothed out but gets preserved, kind of.

My method is more fidelity-targeted. Butteraugli tends to like it more than anything else I know of. Also very sharp while staying pretty much artifact-free... <:Perfect:991312615194234981>

The process involves a lot of Gaussian blurs and the nyquist theorem.

how do you benchmark this using butteraugli? I assume it doens't have a mode to test specifically this. how do you generate the downscaled ground truth reference?

or am I misunderstanding how butteraugli works

Point upscale to original resolution. Of course only works properly with 1/n scale factors.

For other scale factors I guess you could do Point upscale to a common multiple of both resolutions for comparison. 😅

Other upscaling methods would also work, of course, but it would warp things in ways that doesn't reflect the actual viewing experience anymore, so Butteraugli score might not be representative there.

interesting!

thinking about it, this is sort of the opposite of what AMD FSR (the non-ai one) tries to do. take an image and upscale it using some contrast and...something else, not entirely sure how it works

I wonder if FSR is simple enough that it can use used as an upsampling mode in JXL. or maybe a simplified version of it?

Looks like the "pop" filter in google photos

Looks quite visually appealing not gonna lie

interesting! have you tried downscaling stills with film grain? does it make the film grain bigger to preserve variance?

I see that the denim texture features become "coarser" after downscale

FSR 1 is a tuned Lanczos, why not use Lanczos?

It preserves local variance so something like a sky with photon noise will downscale to something that still looks like a sky with photon noise, instead of a smoothed out version of the sky. Whether that is a good thing or a bad thing of course depends on your needs/expectations.

this makes sense, thanks

It's of course physically incorrect in a way, since it is equivalent to making the size photon noise a lot larger in terms of original image dimension pixel area. But then again it often does work to better convey the real texture

indeed, there's a tradeoff between feature size and energy preservation

the reason this caught my attention is because surprisingly, a similar phenomenon happens in video encoding with film grain retention

It's a bit like how NN resampling can look sharper than better downsampling methods — except with NN you will often get aliasing issues and you're just throwing away lots of data. My method avoids aliasing better and does use all data.

it's overall better to make the film grain appear "bigger" as you approach the lower bitrate end in order to preserve overall energy, instead of fully collapsing it into flat blocks due to too harsh quantization into the high frequency coeff area

It's the trade-off between pretending you keep the camera where it is and the resulting photo as it is and just increase the viewing distance (that's what usual downscaling does), and pretending the camera is further away so the photo is different and the region of interest becomes smaller so you crop it — then things like film grain and photon noise (and maybe also some of the texture of the actual scene) will be different than in the case of just going further away from the image.

I think

yeah, I can follow the train of thought here

I hope you can open source your fancier detail preserving downscaler at some point!

that said, for more extreme downscaling (>2x), I can see value on ramping down the strength on variance preservation

otherwise, the resulting textures could end up being too far removed from the original

Yes, there's a balance there. Best is to mix both approaches a bit.

if it lifts the noise from very high frequency to a lower frequency it can have semantic interpretability difference such as the thickness of thread in the cotton, or roughness for touch interpretation differences -- if I had an estore I'd just benchmark what works best (and monitoring both sales and returns)

Let's ironize my autism

https://www.tuttobiciweb.it/article/2025/05/13/1747124327/ciclismo-dipendenza-bradley-wiggins-tour-de-france

The main thing it is trying to do is avoid the smoothing you usually get when downscaling, where any texture just becomes flat. There's no way to get around the problem that there just aren't enough pixels to preserve the original image, but some of the 'feel' can be preserved better by preserving local variance. The goal is to convey already in the product gallery page with all the thumbnails some of the texture of the full resolution image (that is on the product page you get if you click on one of the thumbnails).

E.g. it's not unusual for some fabrics to have some texture or print pattern that is high-contrast high-frequency, and a normal downscale (say a 10x downscale that reduces a 10 Mpx image to a 0.1 Mpx thumbnail) would just completely remove that and replace it with some average color (where the average can be quite wrong if you don't do it in linear space, but that's another issue). Keeping some of that variance is 'wrong' (and can introduce problems like Moiré) but it can semantically feel more right than the usual smooth downscale.

I prefer vp9 and av1. Jxl stuff I don't like why sorry you think I abolish the SW but is not that intention

Unfortunately Krisna Rapana and my cousin started new activity both 5 6 yrers ago

So YouTube is having a confusion

Luckily me and other ocd people developed the best subliminals ever

And libjxl now looks amazing

Hi! I have a question regarding jpegxl lossless mode: in modular transform the used wavelet is (a+b)/2 for the low pass with ceil/floor depending whether a or b is larger. What about high pass coeff and how you would decode this wavelet backwards? I can't reason this out because I'm trying a high pass filter bank with formula of (a-b) however I cannot reproduce the tree this way

I'm ignoring the tendency term for now

high pass is just a-b (- tendency term)

reconstruction is just a = (a+b)/2 + (a-b)/2, b = a - (a-b)

Tendency term is a form of lifting scheme for the wavelet right? It will lower the entropy of encoded wavelet tree comparing to a tree without it

The reconstruction is lossless even though there are two integer divisions by two going on there. - if a+b is even, then a-b is also even so the divisions are exact so there is no issue. - if a+b is odd, then a-b is also odd. If a>b then the rounding up of the (a+b)/2 term compensates for the rounding down of the (a-b)/2 term. Otherwise a<b (they cannot be equal or a+b would be even), and then (a-b) is negative so (a-b)/2 rounds up while (a+b)/2 is rounded down,

And yes, the tendency is basically applying a linear interpolation prediction to the (a-b) residuals, made nonlinear by conditioning it on local monotonicity. This helps to lower the entropy in the lossless case, but most of all it makes it possible to use it in a lossy way by quantizing the highest frequencies. Without the tendency term you would get a blocky mess if you simply quantize...

Crop of an image compressed to 0.4 bpp using the Squeeze transform with quantization of the residuals. From left to right: 1) no tendency term at all, 2) an unconditional linear interpolation tendency term, 3) the nonlinear tendency term used in JPEG XL, 4) original image, for reference.

no tendency term produces obvious blocking/pixelation. tendency term that is just simple linear interpolation produces obvious ringing. tendency term as it is in Squeeze better balances the artifacts: the condition helps to avoid ringing, the interpolation helps to avoid blocking.

thanks for the explanation! this clears a lot

also by any chance, are there any measurements for lossless encoding bpp with and without tendency term?

Haven't tried that in many years; in general lossless bpp is usually lowest when not doing squeeze at all and encoding non-progressively. Should be easy enough to try it out though, just hack a libjxl where the function computing the tendency term returns 0 instead...

very interesting, this indeed looks like a good test image

Yeah this `https://res.cloudinary.com/jon/image/fetch/w_300,f_png,q_100/` is a universal converter for any link!

Pitiful that JPEG 2000 and JPEG XR aren't available but BMP (losing Alpha however) is available

||https://res.cloudinary.com/jon/image/fetch/w_300,f_png,q_100/https://upload.wikimedia.org/wikipedia/commons/3/3f/GPT_Test_Plugsuit_High-Exposure_Type.png||

good use for photon noise synthesis. these noise patterns come as large PNGs. if they were JXL they could've been really small

To be fair, they only weigh in at around 10kb

The rust foundation SVG is actually much larger than the PNG noise files lmao

It's not a lot but it adds up. depending on how many requests they serve

True, but the SVG is actually 20 times larger than the noise PNG

crazy

that's surprising

Actually massive

the SVGs are sent to browsers as Brotli compressed although even with the size reduction from that the SVG logo still ends up being larger then the noise PNGs lol

actually wtf the noise "PNGs" are being sent over to my browser as WebP 🤷

they aren't even PNG files

Probably cdn behaviour

Try spoofing your accept header

I need to know something: Why is center-position 1/2-factor scaling not the same for Bilinear and Box? I never understood that.

Like, shouldn't Bilinear simply deliver the average of the four neighbouring values in this case? Just like Box?

When downscaling a 4x4 checkerboard image ``` 1.0 0.0 1.0 0.0 0.0 1.0 0.0 1.0 1.0 0.0 1.0 0.0 0.0 1.0 0.0 1.0 ``` with Bilinear I would expect output values to be ``` 0.5 0.5 0.5 0.5 ``` But that is not the case for some reason. Top-left and bottom-right were of a visibly different shade than the other two. And the output was even visibly different between bilinear implementations (imagemagick, zimg). This all makes no sense to me.

Implementation details tend to be different for these things, especially in how they deal with the edges. Duplicating vs mirroring vs zeroing the edges makes a big difference, for example.

Yes, I also thought of edges. But, I don't see how edges are relevant in this specific case with bilinear. Isn't every new value here the result of only four original values?

I would think so, but I am not sure how exactly ImageMagick etc implement it.

What do you get when downscaling a larger checkerboard?

I bet it has something to do with edges. If you duplicate at the edges you get ``` 1 1 0 1 0 0 1 1 0 1 0 0 0 0 1 0 1 1 1 1 0 1 0 0 0 0 1 0 1 1 0 0 1 0 1 1 ``` which could result in the downscaled image getting higher values in the top left/bottom right pixels than in the two other pixels...

Hmm, but I don't see why those extra values would influence anything with bilinear...

ok, looks like I cannot reproduce with a larger checkerboard image, huh

They shouldn't, but I wouldn't be surprised if they somehow do, if there is no special case for exactly 2x downscaling but it's all a general code path for arbitrary factors

Either way, I still don't understand how Box downscaling looks so much better than bilinear downscaling for 1/2 scaling. The way I understand both scaling methods, output should be identical.

https://usage.imagemagick.org/filter/#box

Box and Triangle/Bilinear are the mathematically simplest of all scaling methods after nearest neighbour, so I want to understand at least those properly 💀

Yeah it's a good question. Maybe it can boil down to different conceptions of pixels: do their values correspond to the center of a small square, or to uniformly spaced sampling positions on a grid where the top left pixel is at the top left corner and the bottom right pixel is at the bottom right corner?

The first interpretation makes the most sense to me and is how all image editors etc present images, but I think the second interpretation is also used

Yes, I always assumed the first case.

But, how I understand it, both box and bilinear should produce a simple average for every 2x2 pixels when doing 1/2 resolution downscaling... Assuming target sample position is in the center, which it normally is for scaling.

However, in practice, bilinear and box look very different for this scenario.

Box is the sharper one

scaled in linear light

`-colorspace RGB -filter Triangle -resize 50% -colorspace sRGB -dither FloydSteinberg -depth 8` `-colorspace RGB -filter Box -resize 50% -colorspace sRGB -dither FloydSteinberg -depth 8`

imagemagick

I'm starting to think it can only be the sample position...

`-distort Resize 50%` performs better than `-resize 50%` <:Thinkies:987903667388710962>

I think I have enough of imagemagick for now...

oh, yes, the documentation seems to touch on this

> If you look along the bottom edge of the rose, you will see that the Distort Operator actually produced a better cleaner result than the Resize Operator. […] However remember that Distort is much slower than Resize, as it uses a more direct but much more complex Area Resampling technique, without the 2-pass speed optimizations that resize uses.

https://usage.imagemagick.org/resize/#distort_resize

TIL

brb I’m going to reprocess all the images I’ve ever applied `-resize` on

No, that is definitely always center, I just tried non-center, and everything was visibly shifted.

for downsizing, I’m not actually sure `Distort` is better

the result of `resize` seems sharper

well, it's a very small difference anyway, and I only tested with bilinear

Looks like almost all the bilinear scaling out there has little to do with bilinear interpolation, first step appears to be triangle-shape convolution over +- 2 px distance.

Which explains the blurriness, of course...

So, something like 2 - |(x - x0)| * 2 - |(y - y0)| to get all the relative weights for the neighboring 4x4 pixels.

I think anything where the kernel weight computation only involves linear stuff could be called "bilinear", just like "bicubic" can mean a huge amount of different things that only share the use of ^3

https://www.cs.utexas.edu/~fussell/courses/cs384g-fall2013/lectures/mitchell/Mitchell.pdf

Right, bilinear is fine as a term, actually... Not sure about bilinear interpolation, though... Because that's not really what happens.

Bilinear filtering?

dang, that's old <:woag:1070464147805970432>

I guess often it's seen from the perspective of upsampling, where it's interpolation. When downsampling, "decimation" is sometimes used which kind of makes sense

SIGGRAPH'88, lol

It's good that I live in 2050, because they're discussing interpolation using algorithms from 50 years ago again. box (fant) is really better for downscale, but for video I use spline36. there are fewer artifacts than lanzcos and fewer blures than bicubic. for 1080p -> 720, this is ideal. but box is better with pictures, there are zero artifacts, only problems of subjective perception, which makes the picture seem not so clear. but its perfect, though.

The main issue is that the image viewing will not occur at the same size, pixel by pixel, making the selection of algorithms extremely useless and meaningless. The image will still be rescaled using some bilinear method, after which the artifacts from Lanczos will be much more noticeable, and the blur from bicubic will be quite apparent. The second problem is compression... Even effectively using Lanczos when sending content that is not art to a place with high compression, such as Telegram. Despite being able to use a perfect 1280x1280 canvas and guarantee quality, smooth, perfect box pieces will simply compress more. Although with Lanczos, due to artifacts, there will be more information at the edges of objects...

box is better for stickers because webp does it better. and for jpeg, lanzcos or bicubic is better, in order to provoke the encoder to give out more information on the current quality parameter.

i also use Hanning interpolation for downscale

but there are still no solutions. if it is possible not to interpolate, don't do it. or make sure that the size is reduced at least 2 times. then it has a profit. and it definitely doesn't have blure because of the concentration of information. Then it's just a matter of what type of artifacts are acceptable to you personally.

lanczos is a tuned bicubic...... the difference in the shape of the window

Lanczos is based on sinc, not bicubic

yeah...

only 2-tap Lanczos is Cubic-like.

Should be pretty close to Catmull-Rom I think...

I mostly see horrible compression artifacts in the second pic...

Yes, that's right, true, you caught me—this is exactly where I went wrong.

When FSR was released, I thought, "Finally, they've made madVR NGU available for everyone." But no, that's not the case... madVR NGU Sharp still remains an interpolation performed using arcane tricks that have been around for 10 years, and no one has even come close to matching it.

What is this madVR thing, actually?

algorithms that were created a long time ago, but still can work even better than neural networks. This is just —Spline-S —Ngu sharp their whole problem is commerce, they sell the first one, and you can only see his work by stealing. and the second one is closed, although it is free, it is written on DirectX shaders.

mpc-hc addon

I use ewa_ginseng for upscaling...

What?

in mpv

in mpv I also use FSR

in my testing so far (for 800% upscaling), I think my preference goes to `-filter Jinc -define filter:support 8 -distort Resize 800%x800%`

(but not for downscaling – I haven’t determined which one I prefer for that yet, but that’s likely not it)

on second thought, maybe `-resize` instead of `-distort Resize` – tends to be less artifacty

<@794205442175402004> im back with my cloudinary question of the week, hah libjxl uses highway so I guess this is less relevant, but do you know if all the server hardware you use for encoding is AVX-512?

or AVX2 at least, maybe?

Yeah it's avx-512 but we are compiling libjxl without it because we suspect there might be bugs specifically triggered by avx-512 (since the well-tested simd variants are all less wide). The speed difference between avx2 and avx-512 doesn't justify such risks right now.

would this be a libjxl issue or a highway issue? iirc the highway SIMD intrinsics are platform/extension agnostic?

No idea, could be there is no issue at all in libjxl but we did see some bad behavior in jpegli and the HDR tone mapping tools that come with libjxl when compiling with avx512. Could be a question of insufficient padding or something like that (some accidental assumption that 8x32 bits of padding is enough), or some bug in highway or in clang, I dunno. We haven't bothered yet to investigate.

Interesting

this is a really cool video https://www.youtube.com/watch?v=xDLxFGXuPEc

it's about blurring, and de-blurring by dividing the image by the blur kernel instead of multiplying it

it makes sense that it's possible in hindsight but I never would have thought this was possible before, I thought blurring was a strictly destructive process

We watched it together in the Voice Channel this morning "Hey I know this part!"

oh nice :D

Sharpening is just the opposite of blurring, but information does still get lost and you cannot sharpen back detail in regions that are smoothed to oblivion...

I see that Technology Connections guy has a new channel 🤔

Huh, never noticed that before

I suspect the reason that if you blur too hard you won't be able to recover detail eventually, is because of quantization?

e.g. if your data theoretically is real numbers without precision limits it doesn't matter how strong the blur is, and you'll always be able to recover it

actually, no, because a very strong blur over the whole image could turn every pixel the same...

or could it? maybe it depends on the blur implementation too. it's hard for me to reason about, I can't see at which point the blurring is too much and data becomes unrecoverable

not possible

this is infinite sigma

a gaussian blur is by its nature invertible (without precision issue)

to visualize it

you can see the FFT effect of a gaussian blur

basically multiplying by a gaussian kernel the FFT

you can completely revert these factors

and well, infinite sigma is different since you cannot divide by 0

ahh I understand. neat

In practice though, you use a convolution kernel that is small and a precision that is finite.

well, not possible if you want to call it a gaussian blur, but definitely possible to blur an image in that way

Math yes, in engineering no

I was answering a theoritical question indeed ^^

It is in practice due to precision loss.

yep yep

I think averaging all pixels is my preferred way of blurring sensitive information. second is black bar, but can look too out of place

I wonder how Signal's face blurring feature works. If it's reversible then maybe I should create an issue ^^

I tend to use GIMP’s “Pixelize” filter

adjusting the block size until it looks “right but not leaking too much”

there are machine learning models (one from Google I believe) that can reconstruct faces from non-scrambling pixelating filters, and there are also tools for recovering the original text from pixelated segments in screenshots. you can possibly also recover the text from a small segment where all pixels are averaged, though thankfully there are only 256 shades of gray in most screenshots so while I wouldn't hide someone's name that way - the length of the name alone might even be a good enough giveaway if the font isn't monospaced - it's probably fine for longer snippets of text

Are they better than this?

R-c-st learning

Why can't I decode this file with JxrDecApp? https://cdn.discordapp.com/attachments/615105639567589376/1376816652687118336/Screenshot_2025-05-26_00-24-30_058.jxr

I always get an ``` *** ERROR: Unsupported format in JPEG XR *** ```

even with the exact example command

How did you get the file?

someone on the AV1 discord posted it

I vaguely recall NVIDIA software creating JXRs that were either unreadable, or only via Windows and not the reference library. Can't remember any details though

that would make a lot of sense...

Windows Photo viewer can show them

it appears to be a screenshot

so that fits

The JxrDecApp does not always automatically choose the correct pixel format. You can try specifying manually

But some JXRs cannot be decoded at all by JxrDecApp

Those jxr cli tools are extremely brittle and annoying to use

I think they were made just because they needed some reference implementation when they were rubberstamping wdp into a jpeg standard, so they quickly made something that somewhat worked and then abandoned it completely.

I just use magick lol

jxrlib even can't read PNG

tiff and BMP are all a man needs

converted via nomacs on Windows.

Huh, interesting image... Also massively blown out as the AVIF

hey, could you show me how to get the file conversion preview for nomacs? like the one demonstrated here? https://github.com/nomacs/nomacs/issues/292#issuecomment-644237409

the source image is a scRGB image

so that is to be expected to some extent

wait, how *did* you try to decode it?

Use "Save As" from File menu and the preview appears after typing filename and selecting type. Note: not all formats have the preview dialog.

interesting, magick identify reads it as a srgb image ``` Channel statistics: Pixels: 8294400 Red: min: -60.0928 (-0.000916958) max: 822259 (12.5469) mean: 9546.61 (0.145672) median: 59.6866 (0.000910759) standard deviation: 55674.1 (0.849533) kurtosis: 85.2372 skewness: 8.71022 entropy: 0.704312 Green: min: 0.964829 (1.47223e-05) max: 822259 (12.5469) mean: 12271.4 (0.187249) median: 266.246 (0.00406265) standard deviation: 67066.8 (1.02337) kurtosis: 70.0362 skewness: 8.07073 entropy: 0.838601 Blue: min: -218.872 (-0.00333977) max: 821236 (12.5313) mean: 12432 (0.1897) median: 422.994 (0.00645447) standard deviation: 67501.9 (1.03001) kurtosis: 67.7693 skewness: 7.95335 entropy: 0.867897 Alpha: min: 65535 (1) max: 65535 (1) mean: 65535 (1) median: 65535 (1) standard deviation: 0 (0) kurtosis: 0 skewness: 0 entropy: 0 Image statistics: Overall: min: -218.872 (-0.00333977) max: 822259 (12.5469) mean: 24946.2 (0.380655) median: 16571 (0.252857) standard deviation: 47560.7 (0.72573) kurtosis: 55.7607 skewness: 6.18358 entropy: 0.602702 ```

` Gamma: 0.454545`

First like this: ``` JxrDecApp -i '/home/damian101/Downloads/Screenshot 2025-05-26 00-24-30_058.jxr' -o '/home/damian101/Downloads/Screenshot 2025-05-26 00-24-30_058.jxr.tif' -c 10 ``` then like this: ``` JxrDecApp -i '/home/damian101/Downloads/Screenshot 2025-05-26 00-24-30_058.jxr' -o '/home/damian101/Downloads/Screenshot 2025-05-26 00-24-30_058.jxr.bmp' -c 0 ```

why are you specifying `-c` ?

yeah just don't specifc -c

bmp requires -c 0

makes no difference

don't use bmp, use tiff

tif should support anything anyway

I did

and you get that error not specifying anything?

oh

yeah, tif with nothing specified works...

btw, the valid outputs for this image are {2,3,22,25,28}

oh, because it's planar?

no...

why

no because jxrdec is dumb

lmao

but yeah, in the future if you want to know what outputs are valid just do `for i in {0..34}; do JxrDecApp -i Screenshot_2025-05-26_00-24-30_058.jxr -o out-$i.tiff -c $i; done`

[av1_kekw](https://cdn.discordapp.com/emojis/758892021191934033.webp?size=48&name=av1_kekw)

That tool should be given a 'Command line interface of the year' award

Some ignoble prize version of such an award, that is

The Golden Raspberry Awards for CLI programs

That goes to the Adobe DNG Converter for me. Case sensitive, order dependant, unlisted parameters, unless you find the example PDF on the website which also doesn't explain the ordering, with no user feedback at all

it's a shame because jxr is an... ok image format all things considered for what it sets out to accomplish, for sure a bit outdated now.

huh, djpegli is quite slow to decode? ```ps Benchmark 1: taskset --cpu 1 djpegli woag.jxl.jpg --disable_output Time (mean ± σ): 1.217 s ± 0.004 s [User: 1.168 s, System: 0.037 s] Range (min … max): 1.213 s … 1.224 s 5 runs Benchmark 2: taskset --cpu 1 djpeg woag.jxl.jpg > /dev/null Time (mean ± σ): 824.2 ms ± 123.2 ms [User: 790.0 ms, System: 24.5 ms] Range (min … max): 750.7 ms … 1042.0 ms 5 runs Benchmark 3: taskset --cpu 1 jpegtopnm woag.jxl.jpg > /dev/null Time (mean ± σ): 847.1 ms ± 7.2 ms [User: 810.5 ms, System: 25.9 ms] Range (min … max): 839.4 ms … 857.3 ms 5 runs Summary taskset --cpu 1 djpeg woag.jxl.jpg > /dev/null ran 1.03 ± 0.15 times faster than taskset --cpu 1 jpegtopnm woag.jxl.jpg > /dev/null 1.48 ± 0.22 times faster than taskset --cpu 1 djpegli woag.jxl.jpg --disable_output ```

djpegli decodes in f32 while libjpeg-turbo does it in integers I guess

also djpegli is optimised more for quality where libjpeg-turbo, as given in the name is specifically optimised to be really fast

(probably explains why they use int instead of float)

expected it to be slower, actually

but seems about right

this is quite a bit slower

1/2 more time, 1/3 slower

yes

quite alright imo

<@&807636211489177661>

Oh you beat me to it

2 scams/malicious ads in a row.

https://github.com/microsoft/edit/blob/6fc049713b2f6421c5000443edd1e645a57b8e1f/src/oklab.rs

why does a command-line text editor contain an Oklab implementation

probably something dumb like color accurate emoji renderinf

It feels like they remade notepad but in the terminal

Dear experts on image coding quality, one of the ongoing JPEG activities is JPEG AIC which targets the assessment of image coding quality. This activity aims to develop methods for subjective and objective image quality assessment with the goal to support developing image coding standards and implementations. For subjective assessment, the AIC-3 methodology is in the final stages of standardization and will be published as ISO/IEC 29170-3. For objective assessment, the JPEG Committee is considering initiating a new Part, AIC-4, of the JPEG AIC project. The Final Call for Proposals (CfP) on Objective Image Quality Assessment was issued as an outcome of the 107th JPEG meeting in April 2025. Expressions of interest and registration may be submitted until June 15, 2025 (not obligatory). Submissions to the Call for Proposals are planned to be due September 29, 2025. At https://jpeg.org/aic/documentation.html please find the relevant documents and related information - ISO/IEC JTC 1/SC29/WG1 N101211, REQ "AIC-4 Proposal Submission Template" - ISO/IEC JTC 1/SC29/WG1 N101157, REQ "Final Call for Proposals on Objective Image Quality Assessment (AIC-4)" - ISO/IEC JTC 1/SC29/WG1 N101056, ICQ "Common Test Conditions on Objective Quality Assessment“ Also, the following blog post summarizes the concepts for the corresponding subjective quality assessment that is to by predicted by the metrics to be submitted for the above Call for Proposals: https://cloudinary.com/labs/aic-3-and-hdr In case of any questions please write. We hope that you may find this call for proposals interesting and consider a submission that later might be integrated in the forthcoming ISO/IEC AIC-4 standard. You are also welcome to share this information with other interested parties, of course. Kind regards, Dietmar Saupe / Jon Sneyers Co-Chairs JPEG AIC Ad hoc Group -- Dietmar Saupe dietmar.saupe@uni-konstanz.de Jon Sneyers jon@cloudinary.com

can I propose mean square error 😄

So is Jon pronounced like "yawn" or is it more like Hebrew "Elyon" (most high) and "Yonatan" (Jonathan) or Yiddish "Gut Yontif" (good holiday)

I don't speak Hebrew/Yiddish and I don't know how those are pronounced, but my name is pronounced "yonn" (the J is like the J in German/Dutch "Jan", not like the J in English "John")

There's a list of "anchor metrics" that will be used as a baseline to compare against, MSE is one of them (or rather PSNR, but that's basically the same thing)

I will never understand the relationship in pronunciation between 'y' and 'j' across Latin-script languages.

But is it an "oh" or an "ah" vowel sound?

Gemini says /ɔ/ (open o)

https://en.wikipedia.org/wiki/Open-mid_back_rounded_vowel

(check out the audio sample)

whether that’s “yawn” depends on the accent https://en.wiktionary.org/wiki/yawn#Pronunciation

Hmm

So like "over yonder"

yonder seems more open https://en.wiktionary.org/wiki/yonder

oh

I've always said it like "yon" (in Spanish)

please forgive me for my sins

How does "yon" sound in Spanish?

In the International Phonetic Alphabet, my name is just <jon>. The "j" is this one: https://en.wikipedia.org/wiki/Voiced_palatal_approximant The "o" is this one: https://en.wikipedia.org/wiki/Close-mid_back_rounded_vowel (but the short version, the audio sample on that page is the long version, <oː>) The "n" is this one: https://en.wikipedia.org/wiki/Voiced_dental,_alveolar_and_postalveolar_nasals

I hope that clarifies it 🙂

like [jo̞n]

so actually very close to ground truth

https://en.wikipedia.org/wiki/Mid_back_rounded_vowel

Sounds like this https://en.wikipedia.org/wiki/Jiong

If that j isn't [j]

“mid back rounded vowel, you touch my tralala” “voiced bilabial nasal, my ding ding dong”

oops, sorry for spreading misinformation about the degree of openness then

An online converter that lets you choose jpg and jpeg

Wow the jpg and jpeg file sizes are identical 🤨

like its not even a jpeg / jfif thing

its literally byte identical?

https://meee.com.tw/changetype

他说404

Walled

我需要台湾的IP吗？

Uh the website breaks now

The traffic may be too high now as Imgur blocks uploading from Taiwan

<:megapog:816773962884972565> png --> jpeg jpg jfif jpegli guetzli jpeg mozjpeg turbojpeg baseline jpeg true jpeg 1992

forgot jpg_large

420_jpeg 444_jpeg

what about png -> reconstructed jpeg (png -> jpeg -> jxl -> jpeg)

What? Why?