Opened 13 years ago

Closed 7 years ago

Last modified 17 months ago

#8578 closed patch (outdated)

new Edge3x/2x filter

Reported by: SF/ewelsh42 Owned by:
Priority: normal Component: Graphics: Scalers
Keywords: Cc:
Game:

Description

I have created a new anti-aliasing resize filter which I thought may be of interest to the ScummVM team. It includes a 3x and 2x nearest neighbor resizer, as well as a 2x interpolating resizer. It also detects when overlays are being drawn, such as the mouse, assumes that they have transparancy, and handles transparancy in a reasonable manner so that the anti-aliasing of mouse pointers looks good now (as compared to AdvMame). See the mouse pointer for Maniac Mansion for a good example. The overall image quality is higher than the AdvMame and HQ filters. More edges are anti-alised, fewer edge directions are mis-detected and anti-aliased in the wrong direction, and the shapes and shadings of the original image are better preserved. The new filters give sharpness without the common font edge direction misdetection artifacts of AdvMame, and good anti-aliasing without the common heavy blur of the HQ filters when they are unsure of how best to anti-alias a given pixel. The filters are also reasonably robust to various odd color and shading combinations that give the other filters difficulty. The improved image quality is worth the speed hit, at least to me.

Unfortunately, the improved accuracy comes at a hefty cost in speed. However, since many ScummVM supported games only redraw small amounts of the screen each frame, this is not so much of a problem. But the filter is slow enough that dirty rects still don't help it enough. To speed it up a bit more, the filter keeps local copies of the src and dst buffers so that it can do its own unchanged pixel detection and only redraw pixels that have actually changed between frames, even if a full screen refresh is requested due to color cycling, etc.. It detects all current instances of ScummVM writing to the screen outside of the filter and forces an internal full screen refresh when this occurs, so there should be no artifacts from messages, menus, etc. that get drawn outside of the filter. Unchanged pixel detection and skipping appears to be stable. The cached dst buffer lets it work with aspect ratio correction as well. If at any point this breaks in the future when ScummVM writes outside the filter in a way that the filter does not expect, unchanged pixel skipping can be disabled by simply setting the skip_unchanged_pixels_flag variable in the filter to 1, or figuring out what new case to check for in the function that contains the flag.

With the unchanged pixel detection, most games are smoothly playable for me on my 1.53 GHz Athlon. Full screen pans can get a little jerky, but they still aren't too bad. Modern CPUs should have no problems.

I have attached a diff of the changes, made from a snapshot a few months ago. I applied it to a fresh svn download tonight, and it patched and compiled without errors, so it should still be fine. Minimial changes were made to all of the existing files, just what was required to add basic support of a new filter. The new filter is included in graphics/scaler/edge3x.cpp. See code comments for better descriptions of the edge detection algorithms used, handling of transparancy, unchanged pixel skipping, etc.. The code enclosed in DEBUG defines can be removed, but I thought I would leave it in there for now, as those defines can be very interesting for visualizing which pixels are changing between frames and seeing the outlines of dirty rects.

The default hot-keys are ctl-alt-9, and ctl-alt- +/- switch between the 2x interpolating resizer and the 3x nearest neighbor resizer. It is impossible for a 2x nearest neighbor resizer to get diagonals correct, which is why I chose to default it to the 2x interpolating resizer instead of nearest neighbor.

I forsee the following objections being raised against including this filter in ScummVM:

We don't need yet another filter And I thought HQ3x was slow.... Unchanged pixel detection is a bit of a hack Transparancy handling is also a bit of a hack

I don't necessarily disagree with the last three of those, but I think that the much increased image quality at least warrants giving it a try before turning it down.

Ticket imported from: #1574256. Ticket imported from: patches/683.

Attachments (1)

edge3x.dif (141.4 KB ) - added by SF/ewelsh42 13 years ago.
diff to add new Edge3x/2x anti-aliasing resizer filter

