JPEG XL

original lanczos my (selected neighbor)

it's strange that nothing is known about this method, as if I invented it <:WTF:805391680538148936> since this method takes only the original pixels, it does not make artifacts. And as far as I know, to preserve the clarity of the image, photos, usually use neighbor. But my method is as clear as it creates fewer artifacts.

lanczos my neighbor

the main problem, of course, is no flexibility of the algorithm, downscale only in pixel increments for search. 2x 3x 4x. And for an extremely long time - Need to compare each pixel of the image with the sum... BUT I have a feeling that such a scaling method will perfectly fit modern compression, since sharp pixel changes will give less rounding of the coefficients, as happens with any other algorithms (blur)

||pip install pillow|| ```python from PIL import Image def pixel_difference(pixel1, pixel2): r1, g1, b1 = pixel1 r2, g2, b2 = pixel2 return abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2) def downscale_by_closest_pixel(image): width, height = image.size new_width = width // 2 new_height = height // 2 new_image = Image.new("RGB", (new_width, new_height)) for y in range(new_height): for x in range(new_width): pixels = [image.getpixel((x * 2, y * 2)), image.getpixel((x * 2 + 1, y * 2)), image.getpixel((x * 2, y * 2 + 1)), image.getpixel((x * 2 + 1, y * 2 + 1))] r = (pixels[0][0] + pixels[1][0] + pixels[2][0] + pixels[3][0]) / 4 g = (pixels[0][1] + pixels[1][1] + pixels[2][1] + pixels[3][1]) / 4 b = (pixels[0][2] + pixels[1][2] + pixels[2][2] + pixels[3][2]) / 4 avg_pixel = (r, g, b) closest_pixel = min(pixels, key=lambda pix: pixel_difference(pix, avg_pixel)) new_image.putpixel((x, y), closest_pixel) return new_image image = Image.open("input_image.png") downscaled_image = downscale_by_closest_pixel(image) downscaled_image.save("downscale_output_image.png") ```

No magic happened. original my lanczos

It's certainly sharper, but I'm not necessarily sure that's best for human viewing

It's all just an interesting find. an alternative and better nearest-neighbor

on vacation and took my laptop I guess it's CPU burning time™️ <:KekDog:805390049033191445>

only FLACs optimization tho

I had problems using the latest Squoosh while offline today. AVIF and several others weren't available...

I'm surprised there's an update at all, it's essentially archived

fun fact: ```c int main; ``` is a C program that compiles.

what's it do? segfault immediately. but it *compiles*

if you have `-Wall` it'll trigger `-Wmain` on gcc ``` test.c:1:5: warning: ‘main’ is usually a function [-Wmain] 1 | int main; | ^~~~ ```

so it's okay to be just any type of symbol and doesn't need to be callable

to compile? yea, but if it's not callable (which it isn't) it will segfault at runtime

yeah definitely

data sections are usually not executable

