JPEG XL

one of the things im looking forward to is just not using a libc

then you can never ever do GUI stuff 😔

im not sure this is true, if we had a all native rust stuff it could work

graphics drivers must be loaded dynamically, since you don't know what drivers will be needed

and modern GUI practice is to use vulkan/opengl directly, rather than sending drawing commands to Xorg

but hey maybe we could do the stupid zig trick

get rid of libc as the method used by rust to talk to the kernel

add some startup code that checks which libc is in use

reload with it

bam you can now dlopen system libraries if you want to

there was a really neat thing I read about potentially getting around this a long time ago, ill try and find it again

this can be done with some effort and eyra probably

https://github.com/sunfishcode/eyra

C-gull is more or less a partial libc

oh wait, maybe im thinking of mustang, cant remeber https://github.com/sunfishcode/mustang#readme

> c-gull has two main cargo features: "take-charge" and "coexist-with-libc". One of these must be enabled. Now THAT is what is needed, excellent. Still needs a way to dynamically choosing which libc to use at runtime, tho.

jxl on 🅱️ista https://github.com/Eclipse-Community/r3dfox/releases/tag/v126.0.2v

https://github.com/Eclipse-Community/r3dfox/releases/tag/v127.0

TIL that RISC-V only has an approximate reciprocal square root instruction for vectors, not for the regular FP registers. So if you're using the regular FP regs, or simply don't have a CPU for the V extension, the old Quake trick may be useful again...

isn't that true also of x86/arm?

x86 and Arm uses the same registers for 128 bit vectors and for scalar FP, and have instruction variants for doing scalar or vector stuff. There are no separate scalar FP registers. RISC-V otoh does have separate FP registers for non-vectors, with completely separate instructions. If you're using floats and doubles in your code, it will almost certainly use these registers and not the vector ones, other than when the compiler figures it can auto-vectorize your code.

ah, fair

seems like an odd choice tbh

The full of "news page" on Samsung's original website is a JPEG picture <:monkaMega:809252622900789269> https://www.samsung.com/sec/event/GalaxyBook4Edge/comp/

Japaneses do that very often too... perhaps they are used to have strange behavior for CJK page layout in software written by English speaking people 😄

it's more of it's designed in microsoft word and just exported from that

Fun Arm fact: in addition to an instruction to compute an approximate reciprocal square root, it has an instruction that computes `(3.0 - in1*in2)/2.0`, which is about half of the steps needed for a Newton-Raphson iteration to improve an rsqrt guess. *Extremely* RISC!

Mozilla managed to break video demuxer 🤦‍♂️ Just curious how do they perform tests if it was not noticed in "stable" branch

Mozilla moment

not that hard to break

finally, I wrote my image board completely from scratch. no css, no js, no cookies, no connect sessions, no user agent or any any other. pure post/get.

``` #####*,`*|~~*|*~~*######## ####*###|,#####,*``#*#~*## ##****#|**#-**~*,+-****~_# ##.#|*#\*****#*\#+**,^}### ##,~,_##*``-*~,*#`*##*##** #####|#|##\,~~*~,+-*###*~# ####*|#**~,###\,.#+*+##### ###,*##-#*_,~~~,**#^*##### ##,/####*^#####*#**``##### #*_###,***---,*~+#**~*#### #####/####*`,~+~*~####~*## #####|###*`*#####~`#####*# ##`~*~**~#########,*####*# #(-**************,-****-##` ```

I had to invent my own function for finding the percentage of distortion. I did it through the pixel difference. For some reason, all the standard algorithms that I found, including those that the neural network recommended to me, are worse. I make a mask with all the letters and make a bruteforce of each character ```py def image_difference(img1, img2): diff = sum(map(lambda x, y: abs(x - y), img1.getdata(), img2.getdata())) return diff ``` for some reason, parallelizing this function makes execution 2-3 times worse. It's funny. It's also funny that I manually wrote it without NUMPY, although it would seem impossible for numpy to be slower. But it's true. My option is faster than numpy at ~20% ```py import numpy as np def image_difference(img1, img2): img1_gray = np.array(img1.convert("L")) img2_gray = np.array(img2.convert("L")) diff = np.sum(np.abs(img1_gray - img2_gray)) return diff ```

Completely random, but Elon makes a comparison to progressive image loading... Now if only most images actually used it https://youtu.be/aFqjoCbZ4ik?t=246

most images do use it

progressive jpeg is the most popular image format on the web

FB does not use progressive, while Instagram does

https://youtu.be/50jkO2s4Sp0

Saw somewhere (maybe even here?) video, when non native English asks native how many tenses there are in English, and native says - 3 😅 And is very surprised by the correct answer

Well, there are few inflections, but there are various tenses, I’d say. They just happen to be composed of auxiliary verbs instead of having a dedicated inflection.

yeah, the most irregular verb is “be”, which still has only 3 forms in the present simple

I am, I will be, I was, I have been, I had been, I would be, I would have been, I am being, I was being

(“I would be being” / “I will be being” seem more rare)

ah, I’m conflating with aspect and mood

https://en.wikipedia.org/wiki/Tense%E2%80%93aspect%E2%80%93mood#Tense-mood-aspect_conflation

> In the traditional grammatical description of some languages, including English, many Romance languages, and Greek and Latin, "tense" or the equivalent term in that language refers to a set of inflected or periphrastic verb forms that express a combination of tense, aspect, and mood.

lol steam is trying to send me a windows executable on my phone

The top starts with MZ and contains the dos mode thing

Slavonic are much "easier", no these "be" at all 😅

so, no question of to be or not to be?

hamlet, translated: “or not, that the question”

I meant no usage of be as helper word. Surely it is possible to say I am\was\will, but only in such case as Hamlet