Download all attachments as: .zip

Change History (7)

by SF/ewelsh42, 13 years ago

Attachment: edge3x.dif added

diff to add new Edge3x/2x anti-aliasing resizer filter

comment:1 by sev-, 13 years ago

Summary: new Edge3x/2x resize filter submittednew Edge3x/2x filter

comment:2 by fingolfin, 13 years ago

No scalers are likely to be accepted. Even if that wasn't the case, this patch as it is would not be acceptable due to the hacks it uses. Like messing with the backend settings -- that is not the way to do it.

The auto-dirty-rects code indeed is far from optimal. And on modern machines, detecting changes by keeping a copy of the full frame buffer is possible (memory and mem speed limitations are mostly gone)... But that should be implemented in the backend, not the scaler. I.e. the backend should manage this (and the scaler funcs would need a new additional param, pointing to the content of the "old" screen). You might want to work on such a patch first, if this new scaler needs it to work with acceptable speeds...

comment:3 by SF/ewelsh42, 13 years ago

It doesn't touch the backend settings at all, all the hacks are in the filter itself to work around things that aren't currently in the backends (such as passing transparent overlay information and buffering the screen). No hacks are made to the backends, nor are any backend settings changed or even read, it is all internal to the filter itself. Everything is done by detecting different behaviors, such as the src address being outside the bounds of what the filter guesses to be the full src screen (must be drawing a transparent overlay), the scale, screen dimensions, or overlay dimensions change (resolution change, mouse pointer change like in Sam and Max, drawing messages outside the filter, etc.). I figured it would be "cleaner" to keep the work arounds in the filter, rather than modify the backends and then have to modify all the other filters to work with the new filter parameter passing conventions. I agree that adding buffering and transparancy flags to the backends that get passed as extra filter parameters would be the "right way" to do things, but again, I thought it would be cleaner to just keep it all self-contained in the filter to minimize changes elsewhere. It doesn't do anything to the backends, it just detects some behaviors that, if they change in future builds, may break the filter. Even though they are hacks, they are still pretty stable, they've been working ever since the big change was made in the backends a while ago to draw the original screen and overlays/menus separately, rather than render everything to the screen directly and then apply the filters to the final product (this change led to the need for all the hacks, the transparent pixel handling, etc.). If the filter had a chance at being accepted, I'd modify at least the SDL backend to move stuff out of the filter and into the backend and do things the right way, but since no new filters are likely to be accepted, keeping it self-contained makes it far simpler for me to patch the latest src and not worry about having to continually modify backend changes every time the backends undergo a major revision, or continually having to repatch all the other filters to support new scaler function prototypes with additional paramaters.

If no new filters are likely to be accepted, and the other filters don't really need the features in the backends that my work arounds provide, then I guess there's not much need to add that extra functionality to the backends. It might be nice to add transparency info to the filter arg passing, though, and modify the existing filters to edge detect transparent pixels similar to how I handle it so that transparent pixels provide maximal contrast and thus a more correct edge detection than just using whatever the color chosen to be transparent happens to be. Mouse pointers would look a lot better that way.

I'd hoped the filter might have a chance at being accepted, even with some of the workarounds, since it really looks much better to me than the existing filters (which bugged me enough to make me want to develop this filter in the first place). Oh well, at least someone might still download the patch, try it out, and be happy with the results. Or maybe it can inspire the other filters to have their transparent pixel handling improved so that mouse pointers look better :)

comment:4 by bluegr, 7 years ago

Resolution: outdated
Status: newclosed

comment:5 by bluegr, 7 years ago

As suggested by singron, this has been added in his GSoC pull request here: https://github.com/scummvm/scummvm/pull/271

Thus this patch is now obsolete, and will be eventually merged together with the rest of singron's changes.

Closing as out of date, and changing the group to GSoC

comment:6 by digitall, 17 months ago

Component: Graphics: Scalers
Note: See TracTickets for help on using tickets.