720p or 1080i on Multiformat CRTs?

[Guspaz]

I can see this being true for Nearest Neighbor upscaling due to uneven pixel scaling. However, for Billinear Scaling the results are better the less upscaling there is to be done, and this is the type of scaling usually employed by TVs and consoles.

That's simply demonstrably wrong, the exact opposite is true.

Here is a 64x64 pixel grid. This and all the images were enlarged as a final step with 2x integer nearest neighbour to make it more visible.



Here is the same image, upscaled by just one *single* pixel, to 65x65:



Now here is the same image, bilinear scaled up to 120%, simulating a 600 to 720 scale:



And here is the same image, bilinear scaled up to 180%, simulating a 600 to 1080 scale:



This is a *massive* improvement in sharpness and detail preservation due to scaling farther in the first step. With bilinear, the less you scale, the worse your results.

And even then, minor scaling would be a worst-case scenario at best, most 360 games run at 1280x720, so no scaling would be happening.
https://forum.beyond3d.com/threads/list ... st-1114423

It's true, 68.6% of those games are 720p, and those would benefit from 720p output. The rest are not and would benefit from 1080i output. So I guess you should say that, for the 360, you should check the game resolution, and roughly a third of the time, you should set 1080i output.

[fernan1234]

Also known as "detail loss".

"Loss" of redundant edge pixels on "HD" 3D/video content for a less jagged, more natural picture? Sign me up.

[tongshadow]

Yes, softening is a neat trick only CRTs can do. It can look really good at times.

That's simply demonstrably wrong, the exact opposite is true.

Here is a 64x64 pixel grid. This and all the images were enlarged as a final step with 2x integer nearest neighbour to make it more visible.

I see, you were thinking of this grid pattern. This is a very extreme example, there are only 2 colors and very few pixels. This means the upscaling algorythm doesnt have enough information to properly interpolate into a proper grid, so you end up with those artifacted results on both methods (1.2x and 1.8x). This grid shows what would happen in detailed and contrasting elements, like a far away fence or meshes.

Take a native 720p picture, like a sprite game, and scale it by 1.2x and by 3.0x, and you'll notice how softer 3.0x is in comparison to 1.2x.

[orange808]

Assuming there's filtering to hide shimmering artifacts, textures will have more detail at 1080i. If you pulled up a checkerboard texture and scaled the texture down slowly, it should appear to become solid gray at 720p before it does at 1080i. As expected, the additional information in a 1080i signal would be able to resolve and display a recognizable checkerboard on a smaller texture (versus 720p).

That should hold true for most textures. Of course, I'm assuming the scaling is good.. It's possible the console smears and blurs everything and it won't matter.

[Guspaz]

No, the grid is just exposing what's happening. You have the same issue with sprites.

Here's Mario from Super Mario World, same this time except a 4x integer scale at the end since we're dealing with small sprites here.



Here's the minimum possible scale that affects both axes, one pixel horizontal, two vertical:



All fine detail is lost.

Now, here's the 120% versus 180% comparison:



Notice how in the 120%, the white highlight of his hat badge is gone, but is visible in the 180% version. Notice how one of his eyes in the 120% version has just a gray smudge, but his pupils are more distinct in the 180% version. Notice how the shape of the pixel boundaries is not visible in 120%, but is visible in 180%. Is the 180% softer? Maybe, but it's preserving more detail.

None of these are ideal. Upscaling images with most algorithms between 1.0 and 2.0 is going to suck. There are better ways to do it, though. Here, for example, is 180% bilinear sharp, which does a better job preserving both sharpness and detail:



But of course we can't use bilinear sharp with old consoles.

[kamiboy]

I know the PS3 at the very least has custom firmware development. I wonder if it is feasible for an option in the CFW to enable unscaled output from games. That would technically get you the best analogue image. The downsides are that native render resolution of some games could have the wrong aspect ratio, which scaling is supposed to correct for. In those cases adjustment of picture on the tube would have be made to compensate, if even possible. Also you prolly would get an overall smaller image. On the HDMI side the CFW could perhaps pass along information about the actual native resolution for something like the RT4K to use to do automatic largest integer scaling to 4K?

That would prolly result in the best, sharpest image quality out of the PS3. Of course, it is doubtful how useful this would be for 3D graphics...

[tongshadow]

No, the grid is just exposing what's happening. You have the same issue with sprites.

Here's Mario from Super Mario World, same this time except a 4x integer scale at the end since we're dealing with small sprites here.



Here's the minimum possible scale that affects both axes, one pixel horizontal, two vertical:

This is a very low resolution image, the results cant be comparable to higher resolutions because scaling works better at such resolutions.
And putting everything into the context of the original question, a CRT would be able to mask or hide uneven scaling artifacts, specially in 3D content.

Imo, 720p is the way to go. Better in motion and in some cases better performance than 1080i.

[Guspaz]

The resolution of the image is completely irrelevant, it makes zero difference. The only thing that matters for this sort of algorithm is the scaling factor. Unless you're talking about the perceptual difference in sharpness from the loss. But the point remains the same there, less detail is lost the more you scale.

[tongshadow]

The resolution of the image is completely irrelevant, it makes zero difference.

It doesnt? Then why does my Mario looks cleaner? All I did was 4x sharp scale from the original resolution and then add exactly 1px/2px on each axis. Why doesnt he look like the pixelated mess?




This is the same principle behind sending 480p from a retroscaler as opposed to 1440p, for example. The higher resolution will scale more cleanly.

[Guspaz]

It doesnt? Then why does my Mario looks cleaner? All I did was 4x sharp scale from the original resolution and then add exactly 1px/2px on each axis. Why doesnt he look like the pixelated mess?

Uh, because your first scaling step was a 4x integer nearest neighbour scale, and my first scaling step was a bilinear scale? At that point you're more or less doing a "bilinear sharp", which as I've already demonstrated produces much better results. No game console supports bilinear sharp scaling, so it's not relevant to a discussion about bilinear scaling quality. I did a 4x NN scale at the very *end* just so that it was easier to see the difference, you did a 4x NN scale at the *start*, which invalidates the comparison.

This is the same principle behind sending 480p from a retroscaler as opposed to 1440p, for example. The higher resolution will scale more cleanly.

That's literally line doubling, vertical integer nearest neighbour, what does that have to do with anything? It's not a bilinear scale, thus it's not relevant.

[tongshadow]

Uh, because your first scaling step was a 4x integer nearest neighbour scale, and my first scaling step was a bilinear scale?

And whats the only difference between the 19x34px Mario and the 76x136px one? Resolution. The higher resolution Mario upscaled better.

My claim was that "The less upscaling has to be done, the better the picture will be", such as scaling a 1024x600 game into 1280x720. I said that it would look far less blurrier than scaling 1024x600 to 1920x1080. Your examples arent close to what I propose.
Here, which picture looks better? They're 800x600, 960x720 and 1440x1080.