Verbs are changed according to tense, with no helpers

That's why complex English tenses are a pitfall for most slavonic people, it is just against the way of tenses are constructed in slavonic languages. And I'm not the exclusion, sadly

Well, I tried to imagine where we can say "I am", but it is not used. Only to translate "I am Groot", or something similar. I was\will is used, of course

there is no verb of being?

no cogito, ergo sum in Slavonic languages? 😮

There is, but it is not used as verb helper. I mean like "I stand" -> "I stood", but for all verbs and for all tenses. It is impossible to say "I was standing", only "I was <somewhere>"

oh, I see what you meant

Well, maybe it is true only for eastern slavonic, probably central and western are closer to Romance languages in this. But for eastern - it is so

And also no differentiation between simple and continuous, only one form

Somewhere Slavonic languages are easier than Romance, somewhere much more complex

I find it funny that "to be" in Hebrew has no present tense

it has future and past

but in present you leave it out

“what else would you do than be?”

The same

i just spent 30 minutes debugging before realising the bug is I am returning a `uint16_t` instead of a `uint32_t`

yaaay

i love programming

oops

Steam installer?

https://x.com/summer__heidi/status/1807554013048799340

yoooo https://scottaaronson.blog/?p=8088

can someone help, I want to make my own image format

Compressed or uncompressed?

useless use <:JXL:805850130203934781>

https://cdn.discordapp.com/emojis/862625638238257183.webp?size=48&quality=lossless&name=av1_chad

You can simply fork QOI

my own image format would have file extention .rgb, be stored in 8 bit rgb values so for example pure whit 2x2 pixels would be 255,255,255-255,255,255;255,255,255 as you can notice each pixel is seperated by a - and each row of pixels seperated by a ; originaly it was going to have saturation and brightness, but those aren't realy needed

I use chatgpt because I cannot code

Conglaturations, you've just invented your image format. Fantastically inefficient, but the task is done

I think we can go even more inefficient and store each pixel in a separate file and each row of pixel in a folder.

We display the image using the Windows thumbnail system

Sounds a lot like a weird version of ppm

Reminds me of XBM/XPM

https://en.m.wikipedia.org/wiki/X_PixMap

This?

I independently invented XPM when I was playing with graphics in Turbo Pascal.

help

lmao

