JPEG XL

and complexity for what goes over the radio is a really big enemy to reliability/safety/mission success

my only experience with creating a progressive *lossless* file was that it became much larger, but I don't know how it works for modular lossy

And also that was a long time ago

does the API let me micromanage layers/compression strategy?

because if i could do 1:64 with modular with squeeze and then 1:8 modular with squeeze and then varDCT, that sounds like what i want

Ideally the 1:8 would benefit in some way from the bytes that came before as part of the 1:64, but that's optional

it looks like it may.

I just had a simple idea... What if we used modular lossy instead? It should have all the progressiveness of DC 1 but for the entire image with different artifacts to VarDCT

Something like `cjxl -d 1.5 -m 1 -j 0 -p -g 0 --group_order 1 -x strip=all bluemarb.jpg Test.jxl`

Can we close https://github.com/libjxl/libjxl/issues/2193

it was fixed by #2444 over a year ago

VarDCT has fixed group size, and the LF image uses the same group size as the frame

you'd need to use an LF frame to have a different group size for it

in FFmpeg I have the option exposed as `-disable_xyb`

er, actually `-xyb` but it defaults to 1

I'm planning on exposing more library options to the encoder wrapper, btw

currently I have `-effort` `-distance` `-modular` and `-xyb` exposed

which default to `7`, `1.0`, `0`, and `1` respectively

modular just *forces* modular

it still sets modular for lossless

It could be but it's usually not recommended. If you have a very strange ICC profile and you *need* the pxiel data in that space and lcms2 can't put it in that space that's your only option but otherwise I agree

Just got home, but done. And my first issue closed with my recently gained permissions

<@853026420792360980> Hey-- all very helpful. I don't have a great understanding of JXL. Do you know if I have a modular on top of another modular subsampled at a different resolution, if encoding the second modular derives any benefit from the prior data?

that is, if i have a /64 subsampled and then a /16 subsampled, does the /16 end up smaller than just a /16 on its own would be

Just trying to figure out the search space of things to try

are you doing lossy or lossless? if lossy your best bet is to stick to VarDCT

if doing lossless, this won't save much as most of the entropy is in the lower-order bits

if you have an approximation image, and then you take the difference between the original and the approximation and attempt to encode that difference losslessly, my experience has been that it's generally going to give you the same file size as if you had just encoded the original losslessly without the bells and whistles

or not literally identical but very close

the reason you might want to do that is to make things progressive, but if that's the case, there's a `--progressive` encode option, which enables the Squeeze Transform

Squeeze is a wavelet-like transform (using haar wavelets) that splits one channel into two channels that are each half the width of the other one. the first channel containing effectively a downsampled version of the image, and the second channel containing the residuals that can be used to construct it

I say width but it can be done horizontally or vertically

I'm doing lossy. I really want to get an image file that the first 1 or 2K does something useful, the next 8K makes it somewhat better, and so on

Ideally that's how VarDCT works, but if you want it to be hyper progressive your best bet is probably to use a preview frame

I've been playing with -progressive-dc=2 which does really well on the first thing (first 1 or 2k does something useful, with that modular image)... but the follow on VarDCT makes the image much worse for tens of kilobyes before it gets better

What distance setting are you using?

Progressive DC is sort of what you want

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

I have a couple of settings above. --progressive-dc=2 starts off better until about 6-7k in. Then when we're at 40k of dc=1, it's WAY better than 80k of dc=2, despite the additional frame at the beginning of DC=2 only being 5 kilobytes

the application is for downlink image data from a student designed satellite. we'll get 72 kilobytes of data per pass over our school at best, and a lot of the pictures we'll take will be garbage

what happens if you use lossy modular? how does that end up working?

so being able to send the first 4k of everytihng, then more incrementally, has a lot of value (instead of having to have special purpose resizing)

you won't get as good ratios

but you'll get it to be squeezed

can you post or link bluemarb.jpg just so I can work with the same image you are?

https://lyle.org/~mlyle/bluemarb.jpg

Yes, thank you --- So I tried -m1

what I noticed was, I got a very usable first readout, but the image didn't improve between having 1k and having 64k of it

I'm doing like ``` cjxl -v -v -q 85 -m 1 --lossless_jpeg=0 --container=1 --progressive --progressive_dc=2 --group_order=1 -x strip=exif,xmp,jumbf bluemarb.jpg trial.jxl dd if=trial.jxl bs=1024 count=64 | ~/jxl-oxide -o t64k.png - ```

bluemarb.jpg is ... a way better image than we expect for many reasons, but the resolution, contrast, subject matter, is similar

Also doing things like this to assess ``` for ((i=1; i<=760; i=i+8)); do j=`printf "%05d\n" $i` dd if=trial.jxl of=test.jxl bs=1024 count="$i" && ~/jxl-oxide test.jxl -o "out/$j.png" done ```

Interesting, this is 4K and 8K for me `cjxl -v -v -q 85 -m 1 -j 0 -p --group_order=1 -x strip=all bluemarb.jpg trial.jxl`

`--progressive_dc` doesn't do anything for lossy modular

Use JXL-oxide —with-offsets -I to check the order of the groups

We're not even reaching groups, this is LfGlobal

Oh, that small?

8k there is pretty nice. It just bums me that progressive_dc=2 is better for really small cuts

That's 2k

I am going to play with getting a really downsampled modular in and then proceeding to a similar sequence to progressive_dc=1 afterwards through the API

This here is 768 bytes

I suppose another thing to consider is, does getting tiny previews matter if you can't tell what's in them?

there's not too much around. There's whether the satellite in the frame is illuminated, and whether a planet is taking up a lot of the frame 😉

