Over the past decade or so, the 8-bit, 16-bit, and arcade emulation communities have produced a lot of really good and interesting scaling filters, mainly because games made from the 8/16-bit era, actually ran at incredibly low resolutions. In fact, most console games ran at a resolution of around 256x224 pixels. For a little perspective, lets take a look at an unscaled screenshot from Super Mario World, running at the original resolution:
Super Mario World, at it's
The vertical resolution of this image, is 224 pixels. I'm typing on my laptop right now, which has a 15" widescreen display with a vertical resolution of 1050 pixels. That's more than 4.6 times the vertical resolution that the original Super Mario World ran at! The image itself, only takes up 1.75 inches on my screen!
The problem introduced becomes obvious. How do you scale a tiny image to fit displays that are very high resolution, and still make it look good? A lot of work in the last decade or so, has gone into solving this problem. We have everything from basic scanline filters, to complex upscaling algorithms, such as hq4x. The problem with most of these upscaling techniques, is while they increase the resolution, they still look nothing like what the console looked like on an actual CRT TV screen! Maybe it's time we start emulating what old CRT TV screens looked like, instead of pretending we had high resolution displays in the 90s!
The current state of CRT emulation is pretty pathetic. The only halfway decent CRT emulation filters I've come across, are the filters included in Richard Banister's Emulator Enhancer, which is non-free. Most of the other filters do a very bad job of representing what a game actually looked like on a CRT. As a for instance, lets take a look at a couple different filters.
This first image is of the scanline filter in Snes9x. It doesn't look bad, but it doesn't look great either. Really, all it does is add static scanlines. On a real CRT, the scanlines tend look like they're moving downward, as a side effect of how a CRT TV scans pixels sequentially. No effort has gone into simulating the pixel layout of a CRT screen either, and it makes no attempt to emulate the color profile of a TV, which the game was designed for. For a basic filter, it works well on slow systems, but it's not really useful beyond that.
This next filter, is Blargg's NTSC filter. It's significantly better than scanlines, however, it also fails to emulate very important things, such as the pixel layout. It has some cool artifact filters, and presets for emulating different types of signals (Composite, S-Video, etc), but it doesn't go beyond that. Basically, it's an NTSC/signal artifact emulator, as opposed to an actual CRT TV emulator. One major downfall, is while the color profile looks pretty good on my laptop, I can't get it looking like a CRT on any of my other displays.
The problem with these, is they don't attempt to fully emulate a CRT TV, but instead are just filters applied to an image. What we need is a CRT Emulator, that takes the pixel data from the emulator, and emulates everything from the transmission of signal from the console to the TV, to how the TV actually displays the signal, and perhaps even the artifacts introduced by most multi-chip SNES boards. The goal is to make your LCD screen look like it's a CRT screen, which is a fairly difficult task with all of the variation between LCD screens (screen brightness, contrast, resolution, size, etc), and some things are not possible to emulate without further advances in computer display technology (for instance, accuate pixel glow/diffuse emulation requires a display with a refresh rate of at least 120hz).
The following is the pixel layout of a CRT TV. Most computer screens have a "grid" style pixel layout, but as you can see in the picture, CRT TV's don't!
As you could imagine, accurately emulating this pixel layout on a computer display would be impossible, at least if you're trying to emulate it with current display technology (maybe when we get full size "retina displays" :) ...However, if you don't try to emulate the pixels at the level of RGB channels, but instead emulate what the pixels looks like from a distance, you can get pretty close results!
The following is a prototype 3x scaling filter that I wrote, which tries to emulate the pixel layout of a CRT TV, while being limited to a 3x3 pixel grid. It's not optimised, yet it's still fast enough to output 60hz on a modern computer, with an emulator such as Snes9x, and has support for realistic scanlines and interlacing emulation! That's not to say it isn't without flaw. I've been having trouble getting the color profile looking good accross all different types of games. It's simply a first step in the right direction.
And here's an example of the scanline interlacing effects, in Contra 3 (might not look correct in all browsers).
While the prototype filter looks pretty good, it still suffers from some issues. For instance, it currently just scales to 3x the original image size, so the image still has to be scaled to the screen size afterwards. I haven't experimented with making the scale factor tunable yet, but it does look pretty good at fullscreen using a bi-cubic scaling filter. Other things like video transmission artifacts, have been experimented with, but not fully implemented. When I get more free time, I plan on doing further research, and implementing a better version that's more tunable, and has more features.