[⠀](https://cdn.discordapp.com/emojis/922856164834828358.gif?size=48&quality=lossless&name=hellowtf)

How do you have so much space

Hundreds of petabytes? That is quite a lot...

~~storing videos in raw YUV~~

I think macOS’s implementation of SMBv3 is buggy

https://reddit.com/r/ffmpeg/comments/1dy49bz/i_built_ffmpeg_online_inbrowser_terminal_with

[⠀](https://cdn.discordapp.com/emojis/853492103145324554.webp?size=48&quality=lossless&name=woag)

Ooh

''

The free trial is expanded to 6 months https://affinity.serif.com/en-us/trial/

The suite supports JPEG XL as well

i use this

it's good

I've spent much on Clip Studio Paint Ex so I haven't upgraded my Affinity suite

Broken lol

This is what music looks like. Ultra-large spectrogram. 40,000,000 calls of processing the Discrete Fourier Transform. The pitch was calculated in increments of 4 hertz, the duration in increments of 25 hertz. That is, each pixel next to the right is the signal power at a frequency of 25 hertz from the previous pixel. The "window width" is 500 hertz. There are only 4 seconds of sound here. I wrote the code in python from scratch using the DFT forums from wikipedia and gemini 1.5 for keep being dumb. STRESS normalization has been performed on the image (Spatial-Temporal Retinex-Inspired Envelope with Stochastic Sampling)

For some reason, OPUS sounds SO MUCH better at 5.6kbps vs 6.0kbps when using CBR

Cbr with opus is always worse. Let him work without constraints! 😁

I’m specifically doing nonsense stuff with the encoder lol

Also 5.6kbps will suck no matter what rate control

Wondered why my computer was making extra noise... Turns out the No Man's Sky update page doesn't unload any assets when you scroll past, so my GPU decode was at 90% while I was reading the text changelog at the bottom https://www.nomanssky.com/worlds-part-i-update/

speaking of No Man's Sky, do they still artificially limit themselves to Vulkan **1.0**?

last I checked the game ships with a old 2016 compile of the Vulkan API dll meant to fix an issue with some old Intel iGPUs, an issue that's been fixed in the Vulkan dlls since like 2016

don't know if it's placebo or not but I usually recommend people to delete `vulkan-1.dll` from their install of the game so it uses the newer one provided by the installed GPU drivers

There's a licence file dated 14-08-2019 which says this > vulkan-1.dll (Vulkan-Loader) is distributed under the terms of the Apache License. > > The version of Vulkan-Loader distributed with No Man's Sky contains a workaround for a crash. > A discussion of this issue (and the workaround included in this binary) is available at > https://github.com/KhronosGroup/Vulkan-Loader/issues/182

The DLL itself is dated 01-03-2023 `Vulkan Loader - Dev Build` File version `1.0.1111.2222`

hmm my dates where off although that DLL version is for Vulkan 1.0 which means they are still limiting themselves to Vulkan 1.0 also I was off about the bug being Intel related however I think my misremembering of both comes from me thinking of possible reasons why they wouldn't update to Vulkan 1.1 or newer and the only reason I could think of was because of old Intel iGPUs around 2016 which only got support for Vulkan 1.0 and then stopped getting updates which is probably where the mixup in my brain happened

tbh if I would to pick a baseline version of Vulkan to use for good compat across older GPUs in a modern'ish targeted engine I would just pick 1.1 since like mentioned the only real GPUs stuck on 1.0 are Intel iGPUs from a certain time

semi-offtopic but I still find the native Apple silicon version/port of the game to be intriguing https://www.nomanssky.com/2023/06/no-mans-sky-on-mac/

Vulkan 1.2 made a point of not needing any new hardware, so that would be the ideal if you're already cutting off those intel chips. Although I can't actually find any benefits to upgrading, it's mostly just extensions added and hardware features implemented like ray tracing and variable rate shading. I imagine they'll change if they actually want or need those features

Because Heisenberg's uncertainty principle imposes a fundamental limitation (fucking physics) on the simultaneous measurement of time and frequency. — The more precisely you want to determine the moment in time, the less accurately you will be able to determine the frequency, and vice versa. It is impossible to obtain perfectly accurate information about the frequency and time of the signal at the same time. A large window size (increasing the time resolution) reduces the frequency resolution, and vice versa. There are three different ways to create a spectrogram as accurately as possible. (Window size 400 Hertz) 1. https://en.wikipedia.org/wiki/Discrete_Fourier_transform 2. https://en.wikipedia.org/wiki/Wigner_quasiprobability_distribution 3. https://en.wikipedia.org/wiki/Chirplet_transform

You don't even need to invoke Heisenberg for that. The uncertainty principle applies to all waves, even non-physical ones.

<:PepeHands:808829977608323112>

finally! db

https://youtu.be/9wk4ApHloHM

my favorite joke is when people ask me about ffmpeg: Oh yes, just look at the hint, everything is clear there: ffmpeg -h full

I love ffmpeg

how dare you

[⠀](https://cdn.discordapp.com/emojis/659513552033415188.webp?size=48&quality=lossless&name=av1_pepegun)

Plz the ffmpeg UI is very easy to use if you've been using it for over a decade

xD

Logarithmic spectrogram of small size, logarithmic window size (from 10000 to 10) Power in decibels Output sound The actual amount of information per sound duration is equal to a bitrate of 84 kbit

So, as far as I understand, I have now advanced in the topic of decoding spectrograms, to the top 10 in the world. On an equal footing with people who make neural networks to generate a voice from a spectrogram What are the current problems that need to be solved so that the generated sound sounds better 1. The size of the window, for different frequency ranges. Mostly for the lower ones, because this is the most problematic part. The lowest from 20 to 200 hertz is the most problematic part, because of the very small amount of very important information, the waves. But it sounds solvable. 2. The phase. Perhaps the most important problem at the moment. The signals have a random initial phase, I set it up. Due to the zero phase, all phases resonated. But because of the random phases, the signal sounds fake. Having absolutely zero harmonics <:FeelsReadingMan:808827102278451241>

I have an idea, you could possibly encode info about the phase in colors?

Like HSB

the idea sounds good.... but I would like that at the end of the story it could be printed on a powder black and white printer

Two spectrograms interleaved?

What’s the project exactly?

can make 2 spectrograms, sine and cosine. When they are ideally superimposed, the spectrograms will interfere in the desired phase. But The degree of overlap should be ideal

python pure math code use wikipedia formulas

I know that there are no such projects, that's enough. the closest thing that exists is "phonopaper"

The problem is very obvious — generating an ultra-accurate spectrogram using formulas is a very, very slow. I have parallelized ryzen 5 zen 4 into 16 threads Most likely no one has ever done project like this in 2000-2015

many documentt about waves were written during these times: 1980-2010

linear mel bark erb log

okay, I'll try to do the inverse Fourier transform on 2 spectrograms. I am concerned about the inaccuracy of reading 2 spectrogramms of paper. but apparently this is the best way, I'll start doing it soon HSB for color is a good thing in its own way. although initially I thought to put the information in RgB — 255, 0, 255 sine power and cosine power. but hsv sounds even better.

yeah

could you recall me what's the goal here ?

sound on paper (HIFI)

💪

paper ? like printed spectrogramms to be scanned and transformed to audio again ?

I'm already very close to the correct phase interpolation, I just need to figure out where the error is

do you print ? or do you use only the digital picture file ?

https://discord.com/channels/794206087879852103/806898911091753051/1265082013266743328 you can listen to the generation result without taking into account the phase

did you tried to filter out the final result you get with an anti aliasing (low pass) filter ? with a cut frequency at 44.1 Hz (if it's your initial signal freq)

print later. now I'm only doing tests with very low-resolution digital versions to understand that I'm not wasting time, so far I'm happy with everything

this is not necessary, I am using the BARK scale now.

https://en.wikipedia.org/wiki/Bark_scale#/media/File:Bark_scale.png

but this sound uses Logarithmic scale

heh

phase is absolutely real bruh

I decided to use another method. After generating the spectrogram, using the same Fourier DFT algorithm, I generate the total phase of each frequency (the sum of all phases on each herz of the entire sound, frequency which is in the spectrogram) - and record it as separate values. It's working well at the moment. The signal does sound better, not perfect, but better!

Information about the phase shift of the signal for each frequency separately (the average) The number / 100 * 2 * 3.141 93 43 49 74 27 98 98 86 82 56 85 21 18 92 16 76 03 05 88 27 95 83 28 91 44 38 12 95 13 85 42 73 12 64 25 15 49 74 41 83 52 76 14 15 48 67 05 47 74 93 13 98 68 15 03 29 90 55 19 53 71 00 75 88 47 55 36 04 76 99 88 49 24 82 33 99 61 19 76 81 64 54 76 81 56 91 23 97 73 73 98 04 58 58 13 86 43 87 71 80 20 17 07 96 13 68 75 28 56 02 50 03 51 80 88 33 16 62 89 52 30 92 69 14 78 17 31 86 04 84 13 94 88 13 70 98 78 92 88 66 27 07 09 33 97 56 77 46 98 59 85 07 90 75 59 75 79 59 31 45 54 54 56 92 75 11 10 15 89 99 91 30 24 11 17 26 43 46 73 54 43 59 76 71 30 80 51 78 97 36 74 56 79 66 02 15 86 88 37 49 66 03 96 64 77 27 69 18 04 90 79 64 77 15 33 33 54 89 64 28 28 36 87 09 07 39 61 89 80 97 34 31 93 68 29 35 92 85 10 55

bottom line the method doesn't suit me, so I'm search for other ways.

These are all beautiful pictures, of course, it's a pity.

oh yeah I invented Movietone track with variable density in 2024 <:Opus:805856410235437068>

in general. Everything analog is shit. Compress OPUS using "PAPERBACK" to print on paper. Analog is shit

❤️‍🔥<:Opus:805856410235437068> 💪

the only thing that I was able to use normally was encoding the sound in the image. That this sound is quite noise-proof from compression. Compression will increase the signal noise, but will not spoil the signal.

Wave samples stored in the range from 0 to 255 png. and then shifted by 128, to -128 to 128 in the wave - so technically it is an 8 bit wav file in the image

analog-digital file... any scale of the image will ruin everything.

it also clearly demonstrates how compression methods, without any psychoacoustics algorithms at all, can compress sound. For example WEBP q5

jpeg q10 (the same size as webp) a very good way to literally hear: although there is no psychoacoustics, the complexity of the algorithms and more efficient compression are much better in WEBP than in JPEG. And you can listen to it as the difference of artifacts.

i've done something similar before, it's really fun

you can quite literally hear the 8x8 dct blocks

what program are you using to make them? I just use ffmpeg

I like doing the other way around as well, convert image to audio then back to image

write pure python math, wave

<:ReeCat:806087208678588437> use neural network to wrote

Wav file get samples in list[] ÷ 32768 × 256 +128 put in pixel, (use python pillow)

decode: get pixel data -128 ÷256×32768 put in wave sample

this is what happens when you encode rgb24 data as Opus u8 data

looks kinda like old analog video

MDCT <:Stonks:806137886726553651> & Round

wave is wave

the colors drop because color is represented as high frequency data

and sometime the high frequency data is dropped

fair

my face when I realized that the frequency of 20,000 hertz contains 20,000 times more information than 1 hertz 🥴

Is it possible to use JPEG directly to store those audio files, without converting to pixels?

AFAIR it stores frequencies, not pixels, so might be advantageous for audio.

<@129256926088396800> take a listen tomorrow

I guess if you have 8 channel audio?

Cross talk is terrible though

a good idea, but block based DCT as used in jpeg will not work well with audio

MDCT is used instead which has overlapping between adjacent blocks

Non overlapped DCT will cause very severe clicks and pops at block boundaries

Wherever there are discontinuities

Also, not really useful for digital compression

https://en.m.wikipedia.org/wiki/Slow-scan_television

But SSTV converts an image into audio

When I did this with low jpeg quality it almost sounded like bitcrusher

And then the receiver decodes the audio into an image

But without compression artifacting

paper print. paper scan. paper decode, paper analog music <:PepeOK:805388754545934396> closed this topic

Music saved digitally using PaperBack ( https://github.com/Wikinaut/paperback-cli ) to create a block code for printing. The sound is encoded by the neuro-codec EnCodec ( https://github.com/facebookresearch/encodec ) ~9 Kbit/s

After listening to the others, that one has shocking quality

This is nothing new actually. Optical sound recording, both analog and digital, is used in film.

like shockingly good or bad?

imo the Encodec version sounds significantly better

Well after listening to

That

And suddenly having full stereo at good quality, I forgot how good having hearing is

im not surprised the digital route sounds better, it allows for more resilience when it comes to alignment and such

Yeah

also how dare they send a jpeg instead of a jxl

im guessing just lossless jpeg->jxl?

yep ``` JPEG bitstream reconstruction data available ```

Yeah, tried a d1 lossy but the artefacts and being greyscale meant it was the same as the original

3 GB of RAM to do the transcode though, I do wonder if we could do chunked encoding on that too

https://en.wikipedia.org/wiki/Sound-on-film

lossy modular could work?

just wondering what's the source file?

https://www.youtube.com/watch?v=tg--L9TKL0I

It was a good video as always

agreed

nah use mp2 compression lmao

I have already conducted my testing, the best codec for music, for bitrates lower than 8 kbit. this (by a huge margin in quality) is Vorbis

vorbis at 8kbps??

💪 best

don't even know if that's possible

hang on

lemme check

ffmpeg doesn't even let me encode below 48kbps for opus

4000 hz 8 kbps

oh you lowered the sample rate

that no codec can be higher ..... except for the Encodec neural network - which is ahead of everyone else

For some reason that doesn't play with the embed

opus @ 5.6 kbps

opus embed is a bit funny sometimes

idk why

opus is not interesting at such bitrates. use vorbis

discord moment

how do you get vorbis to encode at less than 48kbps

That's FLAC but yeah, annoyingly Discord doesn't embed formats it already supports

it just doesn't let me

for what

Probably use the reference tools instead of ffmpeg

huh using .ogg instead of .opus works

double weird because `.opus` is basically just `.ogg`

I'm serious, it's a waste of time. All you have to do is download the original vorbis encoder and lower the frequency. But this makes no sense, Vorbis as a codec, in principle, remained necessary only in games - because so far no one has created a codec that would be decoded so fast so instantaneous.

For some reason, encodec doesn't launch on my computer ``` Traceback (most recent call last): File "/Library/Frameworks/Python.framework/Versions/3.12/bin/encodec", line 8, in <module> sys.exit(main()) ^^^^^^ File "/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/encodec/__main__.py", line 109, in main wav, sr = torchaudio.load(args.input) ^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/torchaudio/_backend/utils.py", line 204, in load backend = dispatcher(uri, format, backend) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/torchaudio/_backend/utils.py", line 116, in dispatcher raise RuntimeError(f"Couldn't find appropriate backend to handle uri {uri} and format {format}.") RuntimeError: Couldn't find appropriate backend to handle uri input.wav and format None. ```

It's curious that FLAC can losslessly compress any low res PCM like 8 bit 11025Hz for example.

I come across some WAV files that FLAC couldn't compress, then I discovered those are Microsoft ADPCM 😄

> required python 3.8

i've just fallen in love with midi files again

they're just so well compressed

entire song in 78kb (excluding soundfont)

an entire song that is xz compressable into 4.5KiB

194.3 bits per second

No wonder games were using midi based soundtracks. You could fit lots of music on floppies. Also music playback was completely hardware accelerated.

A few hours ago I was playing Space Cadet pinball with a friend, noticed the MIDI file so opened it in VLC, turns out it's 9 minutes long in 110 KB... Unfortunately it doesn't play any audio because VLC is missing a soundfont

In Windows, you can use Windows Media Player. Windows has a basic soundfont builtin.

Or any player that can play though a midi device.

FooBar2000 with proper plugin does great job

Webpages used to be able to play background midi music using <bgsound> element.

I had to manually re-install it, since apparently it was disabled on this install by default, but it does work. Interestingly, my friend and I noticed my MIDI playback is very out of tune compared to others when playing OpenTTD, sounding more like a drunken band than background music

Interesting. Perhaps some software re-enabled it for me.

But yeah, the Microsoft midi synth is not the best. There are better options if you want to experiment.

this is a good option: https://coolsoft.altervista.org/en/virtualmidisynth https://coolsoft.altervista.org/en/midimapper

For music from DOS games, the most fitting option would be OPL2 emulation as that's the way the music was supposed to sound.

Im not sure compressed is the right word [av1_dogelol](https://cdn.discordapp.com/emojis/867794291652558888.webp?size=48&quality=lossless&name=av1_dogelol)

I guess they’re more like SVGs

Fundamentally different, defining the data through instructions rather than the final output

I would say midi file is more like macro recording.

I need to download some soundfonts again

soundfont isn't equivalent to MIDI, just saying

MIDI files are kinda like executables, targeting different equipments or standards with different sets of instructions

Another interesting format is tracker/module music. It¨s similar idea like midi but it also includes the "sound font"

depends some trackers are PCM-based, thus using the samples some utilize the OPL FM chips (2/3/4), so they get FM params instead

I would consider OPL tracks to be a separate category.

Music modules are PCM based , they evolved from Amiga MOD format.

I used to make tracks

I uploaded some of them here: https://modarchive.org/index.php?request=view_artist_modules&query=92535

It's mostly garbage but I had fun making those. 20-30 years ago now, wow time flies...

I know, I was just saying that if you include a sound font with the midi then it is way bigger

Even module tracks using low fidelity samples can take advantage of current technology. Rendering tracks in 48+ KHz, 24 bits allows higher playback quality. You can still hear the crunchy samples but the player won't add any more distortion.

just seeing if anyone recognize this

Flipper Zero MIDI?

wrong

Some electric keyboard

also wrong

related

IDK a hardware JPEG XL encoding ASIC

MIDI related

Some kind of synth?

mmhmm, you're heading towards the correct direction

DAW?

nope

either has no relation to audio plugins

One of those hardware midi synthesisers

correct

this should be among one of the most well-known ones

I just use fluidsynth lol

FluidSynth lacks a lot of features hardware synths have to offer, of most considering bread-and-butter

Roland SC-8850 (emulated screen)

Yamaha MU128/1000/2000 (emulated screen)

Roland SC-88/88 Pro (emulated screen)

Any other good CLI midi synths that run on MacOS?

TiMidity++ with a proper voice bank, should get you some level of proper MIDI support near SC-55 or MU50

Voice bank?

or Nuked SC-55 with SC-55 ROMs, almost perfectly emulating SC-55

voice banks defined via text configurations, or soundfont(SF2) files

Oh, sounfonts

not exactly the same

Soundfonts are a subclass of voice banks?

yup

But so are PSGs and FM synths?

Text configurations like SFZs?

you can say that, since there are a lot of synthesis methods.... sampling (PCM), FM, digital waveguide, analog (or virtual analog), moorer...

sound banks are just collections of definitions of instruments

https://github.com/nukeykt/Nuked-SC55

how do i pass a .sf2 file into timidity?

do i have to convert it to a patch directory?

specify the `soundfont` directive in its config file e.g. `soundfont '/home/user/test.sf2'`

also i don't quite get how drums work in MIDI?

like normal instruments have a bank and program

is there a seperate bank:program for drums?

depends on implementation

one program I use treats drums as 'bank 128'

GM only allows you to have a single drum kit on channel 10, and that channel cannot be anything else

GM2 sets drums via cc0 120

XG cc0 127/126, and part setup SysEx exists

GS only allows SysEx

then select the drum kit via PC

in timidity++ logs it gives lines such as ``` Drumset 0 73(C#): Drum_000/073_Guiro_1_Short.pat ``` Does the `0` mean bank 0 or program 0?

e.g.

program (0-indexed) set to 0

and does timidity++ just not have the concept of drumkit banks?

I think it does, it supports XG/GS/GM2 drum kit selection after all

huh, so why is it only giving 2 numbers (program, key) instaed of 3 (bank, program, key)?

this is weird

what are each of the columns?

with standardized implementations, drums have their "bank" already set to "drums"

from the XG bank map file MSB (cc0), PRG (pc), LSB (cc32), NME (name or ID), ELC (element count), LVL (support level)

So drums are kind of their own special bank? That’s probably why that other program I was talking about treated drums as “128”

yup

I guess bit 7 is saying whether it’s a drum

standard MIDI 1.0 doesn't permit values exceeding 127 though

internal-use extension perhaps

Yeah, probably internal implementation details

Why 3 bytes for programs? Do they really need 2^21 different instruments?

extensibility XG and GM2 use cc0 to set category (XG melodic, MU exclusive, SFX drum kits, normal drum kits), and cc32 to set variations GS uses cc32 to select support level, and cc0 to set variations

e.g. in XG: cc0=0 (XG melodic), pc=0 (acoustic grand piano), cc32=66 → Double Concert Grand Piano

Basically the 15 competing formats xkcd?

XD yup

though only a few popped out

... well, a few dozen

So are the “banks” from gm2 actually variations?

Argh…

I’m sticking to GM1 until I understand this mess

Also what standard do SMF (.MID) files use by default?

cc32 selects variations, cc0 selects type

So from most to least significant, it’s “type.program,variation”?

most just assume GM1 if a MIDI file uses any from most of the standards listed above, they will contain SysEx strings (if not for god's sake, you must infer from cc0 and cc32 messages...)

yes, most standards model like this

So for just listening to MIDI files, I can ignore most of this conversation, and it will only come back to bite me if I start using MIDI for music composition with hardware and what-not

only if those MIDI files aren't conforming to a standard newer than GM1

an example in XG ~~any extension to GM will sound richer than GM due to having more features tbh~~

What program is that?

Octavia Cambiare

I’m gonna go memorise the entire midi spec with all the extensions now, cya and thanks for the discussion

XD yw

though keep yourself to GM2 at first before you begin to lose your mind

One last thing, what the heck is support level?

unrelated to GM1 and GM2, but some of the other standards have released multiple revisions, so some instruments may not be available if you're below a certain support level/revision

enormous rabbit hole

Too late….

I ain’t getting sleep tonight

needs more jpeg

Is that on someone’s actual website?

it’s in a PDF I found on libgen

but I have found a higher-quality version

I can at least read the text now

well, not in that discord preview

Bro don’t use JPG for a pdf lol

this could be a vector drawing, for sure

It could just be test on a PNG background (Probably, I've not actually made a PDF since 2016)

Unfortunately, most people simply believe that jpeg is always smaller than PNG. So when it comes to compressing PDFs, I've seen a lot of textbooks with 4:2:0 jpegs at quality 30-50. Text is barely legible. 😔

I would use pngquant+oxipng to keep *text* in *text*books readable. Then take all the photographic images and compress them properly with jpegli.

I mean it would be best to keep icons/graphs/text in its original vector format, but people seem to be allergic to best practices and do dumb things like rasterize SVGs for no reason.

Again, couldn't you just use text itself instead of embedding the text into an image? Or have I been misunderstanding PDF all my life

That's up to the publishers to distribute a good quality PDF

It's honestly a coin flip depending on the source. I've seen both kinds when obtaining college textbooks online.

to be clear, the image above was just the cover page

the rest of the book is proper text

good

https://pt.thishorsie.rocks/w/uv6TXopveRk8mmq3TxPDk3 the MIDI rabbit hole, no plugins involved

Recent tutorials on YouTube do tell that PNG is more efficient for shapes and texts

the world is healing 🥲

Maybe JXL should have a feature where it detects these kind of images and automatically switches to lossless

like if it detects a lot of flat colours and be like "hmm, this seems like something Modular would want"

One complication is that in the libjxl API the choice between XYB and no-XYB is made in advance and by the application, so it's not something that can be decided when the actual image data is available to the encoder.

(and if you're going to do lossless, you should stay in RGB, going to XYB will compress worse, unless you quantize the XYB more than what is needed to avoid losing information)

It's amusing to see jpeg used for flat colored manufacturer logo on the BIOS boot screen. The jpeg artifacts are amplified by the crappy washed-out laptop screen.

Is RGB<->XYZ not reversible ?

JPEG for logos... wow...

Another manufacturer used jpeg for all graphics in the BIOS Setup. They used very low quality because jpeg is too inefficient for those sharp shapes. The're trying to do fancy graphics but the result looks all ugly and lame.

Someone inform them of the existence of PNG

For compariso. This is what manufacturers were able to pull off in early 90s. https://i0.wp.com/socket3.wordpress.com/wp-content/uploads/2018/06/486pcbuild-21.jpg

It uses just standard VGA text mode with custom fonts.

The famous Energy Star logo present on every POST screen was also made of text characters using a special font.

Considering there was not much space to do eye candy as the entire BIOS had to fit inside EPROM and larger EPROM would be more expensive..

One day, my beloved https://github.com/libjxl/libjxl/pull/1395

The ability for all these different approaches to image processing is one of my favourite parts of this format

RGB to XYB is reversible in the mathematical sense, but when working with finite precision numbers it isn't (or rather, you'll need quite a lot of extra bits to make it reversible). Currently when we have to convert RGB to integer XYB (like in lossy modular), we are roughly adding 4 bits of precision or so, so 8-bit RGB becomes 12-bit XYB. That's not enough to make it exactly reversible, but good enough to be close enough (i.e. maybe you'll get an off-by-one here and there in the blue channel but you won't see that). But doing lossless compression on that 12-bit XYB data is going to be less effective than doing it on the original 8-bit RGB data...

it's a nonlinear transform so you'd need to have to have difference in precision yea

even linear transforms like YCbCr will require some extra precision if you want to make it reversible... but yes, a nonlinear transform like XYB even more so

Why would a library user know or care about whether to use xyb?

Typically the only parameter most users care about is quality-factor

All other parameters should be optional...

I know right? Just give the library an RGB pixel array and let the library decide which color encoding is the most appropriate.

Yes, that's kind of how it works: if you set it to lossless it will use RGB, if you set it to lossy it will use XYB. The thing is, if you set it to lossy but then you want to have an encoder that still tries lossless too in some cases, it's a bit hard to do with the current API...

Add a check before the conversion?

Like just a quick heuristic

currently the library exposes xyb as an option, which defaults to true, and the function SetLossless or whatever it's called just sets distance to 0 and xyb to false

the library still respects whatever that option is set to, which makes it hard to choose internally based on the current API

I mean, neither of these really address why we should *need* encryption. Yes https is nice, but a lot of services just don't need it

does setting it to modular also switch it to RGB?

No, just setting libjxl to modular will still do xyb and lossy modular (distance 1 is default)

is there a way to set modular lossy JXL to use RGB?

Yes.

https://www.cnn.com/2024/08/05/business/google-loses-antitrust-lawsuit-doj/index.html

time to push stract

ive read this and quite frankly it's kinda stupid > Do you really want someone injecting scripts, images, or ad content onto your page so that it looks like you put them there? I really couldn't care. if im running a gallery it's not something I need to worry about. sure they can, in fact one of the examples given as to why this is bad, is actually extremely nifty https://twitter.com/konklone/status/598696478018666496 This is dope, I find this really neat and cool > Or changing the words on your page? Or using your site to attack other sites? a minor nuisance, but again, not something I care about. Tech news source like phoronix (not counting the forums) probably doesn't need to care either.

any site that has a user logging in should have https for sure

https://www.techspot.com/news/104150-mozilla-doomed-suffer-worst-consequences-google-antitrust-defeat.html

> The recent ruling could be an existential threat to the future of Firefox

F to firefox. Btw, millions to management always wondered me, knowing the fact that market share of ff is constantly decreasing, i.e. profit of the management's work is below zero

Yeah I'm not shedding tears despite being a firefox user They've spent so much money on anything but the browser. Maybe it'll jostle their noggin a bit to have their free money taken away

Probably the same, despite I'm also a ff user, and really don't want to switch to chrome. Unfortunately, as far as I know - there are only two really existing options now - ff or chrome

I'm spiteful enough of Google that I would just use obscure forks of FF until the end of time

Obscure forks would eventually stop working due to Gecko becoming outdated. Just look at Pale Moon, the "hard fork" of Firefox: most of the sites are broken on it, despite numerous claims otherwise.

The best FFmpeg downscale algorithm for 1280x720 to 640x360. The number represents the sum of the differences of all pixel values from the original (RGB); the lower the better. 08442031 lanczos+full_chroma_inp 08461621 spline+full_chroma_inp 08470785 lanczos 08487217 spline 08511933 sinc+full_chroma_inp 08565336 sinc 08612397 area 08612789 area+full_chroma_inp 08638503 bicubic+full_chroma_inp 08652976 bicubic 08705959 bicublin 08773004 bicublin+full_chroma_inp 09151218 experimental 09153765 experimental+full_chroma_inp 09772859 bilinear 09775935 bilinear+full_chroma_inp 10212001 gauss 10219327 gauss+full_chroma_inp 12354815 neighbor+full_chroma_inp 12466807 neighbor 16996154 fast_bilinear 17832417 fast_bilinear+full_chroma_inp -vf "scale=640:360:flags=algorithm"

Full table N NEAREST B BILINEAR C BICUBIC L LANCZOS ```AVG:09452026 N:10748670 B:09843899 C:08773504 L:08442031 lanczos+full_chroma_inp AVG:09468144 N:10754896 B:09856028 C:08790869 L:08470785 lanczos AVG:09482502 N:10289810 B:10146695 C:08881106 L:08612397 area AVG:09482646 N:10289602 B:10146881 C:08881314 L:08612789 area+full_chroma_inp AVG:09496395 N:10716450 B:09968064 C:08839445 L:08461621 spline+full_chroma_inp AVG:09509650 N:10721820 B:09976679 C:08852886 L:08487217 spline AVG:09607608 N:10609278 B:10161443 C:09021207 L:08638503 bicubic+full_chroma_inp AVG:09613144 N:10612152 B:10162626 C:09024822 L:08652976 bicubic AVG:09635710 N:11516734 B:09671785 C:08842389 L:08511933 sinc+full_chroma_inp AVG:09658276 N:10647750 B:10203251 C:09076142 L:08705959 bicublin AVG:09668686 N:11531968 B:09698361 C:08879077 L:08565336 sinc AVG:09718642 N:10710082 B:10249368 C:09142116 L:08773004 bicublin+full_chroma_inp AVG:10070181 N:10654192 B:10889493 C:09585820 L:09151218 experimental AVG:10076325 N:10654114 B:10900765 C:09596655 L:09153765 experimental+full_chroma_inp AVG:10665029 N:11187614 B:11463640 C:10236003 L:09772859 bilinear AVG:10672849 N:11186366 B:11479508 C:10249586 L:09775935 bilinear+full_chroma_inp AVG:11053472 N:11503602 B:11841380 C:10656907 L:10212001 gauss AVG:11063524 N:11501186 B:11860598 C:10672984 L:10219327 gauss+full_chroma_inp AVG:12099168 N:12417598 B:11829445 C:11794812 L:12354815 neighbor+full_chroma_inp AVG:12342056 N:13042750 B:11930222 C:11928443 L:12466807 neighbor AVG:16968126 N:17991926 B:16171039 C:16713385 L:16996154 fast_bilinear AVG:17772968 N:18853222 B:16881623 C:17524611 L:17832417 fast_bilinear+full_chroma_inp ```

1280x720 --> 640x360 --> 1280x720 --> diff

What is the "original" in the context of downscaling?

img

I mean, I understand how upscaling can have an "original" (compare upscaled downscaled pic to original), but I dunno how downscaling can have an "original".

I want to note that the AREA algorithm shows itself better than all other algorithms in terms of the actual preservation of information, which can be seen when comparing NEAREST

how do I compare a 1280 image with a 640 image?

the most understandable way is to make the same number of pixels as in the original, that is, 1280. that is, to increase their number, and make a comparison with all of them. This is identical to the magnification of the image by NEAREST

Preserving borders would lower the score instead of increasing, wouldn't it?

but I also did a test with more scale algorithms, because very rarely do we watch a 640x360 image on a 640x360 monitor. It is always being scaled. and then I noticed that the excessive sharpness of LANCZOS when the image is downscale is compensated when it is upscale.

<:Stonks:806137886726553651>

Like brush strokes must be thicker on lower resolution to be legible, but it would count against this kind of score

I didn't understand what problem you mean.

I mean for example you have 1 pixel black dot in an image, and you downscale it. If it becomes light-gray 1px dot it would be visually worse, but it would have higher score.

Same for 1px wide lines

The best FFmpeg downscale algorithm for 1280x720 to 640x360 for mathematically ideal viewing. That is, when 1 pixel of the image is displayed on 1 pixel of the monitor. 10289602 area+full_chroma_inp 10289810 area 10609278 bicubic+full_chroma_inp 10612152 bicubic 10647750 bicublin 10654114 experimental+full_chroma_inp 10654192 experimental 10710082 bicublin+full_chroma_inp 10716450 spline+full_chroma_inp 10721820 spline 10748670 lanczos+full_chroma_inp 10754896 lanczos 11186366 bilinear+full_chroma_inp 11187614 bilinear 11501186 gauss+full_chroma_inp 11503602 gauss 11516734 sinc+full_chroma_inp 11531968 sinc 12417598 neighbor+full_chroma_inp 13042750 neighbor 17991926 fast_bilinear 18853222 fast_bilinear+full_chroma_inp

I still don't understand the problem. I'm calculating the absolute pixel difference. If there were 2 pixels white and black, and they merged into gray, then the difference would be 128 (and 128)

I just wondered why AREA is the best function mathematically, in terms of the number of diff pixel matches, but lanczos is better because the image we will be looking at will be scaled to the size of the monitor...

I can't remember if I posted it here, probably did but either way, I decided to use lanczos to downsize some textures from 4K to 2K for Unity, and the difference was very surprising compared to Unity's default bilinear. Makes me wonder why it's the default considering it's a "Write once, ready many times" use case

I wrote AVG a bit stupidly as a basis. I changed the list to Considering that the image will still be scaled (for example, up to the resolution of the monitor)

I'm assuming not all of those were done in ffmpeg? Since I've never seen mention of full_chroma_inp or area

well

Yes, actually it's some bullshit, I had to go into the source code to find it all.

"bitexact" and "accurate_rnd" have absolutely no effect on anything, identical output

although it can be found by name in the search Like "lanczos+accurate_rnd"

area is an ultra specific scaling, it scales pixel graphics without blurring

<:PepeOK:805388754545934396> It's a pity that zero people know about it, it's in OBS. It would be nice if everyone who streams pixel games found out about it

area bicubic

I assume the full_chroma_inp is disabled by default due to 4:2:0 on most video and jpeg inputs, surprising they don't do a basic check to do it automatically though

Well, this is strange, because I do RGB 24 PNG for input and output

Yeah, that sounds right based on what I said. They assume 4:2:0 subsampling unless told otherwise, so for PNG it works best enabled

0,003% better

I think it doesn't make sense, ever.

"placebo better"

You don't understand how much I hate Google I had a dumbphone for 2 years just because I didn't want an Android phone lol

Yeah, just sticking to Lanczos now that I'm used to it is probably best. It's already a huge improvement over the (unfortunate) default bilinear in most applications

I tried yuv420 for input and RGB24 for output, and when using full_chroma_inp, the quality is still better, by the hundredth percent. But in absolute terms it is definitely better.

I'm not at all sure, but it's possible that more rounded values are used for the Color pixel scaling. This is the only way to explain that there is a difference in any image for the better, so perhaps when down to 640x360 I will use full_chroma_inp

Thinking about the algorithms, I accidentally created the best one, which, according to my tests, is much better than all the others, but only when viewing 1 pixel to 1 pixel ```AVG:09468144 N:10754896 B:09856028 C:08790869 L:08470785 lanczos AVG:09482502 N:10289810 B:10146695 C:08881106 L:08612397 area AVG:09509650 N:10721820 B:09976679 C:08852886 L:08487217 spline AVG:09613144 N:10612152 B:10162626 C:09024822 L:08652976 bicubic AVG:09658276 N:10647750 B:10203251 C:09076142 L:08705959 bicublin AVG:09668686 N:11531968 B:09698361 C:08879077 L:08565336 sinc AVG:09770199 N:10330400 B:10113765 C:09318488 L:09318142 selected neighbor by lanczos -> AVG:09924636 N:10136404 B:10410203 C:09555748 L:09596187 selected neighbor AVG:10070181 N:10654192 B:10889493 C:09585820 L:09151218 experimental AVG:10665029 N:11187614 B:11463640 C:10236003 L:09772859 bilinear AVG:11053472 N:11503602 B:11841380 C:10656907 L:10212001 gauss AVG:12342056 N:13042750 B:11930222 C:11928443 L:12466807 neighbor```

instead of Adding the sum of pixels, the original pixel is selected, which is most similar in color to the sum of pixels