Our pointing may not be too great, so we may have to rely upon luck to get the planet in frame

what happens if you decode it with jxl oxide

That is with oxide, djxl doesn't output anything due to LQIP decoding being disabled

ah okay

should cjxl prevent you from overwriting the file it's using as input unless explicitly allowed with a flag? I can see the virtue of not needing to provide an `--overwrite` flag if you just want to change some encoder settings and then output a file of the same name again, but it's fairly easy to accidentally type `cjxl image.png image.png` and forget to change the extension, replacing the original

Especially if happens to be your only copy and the encoding is lossy, that might be a bad mistake

Yeah most tools will not overwrite an existing output file

You need -f usually

Might be nice

But I have tons of complaints with how cjxl/djxl tools work

Very janky and quirky and unique and unconventional in many ways

Not following normal conventions and standards for command line utilities

Even if we keep the idea to overwrite output files by default, I don't think it should overwrite the *input* files by default

cjpegli is super duper buggy too

Yeah that's a whole new level of weird

Almost any other program will complain if you try that and require very different command syntax to overwrite input file

jpegtran will do it

i've never seen a help command take -v before 😉

That is another cherry on top to add to how ridiculous and weird the tools are

Just wait until you try `cjxl -h -v -v -v -v -v -v`

for a long time, gcc would happily overwrite the input if you wrote `gcc foo.c -o foo.c`

but it seems they’ve finally changed it

```console gcc.exe: fatal error: input file 'foo.c' is the same as output file compilation terminated. ```

oops, clang still does it

I have bad memories of having done that

```console $ file foo.c foo.c: PE32+ executable for MS Windows 5.02 (console), x86-64, 19 sections ```

Early on in my computing journey, I wrote an disk duplicator program in assembly, and on my third test overwrote the source

Which is another fun way to fail

I once wrote a find/replace program in Delphi, but because of the design of Delphi’s folder selection dialog, I accidentally picked the directory one level above the test directory I had prepared, which was my desktop with most of my files in it

and my program was still buggy and would only write the first line of each file

I remember I forgot to add a dash in a batch script I wrote, so it opened around 1500+ instances of the Microsoft Photos app, and I had Task Manager set to not be on top because of earlier stuff... Took around 10 minutes of clicking to close them all

You all were playing with fire, I barely trust myself with the `rm` command

I thought I was safe with my test directory

turns out, you really need to double-click it, not just click it

otherwise the selection remains on the previous directory

(with the folder selection box from either Delphi 7 or Delphi 2006, don’t remember for sure)

I should add a check to my programs so they can't do IO outside of their working directory

2007 was another era, for sure

(can’t find the find/replace program or its code – it might have been lost to the incident)

(maybe that’s for the best)

oh, never mind, I found a binary

yup, exactly as I remember it: a single click doesn’t change the selection, only a double click does

also, by clicking “OK”, I ran the buggy program on that folder and thereby destroyed the files in it

It's called unveil

Short help and long help come up elsewhere, but the c/djxl granularity is certainly next-level.

I deleted /usr/bin once because of a rogue space

I don't like this excessive level of granularity at all

Maybe it would be better to do it the ffmpeg or git way, with help screens per topic. The full list of every cjxl option is inconveniently long. The goal of multiple levels was to put the most needed options in easier reach, but I don't think it's very convenient either.

So it would kinda be like `cjxl vardct --help` or `cjxl -h modular`

`cjxl -h modular` would be ffmpeg style

I don't like that either

Just have a short help and long help

Anything else is just excessive. cjxl is not so complex that it needs more than that.

The long help can have options grouped into the 4 existing categories

The short help can be a very basic summary

It would be nice if there was a single-letter form of each option

The argument parser is not smart enough to recognize multiple flags in 1 argument like most standard utilities

Isn't there a good conventional posix-style argument parser helper library to assist with this?

getopt is the standard, there are freely licensed portable versions available

And if you prefer something more sophisticated than getopt I'm sure it exists

There's no reason for it to be so quirky and weird like it is currently

But the biggest issue with cjxl and co is... the code and extra dependencies need to be separate from the rest of the library, so people who don't need cjxl/djxl and only need the library don't need to pull in all these extra dependencies and code

Also cjpegli always falsely says d1.0 no matter what you set the quality to. And --xyb still isn't 444

The tool code is much messier and dependency heavy compared to the library code and really needs to be more separate...

Is it intentional that noise synthesis does not work at e1 lossless? I haven't tested at which point it actually kicks in

does noise synthesis ever work with lossless?

It worked at e7

Wouldn’t it make it no longer lossless?

Or do you mean specifying adding extra noise on top of the lossless image?

Well, it would be lossless if the noise were to be added as a layer upon encoding, which sadly doesn't happen. I wanted to see if it did, but found that noise would not be added if encoding with -d 0 and -e 1

Afaik the point of noise synthesis is that the noise isn't stored in the image itself but synthesized by the decoder. So there is no reason why the original data couldn't be lossless, the pixel data doesn't change

As in it's still there in the image, it does change in the final rendering

Except there is currently no way to remove the noise, as far as I know

If you manually altered the JXL to make it so it no longer specify that it should do noise synthesis you could probably get the original image data back

Ah right, yeah

Optimally, the noise would be put into its own layer, if that is viable

I tested exporting an image with 4 layers in Krita, the noise gets applied to all layers

Ahh you can't specify the layer the noise is applied to? That's kind of a shame

Maybe it is possible, but not implemented? I have no idea

If it's a thing you could probably even use another layer as a mask for it to selectively apply it or in even in different amounts

as in multiply the noise layer with the mask layer, and then add that layer to your image

