What does /vr/ think?
Me personally thinks hd-upscales with epsx/pcsxr look good in screenshots - for 3d games - but are atrocious ingame because of the jitter, despite gte accurancy. They are a no go for 3d games with prerendered bgs and 2d pixel art games.
Both widescreen hacks in pcsxr or mednafen suck, because they cause slow down and frame-drops and mess up 3d games with prerendered bgs.
Mednafen is very good and accurate. I like it. But it looks really low-res. It also does not support antialiasing.
I like to enhance the picture of mednafen for 3d games & 3d games with prerendered bgs with a bicubic filter. A) for smoothing the edges (antialiasing) and b) for smoothing textures.
For 2d pixel-art games I prefer a PVM, a good CRT or a good CRTshader. I think 3d games look so so on any kind of CRT/PVM device or simulation of such, because the degrading outweighs the enhancing.
2D games looks superior through a CRT because the textures/pixels are smoothed+bleed together to a certain amount through the CRT/analog input but appear really sharp again through the spacing of scanlines which looks really gorgeous in my opinion. 3D PS games on the other hand have prominent jagged edges, which are not meant to be there. So naturally you want to smooth the source to create a superior output, but not add scan lines, as they would degrade the picture again, making the jagged edges prominent again, instead of masking them.
I hooked up my PS to my CRT and my HDTV & found the output to be okay on my CRT, a bit too sharp - prominent jagged edges. The output on the HDTV was too blurry & smudgy for my taste.
I tried to mimic the effect of the PS1 on my CRT but without the scanlines & came to the conclusion that bicubic filtering is the best way to enhance native PS.
You see 3 pictures:
2 Bicubic MitchellNetravali (scientific best way to upscale an image psychovisually)
3 Custom Bicubic B-Spline filter
I personally prefer B-Spline- with the compromise of sharpness.
1. Mednafen with a front-end and accurate filters.
2. A PS2 with its enhancement features on.
3. A PSX with the best output you can mod it to support and a high-quality display (anything but LCD).
Here is a comparison of the Bicubic Catmull-Rom filter and the Bicubic B-Spline by way of illustration.
Now imagine this filter in effect in for example games like Final Fantasy IX and its prerendered backgrounds.
This filter may be blurry, but it makes textures really smooth and the output interpolation really consistent instead of uneven, which I value the most.
>The best way to play Playstation games acurrately and as good looking as possible
PS1 > RGB > XRGB 3 > transcoder > High quality LCD.
Or maybe mess with emulation. Probably get something decent.
Why is integer ratio so hard for you idiots to understand? Look how shit the dithering is in your first image. Nearest neighbor is unfairly considered ugly because people keep doing it wrong.
Then WTF is this? Your image, cropped and zoomed 10x. I assure you the PS1 did not output variable sized pixels. All those dots are supposed to be the same size. You fucked up the scaling.
My favorite general purpose upscaling filter is sigmoidized EWA lanczossharp. In imagemagick:
convert ff9.png -colorspace RGB +sigmoidal-contrast 5 -filter LanczosSharp -distort Resize \!512x256 -sigmoidal-contrast 5 -colorspace sRGB ff9_r.png
Note that the original image has some sharpening, which exaggerates the haloing no matter what filter you use. But look how much clearer the text is with this scaling, and the great balance between smoothness and sharpness.
You can do the same thing in real time with shaders in MPV, so I suppose somebody could make it work with emulators.
>original hardware + SD CRT TV
>accurate emulator input into SD CRT TV
>accurate emulator + CRT monitor + shader
Those are the only way to really get high quality image accuracy.
4K emulator CRT shaders are okay but still not great. Anything under 4K is going to look bad.
>What does /vr/ think?
I think the Mednafen shilling needs to stop.
>CRT, shaders, filters
Literally autism: the post
Most of us just pop a PS1 disc into our real hardware and actually play the games instead of arguing over which method is subjectively "better."
And this is why forced anonymous should be a thing on all boards.
CRUENTO PESTIS SHATRUEX PRAYANAVITA DOMUS-BHAAVA
Thank you. Really interesting.
Do you have the parameters for this filter? You could create one yourself.
CG Shaders are easily implemented. They usually follow a pattern like this:
#pragma parameter JINC2_WINDOW_SINC "Window Sinc Param" 0.44 0.0 1.0 0.01
#pragma parameter JINC2_SINC "Sinc Param" 0.82 0.0 1.0 0.01
#pragma parameter JINC2_AR_STRENGTH "Anti-ringing Strength" 0.5 0.0 1.0 0.1
uniform float JINC2_WINDOW_SINC;
uniform float JINC2_SINC;
uniform float JINC2_AR_STRENGTH;
#define JINC2_WINDOW_SINC 0.44
#define JINC2_SINC 0.82
#define JINC2_AR_STRENGTH 0.5
#pragma parameter LANCZOS2_WINDOW_SINC "Window Sinc Param" 0.5 0.0 1.0 0.01
#pragma parameter LANCZOS2_SINC "Sinc Param" 1.0 0.0 1.0 0.01
#pragma parameter LANCZOS2_AR_STRENGTH "Anti-ringing Strength" 0.8 0.0 1.0 0.1
uniform float LANCZOS2_WINDOW_SINC;
uniform float LANCZOS2_SINC;
uniform float LANCZOS2_AR_STRENGTH;
#define LANCZOS2_WINDOW_SINC 0.5
#define LANCZOS2_SINC 1.0
#define LANCZOS2_AR_STRENGTH 0.8
float ax = abs(x);
const float B = 1.0 / 3.0;
const float C = 1.0 / 3.0;
Fixed it for you, by reversing your defective integer ratio scaling, redoing it correctly, and then fixing the aspect ratio with horizontal axis only sigmoidized EWA lanczossharp. Flick between the two images and check out how much better the dithering looks now the pixels are all the same size.
I found the bug. Ironically Retroarch applies the wrong core provided aspect ratio when overscan cropping is turned off. The only way to display the correct aspect ratio is to turn overscan cropping on. Thank you for bringing this to my attention. That it very unfornunate indeed. But now it is correct.
The game is obviously using 512x224/240/256 depending on the region and coding. It's not 320x240 natively so it's not going to scale up well unless you do something like 1024x896/960/1024.
Of course the intended aspect ratio would always be 4:3, but the most correct way to do an integer scaling of something odd like 512x224 while keeping a close ratio would be doing a vertical doubling first.
Btw this also goes for SNES games.
Mednafen simply outputs 4:3 in most cases. If you only did 1:1 pixel aspect ratio, then you would have games suddenly changing the display aspect ratio when they changed to a different resolution.
It's pretty much impossible to display PSX 4:3 and still always have integer scaling.
Just curious, would perspective correct texture rasterization always improve a PSX frame? I can't imagine many games would rely on the incorrect screen coordinate rasterization.
You can use a CPU filter to scale 3x integer nearest or so (I don't think one's included in the official distribution, but it's easy to write), and then bicubic or something in a shader. This is a reasonably good compromise between sharpness, speed, and artifacting.
Perfect rectangles actually, because the pixel aspect isn't 1:1.
Scratch what I said in >>2891078, and no I don't mean pixels should be perfect squares if you don't want the pic to get large (but that would be the closest to integer anything). I just mean every pixel has to be the same width.
In this case, all you have to do is get the 512x224 framebuffer and double it to 512x448 using nearest neighbour. And there it is.
You can't expect perfect square pixels on PSX, because games can use wildly non 4:3 resolutions internally.
Best recourse is to use sharp-bilinear or pixellate shaders if you want to keep pixels sharp without unevenness.
This game uses 512x240 during gameplay, but displays 320x240 during loading cutscenes and 640x480i in the main menu.
>You can use a CPU filter to scale 3x integer nearest or so (I don't think one's included in the official distribution, but it's easy to write), and then bicubic or something in a shader.
That's more or less what sharp-bilinear shader does, it prescales 2x to 5x nearest neighbor, then scales using bilinear to the screen resolution.
If you want to do it with something other than bilinear, you can make a shader preset that uses the stock shader to scale 2x to 5x Nearest, then put the interpolation shader in the last pass to scale to screen dimensions.
Haven't tried this, sounds good
Tried this, it sucks because the sharpness varies depending on how the emulated pixels line up with the screen pixels.
It always displayed 4:3.
Another complication - the PS1 could move the image on CRTs by adjusting the video signal timing. Some games had this in the options menu. And a few games (Chrono Cross was one IIRC) used this feature to do screen shaking effects. This literally moves the image by fractional pixels. Can any emulators handle this?
>I can't imagine many games would rely on the incorrect screen coordinate rasterization.
I can't imagine any developer building 3D assets around affine transformation. For static sprites and all that there are specific 2D functions which are rasterized without any vertex information.
How so? Please explain it to me so I can understand- I don't get it. Stretching is stretching I though, if done by CRT or integer scaling in the emulator.
And what do you mean by same width? All the pixels in the image have the same width. The pixels are not square but they have the same width. If the internal resolution is not 320x240 the pixels can't be square, nor can the displayed signal on a CRT line display them that way. If you were to stretch the pixels to rectangles the image would become very distorted as seen in the attached image.
But maybe this is all wrong, as we don't how mednafen works. Maybe the resolution is displayed correctly just the dither pattern is displayed or scaled incorrectly which maybe a emulator or core specific bug.
Okay but isn't it as follows:
Ps generates let's say 512x240 image.
>CRT stretches it 4:3 aspect ratio in analog signal with lines. The pattern of a square displayed will be stretched accordingly.
>Emulator stretches image to 640x480 and the interg scales it or integer scales it and then stretches the image.
You end up with a non square pixel.
Maybe I'm just misunderstanding what you are trying to convery, because I totally get it wrong.
I want to play Suidoken II without throwing down 100+ ameribucks on it, so I plan on emulating it I guess
What emulator should I use? Any psx emulators with filters that could give an effect similar to my XRGB mini?
See this? I vertically doubled >>2891096 so that I could get the most correct integer scaling while keeping a close aspect ratio of what it's supposed to look like on a TV. To be even more accurate I would have needed to add artificial scan lines instead of doubling them but you get the point.
No they're not, do you want me to point out they aren't?
But a TV is stretching the image to 4:3 (1,333:1). The image you posted is 1,07:1. How can that be correct? It sounds theoretically correct, but in practice it's not accurate I guess. It would only be correct if the TV letterboxed non 320x240/640x480 content, but >>2891139 >>2891156 and >>2891158 said that it always is displayed as 4:3.
Oh shit, really? I haven't fired up my PS3 in a long ass time. Thanks for the info
I'm sorry, I don't wanna sound rude, but have you actually read the replies? It was said now at least three times that the improper scaling was caused by a emulator bug which was fixed with a setting here >>2891058
Please compare again
original version with wrong aspect ratio: >>2890981
your corrected version of the wrong aspect ratio: >>2891016
and the correct version with 4:3 aspect ratio: >>2891058
Please do review again everything you said in reply to this >>2891058 image and reconsider.
I think this was just a misunderstanding and you didn't see that the changed setting actually fixed the incorrect scaling and I thank you very much and I'm grateful that you brought it to my attention. That is all I have to say about this topic.
>by a emulator bug which was fixed with a setting here
And I hereby tell you that no it was not. Why? Because 512x240 just can't flatout be scaled with an integer factor if the resulting image is 1280 pixels wide, because 512*2=1024 and 512*3=1536, not 1280.
I have zoomed part of the image you're talking about and upscaled 2x. Excuse the poor drawings I made to illustrate my point.
That is unfortunate because mednafens internal resolution seems to be 320x240. There is no way to correct the dither pattern without destroying the intended aspect ratio of 4:3.
I could try it with a custom aspect ratio but it would basically stretch the 320x240 pixels to 512x240 or the multiples of it, but then the aspect ratio would be wrong.
You would need to use an output resolution of something like 2720x1920 at mininum to maintain integer scale at all possible PSX resolutions at an aspect ratio that's somewhat close to 4:3 (in this case, 17:12 or 1.41666). Higher integer scales of that could get you closer to 4:3 but you'd need like 8K or higher screens to display them.
Am I wrong for thinking S-Video for the PS1 looks wrong? Watched a video earlier today.
Maybe it'll look sharper on my TV, I am not sure, but that "step up" just looks wrong to me.
PS1 games look great rendered at the original resolution but displayed at whatever your desktop is.
some of them look particularly good in widescreen, like Silent Hill and Metal Gear Solid.
Then again, most people can't stand the 'blocky' models because they're faggots. Anyone got those SH .GIFs?
This is a detail of retroarch/mednafen in 8K 7680x3840 letterboxed 4:3. Is the problem still prevalent? I can't tell. If so, it's not a resolution but an emulator/core/mednafen specific problem.
it's not as much a wide resolution, as it is a short resolution. Fewer pixels means less work for CPU and GPU. Especially for text, but also general imagery, we rely more on horizontal information than on vertical information. So instead of making the entire output proportionally smaller, it's smarter to use a distorted viewport with tall pixels.
CRTs don't use integer scaling, and have no concept of pixels. That's why uneven dither patterns can not occur. You can even change the size of the output image on your CRT (TV or monitor) with the various analog knobs, and it will only distort the image, but not introduce any scaling artifacts.
I don't know much about PSX architecture, but usually 2d stuff is just 3d with one of the coordinates zeroed out. If that is the case on the PSX, perspective correct texture mapping would be identical to screen coordinate texture mapping, as there is no perceptive to correct for. If there is special 2d hardware, the point is moot because you don't need perspective-anything in 2d.
There's a bit of a workaround I'm using on DOSBox: You upscale the internal resolution to 3x or so using nearest neighbor, then render that on screen using bilinear filtering. The result is a very slightly blurred nearest neighbor output. The advantage of the mild blurring is that misalignments with the output resolution are eaten up by antialiased pixel edges, instead of uneven pixel sizes
Stretch scaling will actually reduce brightness on a real CRT.
Try for example turning between 4:3 and 16:9 on a 4:3 CRT. The latter will be brighter because same amount of light gets "drawn" on a smaller surface.
A real CRT filter should probably try and account for this during aspect correction.
>still using a CRT when it's possible to make old games look amazing on an HD TV