xBR algorithm tutorial

[Hyllian]

Well, I’ve got a different result:

shaders = "14"
shader0 = "shaders_slang/nnedi3/shaders/nnedi3-nns64-win8x4-pass1-rgb.slang"
filter_linear0 = "false"
wrap_mode0 = "clamp_to_border"
mipmap_input0 = "false"
alias0 = ""
float_framebuffer0 = "false"
srgb_framebuffer0 = "false"
scale_type_x0 = "source"
scale_x0 = "1.000000"
scale_type_y0 = "source"
scale_y0 = "2.000000"
shader1 = "shaders_slang/nnedi3/shaders/nnedi3-nns64-win8x4-pass2-rgb.slang"
filter_linear1 = "false"
wrap_mode1 = "clamp_to_border"
mipmap_input1 = "false"
alias1 = ""
float_framebuffer1 = "false"
srgb_framebuffer1 = "false"
scale_type_x1 = "source"
scale_x1 = "2.000000"
scale_type_y1 = "source"
scale_y1 = "1.000000"
shader2 = "shaders_slang/omniscale/shaders/omniscale.slang"
filter_linear2 = "false"
wrap_mode2 = "clamp_to_border"
mipmap_input2 = "false"
alias2 = ""
float_framebuffer2 = "false"
srgb_framebuffer2 = "false"
scale_type_x2 = "source"
scale_x2 = "1.000000"
scale_type_y2 = "source"
scale_y2 = "1.000000"
shader3 = "shaders_slang/nnedi3/shaders/nnedi3-nns32-win8x4-pass1-rgb.slang"
filter_linear3 = "false"
wrap_mode3 = "clamp_to_border"
mipmap_input3 = "false"
alias3 = ""
float_framebuffer3 = "false"
srgb_framebuffer3 = "false"
scale_type_x3 = "source"
scale_x3 = "1.000000"
scale_type_y3 = "source"
scale_y3 = "2.000000"
shader4 = "shaders_slang/nnedi3/shaders/nnedi3-nns32-win8x4-pass2-rgb.slang"
filter_linear4 = "false"
wrap_mode4 = "clamp_to_border"
mipmap_input4 = "false"
alias4 = ""
float_framebuffer4 = "false"
srgb_framebuffer4 = "false"
scale_type_x4 = "source"
scale_x4 = "2.000000"
scale_type_y4 = "source"
scale_y4 = "1.000000"
shader5 = "shaders_slang/xsoft/shaders/4xsoft.slang"
filter_linear5 = "false"
wrap_mode5 = "clamp_to_border"
mipmap_input5 = "false"
alias5 = ""
float_framebuffer5 = "false"
srgb_framebuffer5 = "false"
scale_type_x5 = "source"
scale_x5 = "2.000000"
scale_type_y5 = "source"
scale_y5 = "2.000000"
shader6 = "shaders_slang/windowed/shaders/jinc2.slang"
filter_linear6 = "false"
wrap_mode6 = "clamp_to_border"
mipmap_input6 = "false"
alias6 = ""
float_framebuffer6 = "false"
srgb_framebuffer6 = "false"
shader7 = "shaders_slang/sharpen/shaders/fast-sharpen.slang"
wrap_mode7 = "clamp_to_border"
mipmap_input7 = "false"
alias7 = ""
float_framebuffer7 = "false"
srgb_framebuffer7 = "false"
shader8 = "shaders_slang/sharpen/shaders/fast-sharpen.slang"
wrap_mode8 = "clamp_to_border"
mipmap_input8 = "false"
alias8 = ""
float_framebuffer8 = "false"
srgb_framebuffer8 = "false"
shader9 = "shaders_slang/sharpen/shaders/adaptive-sharpen.slang"
wrap_mode9 = "clamp_to_border"
mipmap_input9 = "false"
alias9 = ""
float_framebuffer9 = "false"
srgb_framebuffer9 = "false"
scale_type_x9 = "source"
scale_x9 = "1.000000"
scale_type_y9 = "source"
scale_y9 = "1.000000"
shader10 = "shaders_slang/deblur/shaders/deblur.slang"
wrap_mode10 = "clamp_to_border"
mipmap_input10 = "false"
alias10 = ""
float_framebuffer10 = "false"
srgb_framebuffer10 = "false"
scale_type_x10 = "source"
scale_x10 = "2.000000"
scale_type_y10 = "source"
scale_y10 = "2.000000"
shader11 = "shaders_slang/warp/shaders/smart-morph.slang"
wrap_mode11 = "clamp_to_border"
mipmap_input11 = "false"
alias11 = ""
float_framebuffer11 = "false"
srgb_framebuffer11 = "false"
shader12 = "shaders_slang/blurs/sharpsmoother.slang"
wrap_mode12 = "clamp_to_border"
mipmap_input12 = "false"
alias12 = ""
float_framebuffer12 = "false"
srgb_framebuffer12 = "false"
shader13 = "shaders_slang/cubic/shaders/bicubic.slang"
filter_linear13 = "false"
wrap_mode13 = "clamp_to_border"
mipmap_input13 = "false"
alias13 = ""
float_framebuffer13 = "false"
srgb_framebuffer13 = "false"
scale_type_x13 = "source"
scale_x13 = "0.250000"
scale_type_y13 = "source"
scale_y13 = "0.250000"
parameters = "RESOLUTION_X;RESOLUTION_Y;CONTRAST;JINC2_WINDOW_SINC;JINC2_SINC;JINC2_AR_STRENGTH;SHARPEN;CONTR;DETAILS;CURVE_HEIGHT;OFFSET;DEBLUR;SMART;SM_MODE;SM_PWR;SM_STRMIN;SM_STRMAX;SM_CUTLO;SM_CUTHI;SM_DEBUG;max_w;min_w;smoot;lumad;mtric;B;C"
RESOLUTION_X = "0.000000"
RESOLUTION_Y = "0.000000"
CONTRAST = "3.000000"
JINC2_WINDOW_SINC = "0.440000"
JINC2_SINC = "0.820000"
JINC2_AR_STRENGTH = "0.500000"
SHARPEN = "2.000000"
CONTR = "0.070000"
DETAILS = "1.000000"
CURVE_HEIGHT = "2.000000"
OFFSET = "2.000000"
DEBLUR = "7.000000"
SMART = "1.000000"
SM_MODE = "1.000000"
SM_PWR = "0.900000"
SM_STRMIN = "0.000000"
SM_STRMAX = "1.000000"
SM_CUTLO = "0.000000"
SM_CUTHI = "1.000000"
SM_DEBUG = "0.000000"
max_w = "0.000000"
min_w = "-0.150000"
smoot = "0.000000"
lumad = "0.100000"
mtric = "0.700000"
B = "1.000000"
C = "0.000000"