I think I brought this up before actually, and I seem to remember one of the devs saying it wasn't possible

Hm, that's unfortunate

Specifying a layer the noise is applied to would be fine, while generating the noise in a new layer seems to be the best option

Even better if the noise can be removed seamlessly

https://discord.com/channels/794206087879852103/803645746661425173/864474180657741842 nvm I guess

I do actually still think I was told noise masking wasn't possible? But I don't remember which specific question I asked

Ahh found it

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

Hm, alright. I assume it's not really simple to implement?

I wouldn't know, I am not a programmer

I assume the way it's implemented (the noise level being local-image-brightness modulated and all) reflects now cameras work, so I think an encoder would have to do relatively little to make the noise match the image noise. Something that's probably much harder for the encoder is denoising the source image (which removes a lot of high-frequency data making it compress better) since if you don't do that right you end up removing the wrong details or smoothing out surfaces that have slight textures, mistaking that for noise. Manually selectively applying noise is probably relatively easy. You just create your mask that defines where you want your noise to be and tell the encoder to do the rest, following the steps in Jon's message. I assume libjxl's API is expressive enough to tell it to do this but I've never looked at it so I wouldn't know

I've brought up 'lossless noise' a few times in the past, letting you get the original back with a decoder flag from those pesky artists always adding it to everything. Unfortunately, it's only in XYB space https://discord.com/channels/794206087879852103/803574970180829194/1303410607965606060

Follow up question I forgot to ask yesterday: Is it intentional that cjxl flattens layers together?

In the near future using noise filters in whatever software artists are using will keep being mandatory if noise is to be included in the final result. Sad, but we'll see if this changes at some point

Maybe we'll also have more control over noise in libjxl by then

I guess we do need an option for djxl to disable coalescing and return individual layers.

In my case, I was reencoding a Krita exported JXL with layers losslessly, but the layers were mashed together after the encode, as displayed by jxlinfo

So it is pretty much a lossy operation

oh, the jxl to jxl is applying coalescing? that's no good, at least not as a default

I was looking if I had missed an option to disable coalescing layers, but there is none

`gradient_test_crt_layers_e9.jxl` has layers, as seen here ``` JPEG XL file format container (ISO/IEC 18181-2) JPEG XL image, 1920x1200, (possibly) lossless, 16-bit RGB+Alpha Color space: 9080-byte ICC profile, CMM type: "lcms", color space: "RGB ", rendering intent: 0 layer: full image size, name: "Background" layer: full image size, name: "Malebene 1 (eingefügt)" ``` Reencoding the image then shows ``` JPEG XL file format container (ISO/IEC 18181-2) JPEG XL image, 1920x1200, (possibly) lossless, 16-bit RGB+Alpha Color space: 9080-byte ICC profile, CMM type: "lcms", color space: "RGB ", rendering intent: 0 ``` The layers have been flattened together

Should I open an Issue?

Yes please. We need a djxl option to decode without coalescing, and a cjxl option to take jxl input without coalescing (which should probably be the default).

Ohh I was so confused about this increasing the file size significantly after increasing the effort for one of my "subtract out the repeating pattern" tests

Since discovering https://github.com/skeeto/optparse I've never considered using anything else for C/C++. Maybe that could replace the tools' home-made option parsing?

Google might be funny about public domain code though...🤔

I would strongly advise to stick with getopt just because it's common and standardized and less likely to have... unforeseen consequences.

It's possible that another library is nice but getopt is pretty well known and understood

If getopt is too simple and limiting then your command line tool is too complex...

Feel free to make a pull request to switch the tools to getopt.

I might try that. Being an include-only library I don't think it gets much simpler than optparse while still supporting long options. Is there a better implementation we should be using?

That's portable and non-GPL?

is it MIT/BSD?

optparse is public domain

<@794205442175402004>, before I spend any time on it, can you confirm whether code released under the Unlicence is OK to integrate into libjxl? https://github.com/skeeto/optparse?tab=Unlicense-1-ov-file#readme

Uh, I guess so. I guess you'll make a derived work that you license under the libjxl license (BSD), or rather according to the CLA.

unlicense has historically been problematic for inclusion on many things and is widely considered incompatible with gpl

if libjxl wants to remain (l)GPL compatible, the answer will be no, author will need to add an MIT/BSD etc licence

The best license is the MGPL https://zapatopi.net/mindguard/mgpl.html

Huh?? Unlicense is a Public Domain dedication that permanently waives all copyprivilege

It's compatible with literally any other license

unlicence is public domain which not all countries recognize

this has caused headaches for me before when doing contract work, the OSI won't even touch public domain software now

or rather, exclusively public domain software

It doesn't prevent you from relicensing it under some other dumb license

And if you live in a country that doesn't recognize public domain, then why would your country recognize the non existent and voluntarily-waived legal privileges of someone who isn't even a citizen of your country?

it becomes spotty territory because such software is considered "not licenced" in which case, the end user can't do so

don't ask me, but the crux of the matter is, corporations will reject it because it's effectively nuclear. you can't re-licence yourself unless you get permission to

And who doesn't have those privileges in their home country, where they legally waived them all

https://web.archive.org/web/20150607123451/http://projects.opensource.org/pipermail/license-review/2012-January/000047.html

it has caused legal issues in the past, and will likely do so in the future, therefor it gets avoided and is not considered gpl compatible

the context which more directly relates https://groups.google.com/g/unlicense/c/G6pzAFtgrx0/m/9TCxE-je2qMJ

It's not nuclear and any corporation that thinks it is, is so stupid it doesn't deserve to exist. If I waive my legal privileges in my home country, and my own home country does not think I have them any more, then German companies should not be afraid of that

