jpeg2png

There's a series of videos showing the algorithm: https://www.youtube.com/watch?v=LFXN9PiOGtY I finally understood DCT after watching https://www.youtube.com/watch?v=Q2aEzeMDHMA And someone created a "JPEG to PNG" tool that "finds the smoothest possible picture that encodes to the given JPEG file": https://github.com/victorvde/jpeg2png . I tried it with some very terribly compressed images, and the outputs were a lot better.

The default implementation of the decoding adds the artifacts. This tool uses more clever math to replace what's missing: https://github.com/victorvde/jpeg2png

This tool optimises blocky JPEGs for a better viewing pleasure: https://github.com/victorvde/jpeg2png > jpeg2png finds the smoothest possible picture that encodes to the given JPEG file.

By the way, you can decode JPEG with less artifacts using these projects: https://github.com/ilyakurdyukov/jpeg-quantsmooth (good for most mid-quality and high-quality images) https://github.com/victorvde/jpeg2png (use for very low-quality images, slower) jpeg-quantsmooth gives a sharper output (use "-q6" option). jpeg2png output is a little blurry, but it does a better job of unblocking very low-quality images.

To be fair, decent JPEG deblocking should have been a solved problem already and included in decoders, see for example: https://github.com/victorvde/jpeg2png

Is https://github.com/victorvde/jpeg2png analogous to a deblocking filter for jpeg? >JPEG encoding loses information. But it is JPEG decoding that introduces artifacts by filling the missing information with noise. >jpeg2png is smarter and fills the missing information to create the smoothest possible picture.

See also https://github.com/victorvde/jpeg2png , which tries to maximize smoothness everywhere instead of just at block boundaries.

Let me share my experience with chroma upsampling and smooth jpeg decoding. At first, I optimized each channel, then upsampled the chroma channels using replication. This works terribly as you can see in the article. So then I changed to linear interpolation. Briefly: +---+---+ a x b y c +---+---+ We know the values in a and c but not b. The distance from x to a is half a pixel and the distance from x to c is one and a half pixel. Then linear interpolation gives x = a + (c - a) * (1/2 - 0) / (2 - 0) = 3/4 a + 1/4 c. This worked decently, but it still showed fringes around sharper edges. I considered using more complicated upsampling methods like Lanczos or Mitchell, but instead went with optimizing a full size image with constraints on the downsampled image. By avoiding upsampling I got my optimized high resolution image for

I was working in YCbCr and I found it noticable. Compare the bottom-right tile in https://github.com/victorvde/jpeg2png/commit/64bf10789092ccf... with swipe. It's worst with green around the top of the left black line, but there's green and red fringing everywhere. And this is a normal use case.

In my experience[1] code is available maybe half of the time, if you really search for it: checking the academic and personal pages of every author, and scouring the code of every framework mentioned. You're lucky when the code is in C or C++ using a framework nobody uses (e.g. MegaWave), but half of the time the code is in MATLAB. All uncommented, using single character variables and under some restrictive or just weird license. And then it only works on grayscale images. Maybe because it's easier to get funding for medical images. Just applying the algorithm to each color channel separately leads to color fringing when they get out of sync. Finally, usability, distribution, and performance are afterthoughts. I don't disagree but it makes a huge difference. [1] https://github.com/victorvde/jpeg2png