[saeedalshaikhpygas]

Yeah that’s because I have used 0.140000 instead of 0.250000 for the scale_x13 value

The idea that I have is to keep the color graduating (which the shader does well) intact and have tiny pixels for the edges giving it a crisp look . Something a bit like this

As I mentioned like having Hi-res pixel art

Unfortunately , lowering scale_x13 value will only give jaggies

[Hyllian]

That’s not easy, because you’d have to determine exactly the edges that should be sharpened and the edges that should keep untouched. Deblur shader does something like that, or at least try. You should use deblur as last shader and tweak its params to see if you get something good.

[Syh]

As someone that does pixel art, that isn’t hi-res pixel art.

[saeedalshaikhpygas]

you’re right about the “determine the edges” part , the whole idea seems kinda impossible now this was the attempt

[saeedalshaikhpygas]

well potato potatoes it would be classified 720P

[Hyllian]

Some characteristic of scalers are that they leave some blur at the output image. It’s basically unavoidable when you need to scale by 4x or more, because you need to fill 16 pixels for each input pixel. Some scalers like pure xbr can scale without introducing blur, though they can’t resolve low contrast color transition very well (basically, games with seamless color transitions like DKC or MK).

So, to use a general purpose scaler (the ones that resolve low contrast color transitions well), it’s recommended to use some sharpening shader as a final touch to get rid of the blur byproduct of scaling.

I’ve been testing many sharpening filters available out there (adaptive sharpen, anime4k, finesharp, etc). Though they bring good results, the one that really shines is deblur (by @guest). It just works perfectly by removing blur without introducing collateral effects (like ringing).

On super-xbr, deblur combined with smartsmooth (another great shader by @guest), it gets some impressive results I didn’t see before. Smartsmooth is good to thin dark lines. As low res cartoon games use black outlines for objects, if you scale by 4x, the black lines become too thick, so it’s necessary to thin those lines for a better ballanced image output. That’s where smartsmooth enter.

Here’s a combination of super-xbr + smartsmooth + deblur:

Preset:

shaders = "8"
shader0 = "shaders_slang/xbr/shaders/super-xbr/super-xbr-pass0.slang"
filter_linear0 = "false"
wrap_mode0 = "clamp_to_border"
mipmap_input0 = "false"
alias0 = ""
float_framebuffer0 = "false"
srgb_framebuffer0 = "false"
scale_type_x0 = "source"
scale_x0 = "1.000000"
scale_type_y0 = "source"
scale_y0 = "1.000000"
shader1 = "shaders_slang/xbr/shaders/super-xbr/super-xbr-pass1.slang"
filter_linear1 = "false"
wrap_mode1 = "clamp_to_border"
mipmap_input1 = "false"
alias1 = ""
float_framebuffer1 = "false"
srgb_framebuffer1 = "false"
scale_type_x1 = "source"
scale_x1 = "2.000000"
scale_type_y1 = "source"
scale_y1 = "2.000000"
shader2 = "shaders_slang/xbr/shaders/super-xbr/super-xbr-pass2.slang"
filter_linear2 = "false"
wrap_mode2 = "clamp_to_border"
mipmap_input2 = "false"
alias2 = "PassPrev2"
float_framebuffer2 = "false"
srgb_framebuffer2 = "false"
scale_type_x2 = "source"
scale_x2 = "1.000000"
scale_type_y2 = "source"
scale_y2 = "1.000000"
shader3 = "shaders_slang/xbr/shaders/super-xbr/super-xbr-pass0.slang"
filter_linear3 = "false"
wrap_mode3 = "clamp_to_border"
mipmap_input3 = "false"
alias3 = ""
float_framebuffer3 = "false"
srgb_framebuffer3 = "false"
scale_type_x3 = "source"
scale_x3 = "1.000000"
scale_type_y3 = "source"
scale_y3 = "1.000000"
shader4 = "shaders_slang/xbr/shaders/super-xbr/super-xbr-pass1b.slang"
filter_linear4 = "false"
wrap_mode4 = "clamp_to_border"
mipmap_input4 = "false"
alias4 = ""
float_framebuffer4 = "false"
srgb_framebuffer4 = "false"
scale_type_x4 = "source"
scale_x4 = "2.000000"
scale_type_y4 = "source"
scale_y4 = "2.000000"
shader5 = "shaders_slang/xbr/shaders/super-xbr/super-xbr-pass2.slang"
filter_linear5 = "false"
wrap_mode5 = "clamp_to_border"
mipmap_input5 = "false"
alias5 = ""
float_framebuffer5 = "false"
srgb_framebuffer5 = "false"
scale_type_x5 = "source"
scale_x5 = "1.000000"
scale_type_y5 = "source"
scale_y5 = "1.000000"
shader6 = "shaders_slang/warp/shaders/smart-morph.slang"
filter_linear6 = "false"
wrap_mode6 = "clamp_to_border"
mipmap_input6 = "false"
alias6 = ""
float_framebuffer6 = "false"
srgb_framebuffer6 = "false"
scale_type_x6 = "source"
scale_x6 = "1.000000"
scale_type_y6 = "source"
scale_y6 = "1.000000"
shader7 = "shaders_slang/deblur/shaders/deblur.slang"
filter_linear7 = "true"
wrap_mode7 = "clamp_to_border"
mipmap_input7 = "false"
alias7 = ""
float_framebuffer7 = "false"
srgb_framebuffer7 = "false"
parameters = "XBR_EDGE_STR;XBR_WEIGHT;XBR_ANTI_RINGING;MODE;XBR_EDGE_SHP;XBR_TEXTURE_SHP;SM_MODE;SM_PWR;SM_STRMIN;SM_STRMAX;SM_CUTLO;SM_CUTHI;SM_DEBUG;OFFSET;DEBLUR;SMART"
XBR_EDGE_STR = "2.000000"
XBR_WEIGHT = "1.000000"
XBR_ANTI_RINGING = "1.000000"
MODE = "2.000000"
XBR_EDGE_SHP = "0.400000"
XBR_TEXTURE_SHP = "1.000000"
SM_MODE = "0.000000"
SM_PWR = "0.500000"
SM_STRMIN = "0.000000"
SM_STRMAX = "1.000000"
SM_CUTLO = "0.000000"
SM_CUTHI = "1.000000"
SM_DEBUG = "0.000000"
OFFSET = "2.000000"
DEBLUR = "2.000000"
SMART = "0.500000"

[saeedalshaikhpygas]

Hey mate , I kinda hit into a wall .

[Album] imgur.com

First Image is done with ESRGAN , second is no shader and the third is this preset over here:

https://mega.nz/file/UcZG0LTS#esPVq1Jk0EGaDxE9nlc8mq3qPFSXurTlZHB75WIplx0

Now I understand that Esrgan results are down right impossible , but aside from the detail aspect , I was wondering if I could the same sort of crisp look as Scalefx . Thoughts ?

[Hyllian]

Use the new shaders/presets from @guest in this Thread post.

To achieve the desired sharpness/smoothness you have to use anti-aliasing shaders combined with deblur shader after the scaler.

The scaler is the shader that will increase/decrease resolution. It can be many: xbr, scalerfx, bicubic, jinc, super-xbr etc.

Anti-aliasing should be set at 1x and using linear sampling. Some of them: advanced-aa, fxaa, 4xsoft, etc. These shaders can work as scalers too though.

Deblur is a sharpen shader. It will increase gradient of edges minimizing introduction of ringing. It’s the best of its kind for pixel art images. It should be put before the last shader, working at 1x and using linear sampling.