Even if Germany doesn't recognize public domain

no, because fundamentally we live in a world of many countries, and anyone who thinks they know every countries laws regarding this is a fool. public domain software **has** caused issues in the past

it's not a matter of if

**The point is that such things have done serious harm to developers when they've not behaved as expected in court.**

is an exact quote

If my own home country recognizes I legally waived all privileges and authority over something, then why would a foreign country that I'm not even a citizen of try to defend and protect my work

What a ridiculous argument. Any corporation that thinks like this deserves to fail

Google might have a policy against public domain software...

Google does deserve to fail and die for a variety of reasons but unfortunately they are one of the stewards of the libjxl project...

Can't someone just take a PD work and relicense it under an MIT license?

If you're really thinking about this then I recommend you consider using getopt, since it's very similar to optparse, and it's the most common and most "battle-tested" method of command line option parsing.

And it's pretty easy to find a standards compliant freely licensed getopt for every platform

There's also getopt_long for long options...

But personally I prefer single letter switches and parameters... less typing, more ergonomic.

It would be nice if long options were not needed...

sure it might be stupid, but laws have never been about being sane or not

whether it makes sense or not doesn't matter, what matter is if it is that way or not, and sadly, it is

this in general is a good thread to read

Not really, it's more just corporate idiocy

Corporations and government constantly compete for who's the most harmfully stupid

There is no justifiable reason for any corporation to worry about something so idiotic

And use that as grounds for not accepting freely given work from a foreigner

>no justifiable reason getting in legal trouble isn't a justifable reason?

How could you get in legal trouble for using a work that was freely given by a foreigner who voluntarily waived all of their legal privileges over it in their own home country?

It's a bizarre and deranged thing to worry about

again, **it has already happened**

> > The point is that such things have done serious harm to developers when > they've not behaved as expected in court. Thus, naïvely propagating one > could be considered to be in the category of irresponsible acts that can > damage others. In general I suggest that such things be discussed as a > list of goals rather than an actual license prototype constructed by a > non-legal-professional. > > Thanks > > Bruce

...How?

because law is a very complicated topic and happens not only on a per country basis, but also something that has issues on sub levels such as states in america or provinces in canada

even rhel doesn't want to allow CC0 anymore

https://lists.fedoraproject.org/archives/list/legal@lists.fedoraproject.org/thread/RRYM3CLYJYW64VSQIXY6IF3TCDZGS6LM/

ahh this one might specifically be a fedora one, hard to tell with them

but yes, in general, public domain only projects are no bueno

Are you claiming that in the past, someone released something under public domain waiver, and some German tried to use it, and the foreigner went to a German court and was awarded damages for infringing on a work they already waived their control of?

german? no. I don't know who, nor do I care who, bruce perens, has worked on a lot of legal stuff, from HP, source labs, etc. He is well versed in the many instantiates of the various laws. and has first hand knowledge of *someone* having the issue (the threads in question is now lost I believe)

but thats the thing, *everyone* dives in head first, this is also an issue with ffmpeg's GPL builds. They are only gpl valid in *some* countries that don't practice patent law like I believe france?

but many projects need to consider a great many countries when it comes to legality. which is why, public domain software is not considered GPL

And the German court awarded damages for infringing on privileges that are not even recognized in the foreigner's home country? I'm using Germany as an example because that's the only country I have heard of that supposedly doesn't recognize "public domain"

It seems like an absolutely deranged thing to be worried about or to use as justification for not accepting free and unencumbered work

in the end, it will cause friction, when the easy alternative is to simply use something with an actual licence like MIT or BSD

Every country has their own copyright laws and certain trade agreements stipulate that member nations recognize and protect the copyrighted works from other member nations as part of the crooked trade agreement. But if a work is not copyrighted in its country of origin then there is no reason why a foreign country would recognize and protect the copyright of a foreign country that doesn't exist in that country.

So if an American waives all their privileges with a PD waiver, there is no copyright. Their government doesn't recognize it and the German copyright law doesn't apply here or mean anything.

And Germans should be able to use it too because it wasn't made in Germany.

They would just have to relicense any of their German-made changes under a German-compatible license

I mean, you can say whatever you want, it won't change anything, public domain software has given companies issues in the past, and because of this, lots of people will avoid it, this can, and will cause issues with libjxl adoption if it becomes part of libjxl in a way that is not easy to disable

I don't agree with this, but it's the shitty thing we have to deal with

Well, first of all, the cjxl/djxl tools really ought to be carved out into a separate build system and source tree

I agree, that would solve that issue really quickly

The libjxl code does not need to be mixed up with the dependency-ridden cjxl/djxl utilities

I imagine that https://en.wikipedia.org/wiki/Berne_Convention probably has something to do with it

> Foreign authors are given the same rights and privileges to copyrighted material as domestic authors in any country that ratified the convention.

if the phrasing is that authoring the work anywhere gives you copyright in each ratifying country then it doesn't necessarily follow that renouncing it in one country applies to all

anyway, CC0 is probably safer https://creativecommons.org/publicdomain/zero/1.0/legalcode.en

fedora doesn't allow cc0 for code any more, just "content" (pictures and stuff) https://docs.fedoraproject.org/en-US/legal/allowed-licenses/ so legally, maybe safer? but adoption wise, for sure worse