``` $ ./test AddressSanitizer:DEADLYSIGNAL ================================================================= ==58==ERROR: AddressSanitizer: SEGV on unknown address 0x55652dfb70c0 (pc 0x55652dfb70c0 bp 0x7fff405bfa20 sp 0x7fff405bf988 T0) ==58==The signal is caused by a READ memory access. ==58==Hint: PC is at a non-executable region. Maybe a wild jump? #0 0x55652dfb70c0 in main (/home/leo/test+0x40c0) (BuildId: 79b512c24b3a4126f21787590cc20c801847ca58) #1 0x7fe79d769d4b in __libc_start_main (/usr/lib/libc.so.6+0x25d4b) (BuildId: 32a656aa5562eece8c59a585f5eacd6cf5e2307b) #2 0x55652dfb4094 in _start (/home/leo/test+0x1094) (BuildId: 79b512c24b3a4126f21787590cc20c801847ca58) AddressSanitizer can not provide additional info. SUMMARY: AddressSanitizer: SEGV (/home/leo/test+0x40c0) (BuildId: 79b512c24b3a4126f21787590cc20c801847ca58) in main ==58==ABORTING ``` luckily address sanitizer tells us this (in case we didn't know)

that is if you run `gcc -fsanitize=address -g -o test test.c`

ahh, C

yes, although we could probably move this over to https://discord.com/channels/794206087879852103/805176455658733570 sooo that's where ill post answer

<https://www.bloomberg.com/news/articles/2024-08-13/doj-considers-seeking-google-goog-breakup-after-major-antitrust-win> > If the Justice Department pushes ahead with a breakup plan, the most likely units for divestment are the Android operating system and Google’s web browser Chrome, said the people. Officials are also looking at trying to force a possible sale of AdWords, the platform the company uses to sell text advertising, one of the people said.

https://x.com/EyeingAI/status/1823493962499555485?t=C-ssIlrHgWijDaqPZ-WO_A&s=19

To me, "AI-powered camera experience" and "authentically" are hard to reconcile...

Every time I take a photo on my phone, I use RAW mode, then when I go though the gallery I can see how awful all the post processing is on the jpeg versions. I can only imagine how bad the Pixel could end up compared to just having a decent sensor

Fitting a decent sensor in a thin device is tricky. Maybe we need some more innovation in phone form factors besides the "rounded rectangle that is as thin as possible" and come up with a design that somehow allows fitting a real camera while still being convenient to carry around and use.

Instead of "How thin can we go before it snaps when you sit down" why not "What fits in your pocket while being full of tech"

It'd be a whole lot easier to have competitive battery life then too, along with better heat management, larger cameras, more grip instea of glass (No need for a few hundred phone case factories...)

https://ae-pic-a1.aliexpress-media.com/kf/Sf952df64be8f4030b87e1f4f9d3bf798o/8849-Tank-3-Pro-by-Unihertz-with-100-Lumens-120Hz-Projector-32GB-36GB-RAM-512GB-ROM.jpg_350x350xz.jpg_.webp

<:CatSmile:805382488293244929>

I was thinking more like this, but yeah https://www.aliexpress.com/item/1005005007646231.html

mmmh for only 200€ cheaper, its specs aren't really good...

Mostly just sent it for the thermal camera and (realistic) battery, but it is a few years old now too

I bought separate thermal camera, needs usb type-c. I hope it will outlive more than one phone

I'm really not liking the Pixel 9 & its messaging...

the last time sony thought it was a good idea, they gave us this monstrosity https://media.wired.com/photos/59332849a4b3d04a47189786/master/w_2240,c_limit/0903_qx10phone_1200.jpg

sony's old pro 1 was neat, packed a 1" sensor https://electronics.sony.com/mobile/smartphone/professional-smartphones/p/xqbe62-b same with their new xperia 1v and 2v have a not bad one either https://www.galaxus.at/en/page/how-much-of-a-professional-camera-is-the-sony-xperia-1-v-28574

not as neat as packing a full 1" sensor, or just a dedicated camera module tho

do any of you devs have a donation page like pateon, kofi... crypto address?

coz

like

I wanna support

but I'm just about the dumbest you can find in the case of computers

(that crypto thing my cousin manages for me lol)

continuing from <#794206170445119489>

https://github.com/reubeno/brush

rust shell with bash compatibility, allegedly works on windows

> brush is functional for interactive use as a daily driver. It can execute most sh and bash scripts we've encountered, but still a work in progress with known limitations.

fiar

*fair

that reminds me that I have yet to try out the light pollution filter I bought a while back

Processed them before dxo\topaz\adobe AI denoiser were invented, and was not in the mood to reprocess since then

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

ANS explainer mentioning JXL and that software patents are the devil

disinformation

Microsoft does not have a patent on ANS

wouldn't the Linux kernel be in trouble if this was true? like why is it/this only ever brought up in the context of JPEG XL?

https://discord.com/channels/794206087879852103/822105409312653333/1274702220499357830

it's only brought up in the context of JXL because some idiot who was covering the patent saw that JXL has it and concluded that that *must* be why Google removed it

and the basic idea has just been getting parroted since

Misinformation spreads faster than the truth

hello, i made this video and i'd also like to clear this up! someone else commented worried they'd violate this patent if they implemented something similar. i'll edit my pinned comment; what exactly is the microsoft patent on? and is it something people should worry about anyway?

these old messages might be relevant?: https://discord.com/channels/794206087879852103/805176455658733570/1037250264387829770 https://discord.com/channels/794206087879852103/803574970180829194/1038201223301578822 alternatively <@794205442175402004> could probably chime in and clear things up

microsoft patent is on a form of ANS with dynamically updating token frequencies. JXL does not do this, it signals all the frequencies at the start of the entropy stream

but yes, see the link in Adoption

<@456226577798135808> could you tell me a bit about that build.opensuse.org thing? I see that it can build packages for other systems, I need to patch and compile mesa for an old laptop but don't know much about it. wondering how it works, I do see that it supports multiple distros which is nice since im on popOS

yeah

well kinda, it has a lot of their own packages and tweaks, but for mesa they use upstream ubuntu

yeah

havent done anything of that yet since im not sure exactly how to use this tool

well I do have a "blank: https://build.opensuse.org/package/show/home:Quackdoc

to be specific, it's a specifc branch im trying to build, I was hoping I could just modify the deb or something fairly easily, but I got no idea what im doing with this tool lol

yeah

I think I know how to start at least, thanks

how did you find one using debian so fast tho [Hmm](https://cdn.discordapp.com/emojis/1113499891314991275.webp?size=48&quality=lossless&name=Hmm)

ahh I see thanks, this gives me a lot to work with

Google translated: *In addition to improvements to HDR video streaming, the Windows 11 24H2 update will also include support for compressing HDR wallpaper images in the JXR (JPEG XR) format, which is a Microsoft-exclusive technology that aims to improve on the widely used JPEG standard.* Instead of adopting JXL they are trying to force JXR. Yet another useless feature that noone will use

I thought Windows already supported JXR for that for years

Windows has had JXR for years, but I think the wallpaper support is new

> Windows has had JXR for years But have anybody seen jxr in the wild? 🤷‍♂️

Assuming 'wild' means a source other than your own computer, then no, since only Windows itself and Nvidia driver tools support it (As far as I've seen)

Internet Explorer and legacy Microsoft Edge support embedding/viewing them from what I remember

and OS wise iirc they have been natively supported since Windows 8

I mean over the internet

I think some CDNs back in the day used to ship JXR files to Internet Explorer users. something like: JP2 for Safari JXR for Internet Explorer WebP for Chrome JPEG for Firefox/other

At Cloudinary we used to deliver jxr (wdp) to IE / early Edge. But we stopped doing that a few years ago, the percentage of clients supporting jxr is too low to justify the extra encoding and storing the extra cdn cache entry...

We're now stopping with J2K for the same reason. Next Safari version is deprecating it, and there are better options now anyway (jxl/avif/heic/webp/jpeg)

pretty sure wallpapers have been like, the only thing you could actually do with JXR for all these years

Not sure if I would actually want a wallpaper in HDR. Seems distracting...

HDR wallpapers can be really nice if you have oled screens, I particularly like starry sky HDR pictures. too bad I don't have an oled HDR device lol

Just wondering what is the order of precedence for Cloudinary?

I would assume it would look something like jxl/avif/webp/jpg

Currently we just mostly do jxl>avif>webp>jpg, but it's also a bit based on image content (and in the future it will be more than now) and desired quality, since for some images and quality points, avif>jxl and for quite a few jpeg>webp.

do you have a recent statistic on what percentage of clients advertise jxl support?

with the new devices settling in, it should be fairly stable now methinks

Currently it is around 25% for us, but probably we have a bias towards North America and Europe

(which means more iPhones)

Around 26.5% of requests have Accept: image/jxl in the header. The real number of jxl supporting user agents is larger since requests coming from JavaScript or from native apps often don't set proper Accept headers when fetching images...

There is still some fraction of non-updated Apple devices that don't support jxl, but most are updated now. Maybe the percentage of jxl support advertising clients will stabilize around 28-29%, and the real percentage of jxl supporting clients will be a bit over one third, for our composition of end-users.

Still "very low to no interest" © Google

Do u guys serve HEIC ever?

Yes, some iOS apps use it. They do f_heic, it's not in f_auto.

one of the things I found funny is I actually had a noticable approvement on nintendo's website by using a redirector on my laptop lol

I did notice some latency issues, but the website was actually somewhat responsive on my piece of trash laptop lol

is there any strong negatives to doing this?

sadly amazon doesn't support jxl so no such override exists for it

what redirection thing is this?

https://chromewebstore.google.com/detail/redirector/ocgpenflpmgnfapjedencafcfakcekcd?hl=en https://addons.mozilla.org/en-CA/firefox/addon/redirector/

ok, this is neat enough to share here https://milkv.io/ruyibook

riscv laptop with an Cortex-A76 class cpu (no RVV sadly), but the CPU is actually a real open source cpu that people contribute to https://github.com/OpenXiangShan/XiangShan

china is building it's independence from US/EU chips at high speed with this amazing risc V

you reading too much into this, it's still a devel device, no RVV means no vector acceleration, which means no analog to SSE/AVX,

well they already had arm

not so much : https://www.reuters.com/technology/export-controls-hit-chinas-access-arms-chip-designs-ft-2022-12-14/

but at the end, it shows that the constraints the west put on china lately just boosted the autonomy of china 😄 a loose loose operation for the west

https://www.cnbc.com/2024/01/18/china-could-face-more-chip-restrictions-in-2024-analysts-say.html

hmm, weak in some things, not others

not really a major issue for them, since they just "dont buy it" lol

NEON?

neon is arm

it would be the similar equivalent

https://www.youtube.com/watch?v=3-Q87w8uhwg

https://youtu.be/pJ-QoG5GXV8?si=fadUuP90s5cgddPG

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

I already saw it.

https://youtu.be/ZV7ON5WjOjc?si=WOKz1rOmEnBSohLg

https://cdn.discordapp.com/attachments/853130811581530145/1277636131051147398/368a3d397098b135.png?ex=66cde2de&is=66cc915e&hm=529e4f64d0e3b7885c164aaf18a1c8c1e5883a0ee0eb5b2ba703b270e7f648a5&

|| mbsrtowcs (multibyte string to wide character string, restartable) strxfrm (string... transform? I think.) wcstold (wide character string to long double) ||

is the first one a Windows thing or part of the ANSI spec?

it's part of the spec

I prefer C# `System.Windows.Media.TextFormatting.TextSource::GetTextEffectCharacterIndexFromTextSourceCharacterIndex`

[C99](<https://www.dii.uchile.cl/~daespino/files/Iso_C_1999_definition.pdf>)

oh god lmao

<:Hsss:806131225278152756>

Java\Kotlin is slightly less talkative 😅

> <delroth> si jamais vous pouvez envoyer un message 15 ans dans le passé > <delroth> envoyez leur cette headline d'aujourd'hui > <delroth> "Microsoft donates the Mono Project to the Wine team " (translated: “if you can send a message 15 years in the past, send them this headline from today”)

<@167354761270525953>

Continuing from https://discord.com/channels/794206087879852103/822105409312653333/1278322842429030400

Regarding ChatGPT's backup strategy, the single drive where all data is kept is quite realistic. I've seen too many Youtube videos where they had just dozens of drives lying around, sans backups of course

i'm also guilty of that somewhat

currently in the process of copying my files to the NAS

I was too, until I built my server

and my offsite server lol

but i still have 2 1tb hdds and a 4tb to sort through, JXL compress, and transfer

you have an offsite server?

how much is that?

Yeah 😎

It was ok, price wise

i just have NAS and then Backblaze B2

only important stuff goes to B2 though, i don't wanna pay $65 usd per month

Understandable

Random data hoarding things aren’t worth it

They’re mostly on IA

I paid around 300€ each for 4 HDDs I then put in RAIDZ1

I don't want to talk about my main server, ouch

WHERE DO YOU PUT THE OFFSITE SERVER AND HOW DO YOU CONNECT TO IT?

oops sorry all caps

Phone

Friend's house and selfhosted VPN

Makes sense

Connection is slow, but it works

Helps if you have nerdy friends

I was thinking of putting very SFF builds in the form of Raspberry Pis and Sata SSDs at some more places

Only for the most important data and also doesn't pull much electricity

My server is an old MacBook Pro connected to a VPS running Nginx tunnelling through Wireguard

Vibrations from my GPU's fan bearing killed both my backup drive and my main drive, thankfully I realised before they completely gave out so everything is on a single SSD now

SSD supremacy 😎

I couldn't bear the noise and vibrations from HDDs in my PC so I'm all SSD now

How much data do yall have in TB?

It's a single 2 TB drive, and I already deleted around 1 TB of old videos that I never really used a few months ago, so at 1.4 TB right now

Like this? xddd

I have around 8-9tb + backups but most is due to the fact I use ProRAW

Yes

I should add a sign to mine

I have seen setups like this, but turned headless by removing the screen lmao

It’s decently powerful but also quite loud with the fan

Not enough lmao

I personally like the screen there so I can use it directly if something breaks

Same

The same vibrations actually disconnected my SSD while in use when then issue came back. Surprised how well Windows worked running from only RAM. Only hint anything was wrong were files failing to transfer and applications refusing to open or update

PiKVM is a nice little project for otherwise headless servers

If you have more ram it can cache more

16 GB, so nothing special

Huh

Well I guess it’s at least using spare ram to cache

Almost the windows equivalent of running rm -rf --no-preserve-root / on linux lmao

It was a stressfull day, only figued out what had happened when I eventually tried changing SATA cable and it suddenly worked

But my old backup drive got the click of death and the old main drive just goes straight into recovery so many sectors are corrupted

Sheesh

Weird thing is, I replaced that fan around 5 months ago, and the same fan has gone again

Maybe it’s getting bad power?

Both fans are on the same cable

And it's definitely the bearing, I can rock the blade side to side

At 5 months you still have warranty at least

Well the replacement fans didn't come with a warranty, I had to replace them myself

The GPU is almost 8 years old

An 8 year old GPU is good for anything but new games on higher settings luckily

Except if is a gt210 or something like that lol

Or 750 Ti

Runs my VR at half resolution and most times I have a CPU bottleneck anyway. Most annoying thing is I got bad silicone so it can't boost very high

1070 TI

Quite alright

Been considering just spending the money so I don't have to worry about it for another decade. Get the god awful value 4060 TI 16 GB, since the VRAM is needed for VR, 2x raw performance over this one ignoring DLSS and stuff, ~~AV1 Encode~~ and uses a single 8 pin power along with the fans turning off at low temps (Should help the bearings last a lot longer....)

I'd share my pain. I have 4080, and it suffered from sudden monitor signal disappearing, while everything continued running. Sometime weeks could go without problems, and sometime it happened 4-5 times per day. There are lots of useless advices over the internet, as usual, but it seems that I found one that worked. Cause is in 12VHPWR cable (native, bundled with PSU), when I changed it to 12VHPWR-to-3-PCI-E power cables adapter - issue disappeared. Now I can't close side panel of my pc case, because this adapter is not flexible enough

This adapter 🤦‍♂️

Because of my system being 8 years old and almost untouched, the 8 pin connector cracked and split into individual pins when getting the GPU out to replace the fans. Part of the reason I'm even considering a 4060 since then I can just use the intact connector instead of manually pressing each wire on

They really need to got back to the drawing board with this standard

the standard's fine

LETS GO i just set up ssh between my home network, a VPS and the internet

https://www.phoronix.com/news/Rust-Linux-Maintainer-Step-Down

Also so much this: https://www.phoronix.com/forums/forum/phoronix/latest-phoronix-articles/1488128-one-of-the-rust-linux-kernel-maintainers-steps-down-cites-nontechnical-nonsense?p=1488207#post1488207

the big thing here is pulling of LLVM which isn't really needed as we are seeing both GCC-RS and rustc_codegen_gcc which should remove the hard requirement for LLVM

> I often end up backporting huge drivers or components to avoid messing with these old audited and certified toolchains. Here bringing in Rust introduces llvm as a dependency. this person would probably be interested in the world Ferrocene is doing on the certified toolchain front. Once Rust support in Linux is stable, they'll probably only bumb the minimum supported version rarely, just like with GCC. > Unwrap hell? Async Rust? Rust has the "hammer and everything looks like a nail now" problem. this person is deeply unserious. "unwrap" hell is nonsense, and doesn't exist in any code written for the kernel. Async Rust is one of the best designs ever for low level stuff, it just needs some unergonomic edges sanded off. > So what would I like to get added to the kernel? Lets see, I code C/C++, Zig, Ada, Pascal, Modula-2 (here I occasionally work on the GCC frontend), Rust and E, seriously? complaining about toolchain woes and then wanting all that? And Zig is years and years away from being ready to use, not to mention being married to LLVM (for production code, their non-LLVM backend is designed to be fast and simple, to not produce efficient machine code), meanwhile Rust is very close to having two different ways of using GCC instead of LLVM.

here's something that the former maintainer posted for context: https://youtu.be/WiPp9YEBV0Q?t=1529

Completely unhinged behavior from Ted Ts'o

I'm confused what he's complaining about. he's basically saying that he's allowed to change ABI/ABI semantics exposed to filesystem drivers provided he changes *every one of those* filesystem drivers to use the new semantics, and he's able to do this cause it's all in C and all upstreamed in the kernel, and he'd lose his freedom to do that if there was any rust drivers that depended on the semantics

this freedom sounds like the kind of thing that you'd have if it's a personal project maintained by one person

this is the kernel, why does *anyone* have the freedom to change the semantics and then fix all the upstreamed drivers that break?

cause like, that will still break ZFS and anything not upstreamed that is used in production

he's just speaking about the general idea of it, not that he can choose to break something. however the topic you brought upm the linux kernel takes a very "if it's not upstreamed it's not supported approach" and have made that very clear many times, but most notably during one of the many the nvidia shenanigans the issue is he is... given the benefit of the doubt, massively misinterpreting what the speaker is saying, and saying that the burden of maintaing rust would be on the programmer who does the refactoring, when it simply isn't true

That is in fact how Linux kernel development works. They actually really like it when they have a chance to break out of tree modules. There have even been backports to older LTS kernels that served zero purpose other than break ZFS.

The presentation speaker said several times that as long as anyone who makes a change can describe the new interface contract, they would be happy to fix the Rust abstractions. But they can't even create initial Rust wrappers for any fs interfaces, because there is zero documentation saying how you're supposed to use them, and the maintainers are refusing to provide any descriptions.

This seems to contradict Linus going on record of saying "no regressions" is a policy.

that only applies to interfaces exposed to userspace

Kernel internals have *zero* stability

Linus has a very strong opinion against stable kernel driver interfaces

how does he expect to work with nvidia then

a third party

Nvidia has spent 20 years keeping their out of tree module up to date whenever anything breaks

If you use Nvidia's driver or ZFS, or any other out of tree module, you must always wait for them to update before updating your kernel if something has changed.

why does linus act like nvidia is the bad guy here

well obviously they should open source and upstream their kernel driver

...right

they did open source it recently though, lol

Not really?

And Linus said recently that ever since the AI boom, Nvidia has gotten a lot easier to work with

the new kernel module is open source

I heard it's more complicated than that

The userspace drivers and the firmware are closed source

Lemme find that IRC conversation

Just like AMD did back in like 2015, Nvidia moved tons of functionality from the kernel module to firmware

oh, that's what it was

they open sources nvidia.ko but stripped it clean

Fun fact: digital rights management stuff used to be in AMD's closed source kernel driver, but because they are contractually obligated to keep it secret, they had to move it all to the firmware before open sourcing.

nvidia has been caught using the private internal GPL interfaces many time which has made many a lawyer angry at the linux kernel staff

and causing many a re-write to try and prevent that from happening

but yes, their stance is very if it's not upstream, it's not supported

There's no such thing as a GPL interface

That's a made up thing

And of course, many symbols in Linux as marked as GPL only despite obviously being too trivial for copyright.

well. tell that to the lawyers

For example, ZFS used to use Linux's exported symbols for Arm NEON, which are just wrappers around the relevant assembly instructions. At some point, someone decided to mark them as GPL, blocking ZFS from using them. This change was backported to every single active LTS kernel.

Well, actually, ZFS still has the code for using those symbols, and several distros patch the kernel to remove the GPL marking :) NixOS for example

while distro's can technically, as in have the technical capability to delete a line, do this, that doesn't make it not GPL, that just makes it a GPL violation

simple SIMD wrappers cannot be GPL-infectious, so it cannot be a GPL violation

You can't override copyright law by putting up a few labels

the interfaces can absolutely be GPL infectious, even simple ones

SIMD wrappers aren't even interfaces

are you gonna claim that the linux devs own the Arm ISA

and the only way anything can be GPL infectious is if you end up with a derivative work

the GPL people have this weird idea that they get to decide what does or does not count as a derivative work, but in reality, only copyright law and courts can decide that

a wrapper is an interface, and it can be GPL'd, if you fork a code base, and add a single commit, which changes a single line, which is GPL, that codebase now effectively becomes GPL, you can GPL code now matter how trivial, ofc people can implement the code in the exact same way and not gpl it, but so long as the code is there with that commit, it's GPL

this has caused endless headache in the past for me for sure

a single line is too trivial to even be covered by copyright law

licenses aren't magic

tell that to the lawyers

of course lawyers are gonna be angry about bogus nonsense

I was going to look up how Google v. Oracle concluded, but apparently, the conclusion was “it’s fair use so this bypasses the question of copyrightability altogether”

Made up by the Linux project in order to scare people away from using/contributing to Linux?

GPL interface as in the names of the API?

I thought the Linux authors/copyright holders made up the concept of GPL-only kernel API

It makes me sad when some people say that Linux owes its success and popularity to GPL... rather than in spite of the GPL.

Why do Java developers wear glasses? Because they can’t C#

https://youtu.be/mDhNQPt8An0

it's an NE555, of course it has such a good sense of rhythm

bro steam using my entire GPU

<@226977230121598977> following from what you were doing a few weeks ago about spectrograms, apparently h.264 isn't a great audio codec

left half is amplitude (top = left ch, bottom = right ch, mirrored so center is lowest freq) and right is phase (same channel config)

bad encode

did i forget a zero in my `-b:v` ?

I think using a variable density phonogram will work well. (Movietone track with variable density.)

do not use bitrate

so stay in time domain, don't frequency domain?

ik, im actually using `-crf`

do you encode only sound into an image? or are you asking about something else?

it's just sound

no other data

unless i want to do a real switcharoo and put a video track encoded in the audio

It doesn't look presentable

this works better

the method itself does not work. you don't transmit sound at least somehow well

static image ?

?

chrome moment

oh

fellow compact mode user?

it's h265 so that may have screwed with it

ok what I didn't understand is this - is the image shown on the screen an encoded and then decoded sound?

yes

what tehnology name

i encode `src.wav` into `video.mp4`, decode `video.mp4` to `out.wav` and mux `video.mp4` and `out.wav`

ffmpeg showspectrum / spectrumsynth

currently testing different configs to try to get the best quality vs video bitrate

like

https://legacy.imagemagick.org/Usage/fourier/

hmm, image fourier transform?

I just can't figure out how the right side works. And why do we need the left part if the right one

it's very complex

well, I spent 3 weeks fully exploring all possible algorithms and writing my own algorithm for drawing spectrograms from scratch. So take the trouble to explain

i was making a joke about how the FFT uses complex numbers 🤷‍♂️

wha

what not the FFT but the Fourier transform

in a pure math context

2 main problems I have encountered 1. It is impossible to create a spectrogram that can be converted back into a signal. Low frequencies are completely irretrievably lost due to the window size. 2. Even if you create 2 spectrograms with phases, it will still be only approximate information about the presence of a wave that has nothing to do with reality, due to the fundamental physical Uncertainty principle of Heisenberg.

DFT*

could wavelets help with issue 1?

although heisenburg is still going to get in the way

wavelet transform the same

DFT GABOR GE RID LOW-GABOR WV1 WV2 WV3 WV4 CT CT-W

1. Дискретное преобразование Фурье https://en.wikipedia.org/wiki/Discrete_Fourier_transform 2. Преобразование Вигнера — Вилла https://en.wikipedia.org/wiki/Wigner_distribution_function 3. Чирплет-преобразование https://en.wikipedia.org/wiki/Chirplet_transform 4. "Cohen's Class Reduced Interference Distributions (RID) https://en.wikipedia.org/wiki/Short-time_Fourier_transform 5. Окно Гаусса https://en.wikipedia.org/wiki/Window_function#Gaussian_window 6. Преобразование Габора https://en.wikipedia.org/wiki/Gabor_transform

Multi-pass Chirplet transformation

What are the weird horizontal attract lines?

Aliasing artefact?

and technically, it's all exactly the same. So how do you tell me is it possible to convert the sound back if even different ways draw it differently

Never said you could perfectly reproduce, it’s inherently a lossy process

I was just experimenting with ffmpeg’s spectrumsynth

this is a really funny thing that is seen exclusively in Chirplet transformation. I have an assumption that it appears at the place where the frequencies add up. Causing a certain ringing. Which should be an artifact of the encoding of the music itself. It's different on different music. Initially, I thought it was an artifact of the 44100 sound or an artifact of the 44100 --> 48000 conversion, but perhaps it is an invisible artifact that is obtained when rendering the original music in the program where it was created.

ok...and yet it is possible to reproduce perfectly if you simply encode the information about the wave as a wave. using Movietone track with variable density.

Or if you encode it digitally as PCM data

or. I wrote the function incorrectly ```py if func == "CT": # chirplet chirp_rate = 1.0 phase_sum = 0.0 for mu in range(window_size-1): t = mu - window_size // 2 if 0 <= time_index + t < N: phase_sum += math.atan2( window[mu] * math.sin(-2 * math.pi * (frequency * t + 0.5 * chirp_rate * t**2) / sample_rate), window[mu] * math.cos(-2 * math.pi * (frequency * t + 0.5 * chirp_rate * t**2) / sample_rate) ) return phase_sum / 10 / window_size ```

https://www.threads.net/@dlberes/post/C_bf1ZKSrkQ/?xmt=AQGzvKregSW_bOHR_ZwxOLiOiwwIJK3WgM2T5lRaA-h87g

Ah yes, subscribing for AI generated articles instead of just asking yourself

pretty sure he meant stories about AI, not written by AI

https://www.sciencealert.com/mitochondria-dump-dna-in-the-brain-potentially-cutting-years-off-our-lives

Can someone explain chroma and chroma subsampling to me in very broad terms? what does that `x:y:z` thing mean?

It's a confusing notation. Basically it means if you have two rows of x luma samples, chroma is subsampled so you have y corresponding chroma samples on the first row and z more chroma samples on the second row.

So 4:2:0 means chroma is subsampled 2x in both directions.

4:2:2 means chroma is subsampled 2x horizontally but not vertically

4:4:0 means chroma is subsampled 2x vertically but not horizontally

4:4:4 means no chroma subsampling

Oh okay; I completely understand it, then Thank you very much

It is mostly a crude trick to reduce the number of samples (and thus the size of buffers, etc) to make video hardware cheaper, and kind of dates back to the time when color TV was introduced and they needed to squeeze in the chroma signal in a way that would fit the broadcasting bands that were already allocated for black&white TV.

what does "two rows of x luma samples" mean? Like a 4x2 recangle of samples?

Yep

although it's not usually flat boxes

there's usually interpolation and upscaling

depends on the implementation

Yeah there's the complication of the offset for the chroma samples. You can align them with luma samples (cosited) or put them in the middle of the corresponding luma samples (interstitial). When it's cosited, you basically have some pixels that are identical to the non-chroma-subsampled pixels and some pixels that have only interpolated chroma info; when it's interstitial it's more symmetric in that regard.

See also: https://en.wikipedia.org/wiki/Chroma_subsampling#Sampling_positions

JPEG uses interstitial subsampling, i.e. in 4:2:0 the chroma samples correspond to the center of the 2x2 box of luma samples, i.e. offset (0.5, 0.5). HEVC uses cosited subsampling, i.e. in 4:2:0 the chroma samples correspond to the top-left pixel of the 2x2 box of luma samples, i.e. offset (0, 0). MP4 uses a mix of both: horizontally it's cosited, vertically it's interstitial, i.e. in 4:2:0 the chroma samples correspond to the center-left of the 2x2 box of luma samples, i.e. offset (0, 0.5).

umm...

how does that work?

it's my startup disk

root file system

> macOS is checking in background whether the program using the disk has exited which is fine for external drives

no, im still using it

haven't restarted

must have been a visual error

i was trying to unmount a network drive but Finder must have got confused

because you can't actually unmount the root fs, it will give you resource busy

Since we were talking about simd dispatch in Rust, I tried sketching something out based on the struct target feature feature. I didn't want to compile rust from source, so I don't have it in this code, but I hope it will be self-explanatory enough. Can't say I'm satisfied with what I ended up with, though.

<@179701849576833024> how are you planning to do dispatching in highway-rs?

https://github.com/rust-lang/rust/pull/129881

I know about that 🙂 I meant, how are you planning to use such structs for dynamic dispatch? Trait objects? Enums? Some kind of macro magic?

generics 🙂

server finally running out of space, might have to either delete or get new drives

I'd go add more drives

or compress some more of my JPEGs to JXLs

only thing is budget

drives are cheap, better get new ones before convert. for now maybe purge some stuff - not everything is worth preserving forever on a live server

converting to jxl only saves like 20% of existing jpgs and halves png filesize. temporary savings just buy time

Cheap is relative, especially when everything else is costing double nowdays...

💀

a 'nice number' is a number in any base whose square and cube together contain each digit of that base exactly once, and there is only a single known nice number: 69 69^2 = 4761 69^3 = 328509

nice

Is JPEG Trust something JPEG XL specific? No mainstream information exists about the project

https://jpeg.org/jpegtrust/

No, it's not jxl-specific. It's a metadata spec and it can be applied to any jpeg format (and probably even other image formats)

Technically, it's mostly the same thing as C2PA (https://c2pa.org/), or rather, it builds on top of that.

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

Maybe someone wants to play around with the files in the description

``` You feel adventurous, you have a behemoth of a computer and a fast connection? Here is a 5 second ProRes4444 16K sample with an eye-watering 15GB file size: http://bit.ly/2XRrnTB You are a wimp working on an antique home computer? Here is a 200Megapixel single frame as a JPG at a lukewarm 64MB file size: http://bit.ly/2GjQWBZ ```

Unfortunately, there is no 1-bit image conversion algorithm that would make super maximum quality. on a very small size. So I had to invent my own combination: STRESS —> NLmeans —> adaptive threshold

"blue noise dithering" doing good results on larger images

but not my case

d0.5 jxl of the 200 mpx image

Trying to open it in Waterfox immediately caused me to go into Swapfile for some reason. 10 GB of peak memory usage with only a white screen instead of a progressive load. Afterwards it settled at around 1 GB, while Irfanview *peaked* at 1.1 GB, settling at 670 MB, only 8 MB above the image's size in memory. Impressive

is it any better with the beta 6.5.0 version from here? https://www.waterfox.net/download/ (it's a jump from ESR115 to ESR128 which has a way newer libjxl version)

ESR115 uses libjxl from this commit: https://github.com/libjxl/libjxl/commit/91760e31a40fb811867fbe9bda6ddf73c962389e ESR128 uses libjxl from this commit: https://github.com/libjxl/libjxl/commit/ba1bfac861315803dc53888abddca8f665c8edf3

Okay, nevermind... Turns out it was zooming in with the scrollwheel that causes memory usage to exponentially grow

I only saw the peak because I had HWinfo in the background, and suddenly noticed a lot of red numbers under memory allocation xP

seems like it only gives jxl decoding 1 thread

Went up to 60% CPU usage for me

Also why remove the file?

tried to edit the text

ill reupload it

Ah, thanks

few

Btw that 1.24 years

That's a lot of runtime

can a jpeg contains 10bit or 12bit image ? can it be wide gamut ? can phone camera somehow cram HDR images into a jpeg ?

10/12 bit: yes in the spec but no one implements it

WCG: I guess with ICC profiles?

HDR: you can either use gainmap (UltraHDR) or use the previously mentioned 10/12 bit with extra signalling

4th solution: JPEG XT

sony seems to use DRO (dynamic range optimisation) but still output jpegs : https://www.institute-of-photography.com/dynamic-range-optimisation-2/

Do you mean HDR as in less of the image is badly exposed or HDR as in displays?

Ofc you can do whatever preprocessing to the data before encoding to JPEG

ultraHDR is what google uses as an excuse not postpone the implementation of jpeg XL 😄 ?

indeed

Not sure, AVIF also supports native HDR

given it’s literally just a video format

oki, I think I have the picture.... thanks

Also it’s not all of Google

It’s specifically the AVIF team / the Chrome Codec Team

is an ultra HDR file a jpeg file ? where the gainmap is hidden as metadata ?

Not sure I don’t use it

I use DNG and HEIC

not sure how it works on the container level, but if you decode it normally it's just a single jpeg. software that supports ultra hdr can decode the gain map (which is another jpeg) and apply it to the regular image (with a parameter for hdr headroom iirc) to "recover" the hdr image

I used wide gamut jpegs before I met jxl

Yes Kinda Yes > Jpegli can be encoded with 10+ bits per component. Traditional JPEG coding solutions offer only 8 bit per component dynamics causing visible banding artifacts in slow gradients. Jpegli's 10+ bits coding happens in the original 8-bit formalism and the resulting images are fully interoperable with 8-bit viewers. 10+ bit dynamics are available as an API extension and application code changes are needed to benefit from it. You can put any ICC onto an image, but there'd probably be banding or other issues unless using jpegli for wide gamut

Yes and yes

For artificial images - probably, but for real world photo noise masks it pretty well, even for ProPhoto

The original jpeg spec has an 8-bit mode and a 12-bit mode. The de facto jpeg standard (the thing that is widely supported) is just the 8-bit mode. In 8-bit mode, the DCT coefficients are 12-bit; in 12-bit mode they are 16-bit. The extra 4 bits are needed to make a roundtrip of encode-decode at the highest quality (no quantization) almost lossless — there's still some loss, but very minor. The actual precision you can get out of 12-bit DCT coefficients is higher when a block has only low-freq info (e.g. a clear sky) and lower if it has a lot of high-freq info (e.g. grass). So the actual precision (in the pixel domain) varies, say between 7 and 11 bits. In practice, you mostly _need_ higher precision (to avoid banding etc) in regions where you happen to get it. That lucky coincidence makes it possible for jpegli to effectively get something like 10-bit precision even though it is only using the 8-bit mode. This is enough to do a reasonable job at HDR.

All other approaches to make JPEG do HDR are basically deviating from the de facto jpeg standard: either they use 12-bit mode, or they add extra stuff (a gain map, or JPEG XT residuals) that is not implemented by current jpeg deployments. If you're going to require people to implement new stuff, you may just as well use a new format altogether. With jpegli, only de facto standard jpegs are used, and you will get a reasonable image even when using just a standard decoder (provided it properly implements color management, but that's necessary anyway). Standard decoders will only decode to 8-bit RGB so there will be some banding, but it's not _horrible_.

Thank you for the recap! The more I read about it, the more It seems like Google will first push ultra HDR in their android camera API as an answer for the need of HDR... Which is sad

for seom reason updating to macOS Sequoia cleared up 100+ GB of disk space

must have cleaned out a bunch of old caches

Or optimised iCloud storage or something

Removed old updates or something?

macOS clock app hitting float precision?

How do I count colors for an animated image's frame in Krita?

`identify -format "%k\n" imagefilename`

if I remember correctly

reporting incorrect translations to LinkedIn is a much greater pain than I would have anticipated

they’ve now asked me to clear my cookies and to try with another browser

(in the context menu that appears when selecting text in posts, they’ve translated “Share quote” to French as the equivalent of “Share cost estimate”)

lol

gotta be international. by throwing everything into bing translate.

technically, I guess a human working with no context could make the same mistake

“this is LinkedIn, and LinkedIn is for business, so the ‘quote’ is probably a cost estimate”

Does someone here have an experience with Eigen?

a little bit

May I DM you with some (not many) questions? It will not be immediately now

sure, and I'll try my best 😊

Thank you!

my hosting service suspended my account for sneyers.info without warning, apparently because I exceeded some quota on disk usage and bandwidth

apparently it was limited to 5 GB storage and 10 GB bandwidth

I called them and they just bumped it up to 100 GB storage and unlimited bandwidth, for the same price as what I was paying before

×20 storage? which host is it?

Maybe it was like a grandfathered plan

I turned my second-hand 2012 MacBook Pro into a small server

Same but with my 2019 MacBook Pro

It’s a great Plex server

It's publicly accessible with HTTPS

Mine or yours?

Mine of course

Mine is behind a VPN and Nginx

Have you got fail2ban or something?

No as I didn't promote at all

my vps does

``` `- Actions |- Currently banned: 879 |- Total banned: 2305 ```

what site is it

is it just a personal thing

yeah

i should check my nginx logs

spider-mar.io (empty), sami.photo (not empty), and another domain with a Glowing Bear on it

funny, discord linkifies none of those

www.spider-mar.io

huh

https://spider-mar.io

there we go

i think it might need the schema for it to link

google.com

youtube.com

youtube.com/

ah yeah

http://youtube.com

www.google.com

interesting

you can always do this: [spider-mar.io](spider-mar.io)

nvm

[spider-mar.io](https://spider-mar.io)