If the scaler already output anti-aliased image you should skip the anti-aliasing step.

[saeedalshaikhpygas]

yeah , coincidentally I was just about test that .talk about timing

[garagecoder]

Hi @Hyllian,

Eight years ago, I implemented a version of xBR 2x as a g’mic filter (which is still functional to this day). It was a direct conversion of C# code from “ImageResizer”, but with no real understanding of how it worked. @Reptoria has recently made me think about updating this filter for the benefit of all g’mic users and to truly understand the method.

To that end, I have a couple questions:

1. Could you point me to a canonical/baseline implementation to work from? I became truly lost amongst the forest of shader code (there appear to be many versions). A direct link would be most appreciated!
2. Has the distance function since changed? In particular, the yuv conversion looks unusual. I’d be happy to discuss that if you wish.

I totally understand if you don’t have the time or will to respond, but thanks for the great algorithm anyway!

[Hyllian]

Hi.

The xBR C implementation is very old and very different from shaders.

The latest advance C implementation are those made by zenjhu in xBRZ. I think you can find C or C++ implementation of this using Google.

As for The most representative xbr shader, my vanilla shader is always the xbr-lv2.cg. Though it isn’t the most advanced.

The distance is different depending on The shader flavour. The accuracy one is the most advanced, though a bit slower.

[garagecoder]

Excellent thanks, in that case this seems like a good time to learn shader code! At first glance it doesn’t look too intimidating.

The curiosity I have about yuv is use of abs() on the (I assume “gamma” compressed for crt) rgb difference values before conversion, whereas that would normally be the final step only. That follows from: target space difference = Ma - Mb = M(a - b), where M is the colour space conversion matrix and a and b are rgb vectors to compare. But, this post being so very old now that could have no relevance.

Thanks again, I’ll try to keep further questions to a minimum!

[Hyllian]

There’s no gamma conversion on xBR. And I converter rgb to luma only. Y is just luminance. The diferences are just lum differencies, hence the abs function.

[garagecoder]

Agreed, it all looks fine to me in the shader version; abs only happens after luma conversion. This also looks more readable than the old C# version, which is a bonus.

[guest.r]

I’ll drop this here. The deblur shader i’ve been working out recently works very well with xbr-lvl3-noblend too. A modified version (included here) must be used, since the repo version does blending.

Edit: multipass version added:

https://mega.nz/file/QgYwBBKZ#0btmhv8QuJStpT9aJPsZg3rfeDWkb8WtSvgk1TwFzWQ

[Hyllian]

That’s a very good combination, @guest.r!

It reminds me I have to start working on a lvl6 noblend version. I’m just a bit lazy.

I’ll need to refactore all super-xbr shader presets. I’ll swap jinc by deblur as the final touch. I think it gives a better sharpness and doesn’t introduce ringing.

[HyperspaceMadness]

Hi @Hyllian I’m really enjoying all the use of the downscaled XBR in your shader and others, it looks really great .

I was wondering if you could explain what is the difference between the different XBRs, 2p, 3p, 6p, adaptive, lv3-multipass , mlv4-multipass, etc.

[Hyllian]

Lately I’m a bit busy with real life, but I’ll try to explain your question here. Sorry for my weird english, kkk:

2p, 3p are related to the numbers of passes. So, super-xbr-2p-xxx delivers sxbr filtering in only two passes. Though I can filter in only two passes, it can be improved with an aditional pass. So, usually, I upscale (with sxbr algorithm) at 2x scale in two or three passes. The 3p version is a bit better than 2p in IQ, though a bit slower. The 3p versions fix the half pixel offset result of the sxbr (in two passes) and smooths the overall image quality.

And, the 6p version is just sxbr-3p applied two times so that we can get a 4x scaling.

Now, about the LVL keyword I use (It’s used only for XBR, not super-xbr), it’s related to the kind of staircase that can be completely smoothned by the algorithm. So, for example, a XBR-LV1 can only smooths perfectly a staircase of 45 degree. If the staircase is 60 degree, for example, the result will be a softened staircase not entirely smoothened. For that I need a LVL2 version. The LVL2 takes care of staircases of 30, 45 and 60 degree staircases. And LVL3 takes care of even more kinds of staircases.

The most advanced XBR I could implement is the mlv4, which means multilevel4. While the others use a greedy implementation where they always try to smooth with the biggest LVL possible. This one use some euristics where it always decides the most appropriate LVL (among 1 to 4) for each staircase kind. It’s a bit complex so I had to implement it in four passes.

For future develpment, I think it’s possible to achieve LVL6 (like in ScaleFX), though I couldn’t find an easy way to make it, yet. Maybe someone else can continue from here (@guest.r ? ).

[HyperspaceMadness]

Thanks so much for the explanation! This helps me a bunch

Also, not to worry @Hyllian, your English is great!