I had an idea to simplify patch detection for things like emulator screenshots and tiled pixel art. How hard would it be to implement something like a `--patch_grid_tile_size` that takes a height,width (or just a size for a power-of-two square if that's easier), and a `--patch_grid_offset`, which tells the encoder to do patch detection just on the whole tiles in the grid?

So they don't allow PD because that's not a thing in most countries, but right here in this thread we see RHEL assuming that US law applies everywhere: they assume that any license without any explicit statements about parents, implicitly has a patent grant. This is true in the US (there's a court case setting precedent). But AFAIK it's not true anywhere else. They say that any license that doesn't grant patents isn't a FOSS license, but that would mean that e.g. the MIT license isn't a FOSS license as soon as you leave the US.

Red Hat is known for being a dumb corporate entity run by lawyers

Most copyright licenses are patent agnostic

A patent license can always be granted in a separate document if required

I disagree with this, MIT and BSD etc implicitly grant a patent licence, as if they didn't it would just be an outright lie

Usually in a file called `PATENTS`

dealing with software without restrictions strongly implies the right to use/distribute etc the technology in said software

That has only been tested under US law. Copyright licenses can't do all sorts of non-copyright stuff, and shouldn't be assumed to unless proven otherwise.

I would argue that if you do not have a right to grant patent usage, using the MIT/BSD licence is just fraudulent

Doesn't matter if you agree or not. All that matters is what your idiotic lawyer overlords say

thankfully, organizations that do deal with international law like the OSI largely find these safe

We have given lawyers license to run the whole world

"strongly implies" is not good enough! A public domain grant also strongly implies that anyone should be allowed to do anything even if the actual concept doesn't exist in law, but it wasn't good enough.

Because it makes us feel safe

obviously they can't deal with every single country, but they do deal with a large amount of them

thats not true though

public domain grant implies public domain.

MIT/BSD explicitly state "you can use/distribute the software without restrictions" public domain licences explicitly state "this software is public domain"

It's pretty obvious what someone means when they do it.

it doesn't matter because what is explicitly said

We have to do whatever the lawyers say because apparently that's the rules now. Safety above freedom and common sense, that's everyone's implicit priorities.

And again, copyright licenses literally cannot do anything about patents!

when you explicitly say "you can use/distribute the software without restrictions" that means "you can use/distribute the software without restrictions" if you need an additional patent licence, then the statement is simply untrue

They have to be general contracts to be able to deal with non-copyright stuff.

You're trying to use logic and common sense in a world where lawyers keep us safe

Though of course lately the American free software community has been more open to the idea that software licenses should be considered contracts. For a long time they always argued that they aren't contracts.

well, thankfully, almost every single major entity that deals with copyright and patent law in the foss world disagrees with this sentiment

Wrong

I've only ever seen them cite that one America court case

I've never seen evidence presented about law in other countries.

ok and?

that doesn't matter

You're saying we don't need evidence regarding the law in other countries?

We only need to care about US law?

The entire world has clearly shown that we collectively care about safety more than logic and freedom and common sense, so there's no point in trying to make sense or resist, just obey the lawyers. They're in charge now.

no, I am saying I only need to care about what the lawyers of said country reccomends

and pretty much every lawyer dealing with this, regardless of country, can't seem to find major issue with it, which is why international groups like the OSI give it the A-OK

IME, European lawyers disagree with American free software orgs all the time.

not that OSI is the only group dealing with international law, but I have yet to see any group massively disagree

For example, the GPL is probably equivalent to the LGPL in the EU. But do orgs like the OSI ever talk about that? Not in my experience.

how so?

Wdym?

how is GPL equivalent to LGPL in the EU?

the reference software HM for HEVC (https://github.com/listenlink/HM/tree/master) is BSD licensed

but that doesn't mean that it's not heavily patent encumbered too

I don't remember the argument because it's been a few years since I read it, but I trust EU lawyers when it comes to EU law.

yes, this is one of the things I strongly disagree with, FFMPEG does this crap too

ffmpeg's GPL builds are by definition not gpl unless you are in a country that does not respect patent licences

GPL v2 and BSD are copyright licenses only. GPL v3 and Apache 2 are licenses that combine a copyright license and a patent license.

at least that's how I understand things

Only US and Japan that I know of, recognize software patents

Another fun one I remember is how US orgs continued to insist that the GPL is not a contract, over and over and over, and when you said that in France, it is considered a contract, they just dismiss it as irrelevant.

gplv2's patent usage is a gray situation but most people I have talked with find that it adequately covers patent usage, not that it matters though because ffmpeg will still let you violate gplv3 without complaining

Software patents are not a thing in most of the world

Canada does, and some european countries do, I don't know them off the top of my head

Building FFMPEG isn't a violation no matter how fucked and conflicted the licenses are.

UK has software patents too but they do a bit weird iirc

I am not a lawyer but I would assume that a license that talks about copyright and distribution but does not mention the word "patent" at all, should not be considered to be a license that implicitly grants any patent rights.

that's simply not true?

well unless you mean for personal use

That's why I said building, not distributing

I think the reason us lawyers say a copyright license is not a contract is the same reason clicking "I agree" to iTunes terms and conditions isn't a contract either.

as far as I know, at least with the companies I worked with, licences that grant "usage without restrictions" imply that you can use the software without restriction, hence a patent grant

You're waiving your "rights" (privileges) under copyright law

that being said, there are programs which, to them wrongfully grant said patents, which can be sticky

that being said, from what I have heard, the penalties from that are mostly "just stop using said tech then"

It's a waiver, not a contract

And you can't implicitly bind someone else to a contract so easily without having anything in writing

BSD says nothing about "usage without restrictions".

You can only waive your own "rights"

MIT says: Copyright (c) <year> <copyright holders> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software

"to deal in" suggests distribution/selling, not using, but I'm not a native speaker

I am referring to a classification of licences

Calling them rights is also a misnomer since copyright law is about protection of trade and not about rights at all. It actually is designed to stomp on your rights by definition

the including part qualifies the "to deal with" part

ah the right to use is mentioned there

still I don't see how it necessarily grants any patent rights

the thought process is that one would not be able to use said software without patent rights, therefor if the licence does not grant them, the licence is simply wrong

Anyone receiving this software can use it "without restriction or limitation"

as far as copyright goes

It actually is agnostic about "permissions"

It doesn't say it's limited to copyright

but if I write an implementation of something company X has patents on, me giving everyone permission to use my thing does not magically also cause company X to grant patent rights to everyone

this is where it becomes a gray area, but because the licence does not explicitly limit itself to copyright, one could reasonably assume that patent licence would be granted as well which is a large part of how general stuff goes

It says "Permission is hereby granted, without restrictions or limitations"

then you would simply not be in the right by licenceing it as MIT

why not? as far as I'm concerned everyone can use it

but I may not be the only one you need permission from

only if they have a licence to do so, since you don't have the right to grant permissions for said patent, implying, which in this case is being done, is wrongful

I believe one could use the BSD licence here, but not the MIT licence

tho, I havent read BSD in a while

Copyright (c) the JPEG XL Project Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

What's the point of arguing about this anyways? None of this matters. Unless you are part of the unholy priesthood of lawyers, nothing we say about common sense matters.

yes, lawyers will always find ways to make things more complicated than they are

It's pretty clear that lawyers are in charge of everything because that's what collectively makes us feel safe apparently and nothing we can say will ever matter until we all collectively decide to stop putting lawyers in charge of everything.

Lawyers aren't in charge of anything

But that would mean we would have to stop caring about politicians, and I don't see that happening, because it's the world's favorite drama on TV

They literally write our laws and tell everyone on the planet what to do, especially big corporations like Google.

I had an idea to simplify patch

Basically either you want others to be able to use your stuff or you want them to pay you, either via copyright or via patent license fees. If you want people to be able to use it, give it some FOSS copyright license and make it royalty-free with an explicit patent grant. For libjxl we have a LICENSE file containing the copyright license and a PATENTS file containing a patent grant; you could also use something like Apache 2.0 that does both at the same time. If you don't want people to be able to use it without paying you, fine with me but then please make it clear what exactly you want: under what conditions do you need to pay and how much.

<@184373105588699137> I find it interesting that Fedora does package some public domain software despite the apparent legal problems.

All of our laws are written nowadays by corporate lawyers hired by and representing huge business interests like Google and P&G and Monsanto and whoever else has friends in high places.

No

Most "elected officials" have a background in law too

Most laws in the US are written by congressional staffers (people who work for the representatives and senators)

Knowing how the law works might be useful when working with the law? :p

Those staffers just take whatever gets handed to them verbatim by their ~~Owners~~ I mean ~~lobbyists~~ I mean ~~financial supporters~~ I mean patriotic entrepreneurs!

No

All of our healthcare laws are written by lawyers working for major hospitals and insurance companies with the most money and influence like Kaiser Permanente. All of our agriculture laws are written by the wealthiest biotech companies making GMO corn and soy.

It's like this with every field and industry that has money

Wherever there's lots of money there's always some sort of special arrangement

Government has always had the goal and purpose of consolidating wealth and power for those that already have it. It was never benign and never "yours" and never existed for any other reason except to pacify those it takes from.

This has never changed in over 10,000 years

But I'm getting off topic 😅

Point is corporate lawyers rule the world and keep everyone safe just like we wanted :)

Just like everyone wants and agreed to

I think its mostly they haven't gone indepth into it

cc0 was the only "major offender" afaik

Well as a former fedora user I am deeply offended

Do you know if it's possible to search the package database by license?

and its important to remeber that it's "public domain only" software

I think so, but I can't remeber

>former same

How dare they conveniently distribute cc0 software for me

I'm surprised they haven't been sued by the non existent copyright holder

I just looked up SBCL, since I know it's public domain (that's the most popular common lisp implementation). (Also, if you look it up and see "AND BSD-3" that's just a small number of files derived from code released by Xerox under that license, the vast majority of the code is PD only.)

In practice it seems like every company and distro will make exceptions and allow legally questionable software if it's important enough.

E.g. Google I believe has a policy against PD software, but they both use and contribute to SBCL (and yes, all their contributions are PD only)

Good. Their grip is weakening :)

https://tenor.com/view/palpatine-smile-creepy-creepy-smile-smirk-gif-24584761

to be fair, I thought the same thing about RHEL with the video accelerated codecs in mesa, but talking with one of the devs on phoronix and it was more or less implied that it actually did become an issue.

it just wasn't made public because it's often easier to just comply

https://tenor.com/view/tell-me-what-to-do-and-i-will-obey-beavis-what-do-i-do-i-will-follow-your-commands-whatever-you-say-gif-17564903546237075113

Submit. Comply. Obey...

https://azrael.digipen.edu/~mmead/www/Courses/CS180/getopt.html Found a good guide... It's a very similar API compared to optparse, and musl libc has a very simple and MIT licensed implementation that can be used on inferior joke platforms like Microsoft

Does libjxl output a single palette referenced by multiple frames if the colors of one frame are a subset of the colors in another frame?

Afaik libjxl has absolutely no intraframe logic of any kind

Dang

Is sharing one palette between multiple frames possible in the format?

layers, i mean, btw

The format itself is capable of just about anything. libjxl is just not a very sophisticated coder and doesn't use all the format features

It's just good enough to be usable as a proof of concept and to introduce the world to a taste of what's possible 😂

As the format gains more attention more sophisticated jxl encoders are expected, specialized for multi frame pixel art animations for example, or existing gif tools can be modified to output jxl instead of gif

I'm not degrading it to a proof of concept given how good it already is, some of its tuning was ported to other formats even, but yeah in terms of uncommon features that's fair

I expect vardct could be improved by another 20% savings at transparent bitrates just from improving the psycho-rdo tuning and fixing the blurring and color desaturation problems, even more savings if spline detection is added... lossless and animation could be improved by a gargantuan factor if there was more specialized optimization for common low bit depth color modes.

The current state of the encoder is like a basic proof of concept to demonstrate some of the strengths of the format and novel techniques, in a preliminary context, lacking major features like splines, and before it's undergone the same level of tuning as other lossy image tools like x264

As a DCT image codec it's already extremely strong and competitive. But it could go much much farther.

And it's capable of far more than just dct

It's actually very similar to djvu...

No, frames are independent. Though you could cheat by making a large invisible frame that uses a palette, and then patch it into visible frames.

Correction, I meant layers, not frames (I don't know if they're different or if it's just a terminology change depending on if it's an animated jxl)

Can the same palette not be referenced multiple times by its offset or something?

Hmm I suppose palettes are very little data anyway so it probably doesn't matter in most cases

if art uses a palette it usually doesn't have more than like 15 colors

Everything is frames in jxl. Layers are zero-duration frames. Pages are max-duration frames. Animation frames are any-other-duration frames.

Oh, I didn't even know JXL did pages. That explains why I've seen people wanting to use it as a format for storing whole comics

There needs to be some clarification regarding animations and pages mixed and whether the animations can loop or not iirc

Yeah, that musl implementation could work if I de-Unix it slightly.

The musl code is so clean and simple 😻

You're looking for include/getopt.h, misc/getopt.c and misc/getopt_long.c

There's nothing unixy in there afaict

It's just super clean.

Well there's unistd.h for a start 🙂 - at least there is if I go straight to the source. I've seen a couple of other repos with just the cleaned-up musl getopt, but they seem to be old and missing a recent bug fix or two

https://git.musl-libc.org/cgit/musl/tree/src/misc/getopt.c

Windows users do not need unistd.h at all.

Windows users can use getopt.h instead of unistd.h

That file only includes getopt interface definitions.

For people who aren't using a crayon OS, unistd.h is the standard header where getopt is defined.

You only need include/getopt.h and misc/getopt.c and optionally misc/getopt_long.c if you want to support --long-options that are a pain in the ass to type

You can also modify the musl code to accept slash `/` instead of dash `-` for options, since that's conventional on crayonOS

in addition to, not instead of.

https://git.musl-libc.org/cgit/musl/tree/src/misc/getopt.c someone would have to try compiling this on windows and remove anything that isn't defined on that platform or that doesn't serve any purpose there. Alternatively I think there is a posix like toolchain available that could provide missing interfaces on that platform without borrowing code from musl

The main thing is just adapting the tools to use the getopt interface without introducing any bugs

That's what I meant by de-Unixing. I was going to avoid making any incompatible changes to the CLI, so we would of course need to support long options, even if we supplement them with new single-letter options for faster typing.

Yeah, taking a closer look at getopt.c there are a few things that need to be tweaked for windows to be happy.

CrayonOS?

Mostly just deleting a few lines

Yeah, windows and other joke systems made with crayons and elmer's paste

When encoding a JXL file via libjxl, is it OK to add metadata Exif,xml via JxlEncoderAddBox even before calling JxlEncoderSetBasicInfo ? Just curious.

Good question. I guess it should be ok?

I thought pages were frames with negative duration

but they didn't have to be -1

(signed int32)

Spec says only 0xffffffff means page break

Duration is unsigned

ye I was using signed for convenience

by negative I mean >= 0x80 00 00 00

In practice, durations over 2^31 ticks are gonna be very long unless you have an insanely short tick

So in a viewer you'd want to manually navigate between the frames anyway, which is kind of the same thing as page navigation.

I guess

I just don't *really* understand the value of saving a whole set of comic pages as an "animated" jxl file instead of using a pre-established format like CBZ

which is just a `.zip` with images as files

considering zip has a page index for fast seeking I imagine that would be preferable, or if there's say a page that's bigger than the others cause it's a double

I guess the value could be that it would also work in generic image viewers or web browsers (kinda, you'd probably just see only the first page), while something like cbz mostly only works in comic book viewers

For fast seeking you could add a jxli box in principle

Pages with different sizes are I guess both nice to have and a bit inconvenient since it is not well-defined how to display them relative to one another, so you might get behavior where the scale suddenly changes or you unexpectedly need to scroll. In jxl you can still have frame content of different sizes but the canvas has constant size.

Anyway, compression-wise, an advantage of putting pages in a single jxl is that an encoder can take patches from previous pages. E.g. for static headers/footers or elements that appear on several pages, that could be a big compression gain.

Could you extend this to say, patch copying the whole previous page to kAdd-blend it onto the next one? Like for a simple format for making use of redundancy between burst photos, where the current photo is encoded as the residuals of the current photo minus the previous one

Yes that's what kAdd blending was meant for in the first place

Ooo. Time for me to take some burst shots and do some benchmarks

Actually I'll have to see if I can do that in Krita, it can do blend modes on layers but it doesn't give you control over patches I don't think...

apropos layers, I opened the issue regarding cjxl's coalescing of layers in JXL-JXL conversions

https://github.com/libjxl/libjxl/issues/4097

The encoder in libjxl does not try to do anything regarding inter frame, it just encodes what you give it. You could manually set the frame blend mode to kAdd though (and subtract the previous frame before encoding).

When doing lossless that could work. For lossy, you would need to use patches to do the adding in XYB...

That's what I'd been doing in Krita for my image decomposition experiments. I didn't immediately see how I could make a chain of frames referencing each other. mostly the layer dock is just confusing to me I think. I'll figure it out

Probably start with the base image and then add consecutive residual layers above it in 'add' mode

Sounds like a bit of work to do every time, especially creating those residual frames is in their own process too. I should look into if this can be scripted

A 'create compressed burst stack' script for Krita would probably be useful to some

You could probably even store exposure-bracketed shots efficiently by creating kReferenceOnly frames that are just a single-value multiplier from one frame to the next, to equalize the exposure before taking the subtraction residuals

who would send a whole comic just to display the first page on a webpage, though

find a way to terminate the stream early, though that'd be pretty cursed

Maybe if the rest can be shown via a js viewer, or if browsers implement native page navigation?

HTTP 206 Partial Content

there are some image viewers (like MacOS's Preview), that actually open animated files as multi-frame static images (as in, you can manually select frames)

something like this

I actually don't know if Preview supports opening animated **jxl** files this way though

(it doesn't, just tried 😦)

Animated JXL support is not yet in place

But I would wager it's likely to come

It would be good for things like burst photo

Moreso for the camera apps by certain manufacturers who allow for capturing a burst series directly into a GIF

ew

Yes

lol

It's horrible

But at least it could be JXL

would make it leagues better

That's what I'm experimenting with today actually

If you read up a bit, I wanted to store burst images as the difference between the previous frame and the current one

If I can get Krita to do what I want that is :)

Sounds good if you're able to get it working

I checked, the created GIF in Samsung's camera app will be 480x640 and have 5 whole FPS

Another thing you might be able to do do with JXL's basic interframe coding is store exposure bracketed bursts by also multiplying by an invisible layer that's a frame with one value, to normalize for the exposure before taking the difference

Not entirely sure if that's possible in Krita since multiplying something by the max value of a pixel appears to be a no-op

If it's not possible in general you'd have to start at the darkest shot and use division instead, to get the brighter shots down to the exposure of the previous one

But that shifts the problem of multiplying by something greater than 1 to the decoding step, so idk. I'm just going to start with normal bursts and see about exposure bracketing later

why are we still living in the 90's... <:PepeHands:808829977608323112>

no APNG support? 😭

I got a few questions about the libjxl .. well lib. I'm currently working on making a backup of my drawing folder, and in there are quiet a few scans. Now they all are scanned in lossless (`.tif`), and currently are stored as `.png `(some rgb, some gray). - My question revolves mainly around the following line from the repo: > Note: This release is for evaluation purposes and may contain bugs I assume this only applies to the newer features being implemented, and less so to the general *encoding* / *decoding* in *lossless* / *lossy* quality, right? Like it would be safe to use, for the task of lossless encoding, right? - My second question would be a bit less on-topic, but still is fairly important. How "vulnerable" is `.jxl` encoding? Like when the *body* and/or *header* is damaged, how well can parts of it still be recovered? I sadly do not know how other formats like `.png, .jpg, .tif (LZMA and None)` them self hold up regarding that, but it would interesting to know, if you guys know anything about that? -# I ask this out of interest, less to skip the 1-2-3 principle, which I just can't full-fill financially. -# I yet have to read in to testing such things as redundancy and recover-ability myself, but not enough time and I do not know apportion resources for that yet, since I want to do "realistic" and varied tests. - And my last question is as follows: Since I'm going to convert multiple images by command, -# better said using python tkinter filedialog to select files and running the cjxl.exe a bunch of time with popen or the alike, is the command correct for lossless encoding? : `cjxl.exe sample.png sample_jxl.jxl -d 0.0 -e 10` Thank you for you time -# and also the Jxl implementation btw

1. will depend on what level of risk you're comfortable with. There *have* been bugs that make the lossless encoding not fully lossless. Personally I trust it enough that I've converted practically every PNG I have into lossless JXL - I use a conversion script that verifies the result by decoding back to PNG and comparing the pixel values to the original. Note that converting PNG to JXL with cjxl will discard any metadata other than Exif and XMP.

2. Others might give a more detailed answer, but bit-rot is probably more damaging to JXL than PNG in general just because of its density. There has been discussion of an option for djxl for attempting to decode broken inputs, but it hasn't been implemented yet.

3. Yeah, the command looks fine if you have the patience for -e 10.

point 1: no, the lossy and lossless encoders in libjxl can contain bugs too. libjxl does NOT do any final sanity-check on the encoder output to ensure lossless output is truly reversible, or to ensure lossy output does not have any regions with extreme and unexpected levels of distortion and loss. You have to test this yourself to make sure there are no serious problems with the output point 2: the header is extremely compact and bit packed, the image is divided into regional chunks, but someone more familiar with the bitstream would have to say whether it's possible to scan for signatures and magic numbers and partially recover parts of the image that way. If the toc is damaged it's possible you might end up with image chunks you have to manually re-order in the right place like a jigsaw puzzle? point 3: effort 10 is really not recommended. I would recommend effort 1 or 2 for maximum speed, effort 7 (default) for 98% the compression of e10 at much improved speed, and I would not recommend anything above e7 unless you are insane in the membrane.

That last 2% increases your wait time by 200x

That's a bad trade

If you're going for maximum compression, you might want to add `--compress_boxes=1` `--brotli_effort=11` to compress the metadata more. There are other options worth playing with too (-I, -E, -g)... plenty of discussion of these to be found in <#840831132009365514>.

Just don't be tempted by the "forbidden" effort level...

surprised compress boxes isn't default 🤔 edit: seems like it is from a quick test