Hello, SuperLumberjack! Welcome to TASVideos. I have never had such a problem. Frankly speaking, it's hard for me to examine your screenshots, and even if they were small or combined into a GIF, not many people are aware of how Simon's walking cycle is supposed to look like and which frames seem to be lost. Does selecting "Config -> Speed/Skip -> Skip 0 (never)" option change anything?
But it's always each 4 frames, sometimes 3 or 5, that there is a missing frame in my records.
Strangely, I checked on other videos on YouTube and noticed the same issue!
Example with this video:
Link to video
I extracted some frames (I zoomed at 100% in 1080p) from the video and added a blue line and a red mark on each frame to better see (click on them too) how a frame is skipped every 4 frames.
The 1rst frame or frame 0 is of course a 4rth frame.
I tested with a video from the Nintendo Switch Online too. Same observation!
Link to video
So, what do you think it is and why have we never heard of it?
If somebody has the answer, thanks to this person! 😉
At the same time, I created a thread on the NeoGAF forums: https://www.neogaf.com/threads/dropped-frames-with-avi-records-and-super-nes-games-with-bizhawk.1672836/
Thanks for your help! Have a nice day!
(Sorry if my English is not great, I'm French ^_^)I was too focused on the perfection of the reproduction and the technic with the blended images ^_^ So in fullscreen it's another technic, the picture needs to be upscaled 4X with a PointResize filter and then, it's simply a bilinear filter to achieve the 1080p resolution ! And for the "Clean" filter, it's simply that :Language: AviSynthImagesource("H:\source image.png") ## 1080p None Filter PointResize(1696, 960) # Simple 4X BilinearResize(1920, 1080)
So, there is no magic ! :-P However, the scripts that I posted above are still correct for the windowed mode of the game. To conclude, I will just say as I said before, that really I think that the Bilinear filter is the best to smooth the image and correct the aspect ratio of these old games. It's the most natural I find ! I tried with Bicubic, Lanczos, Spline36, etc., but the ringing... ugh ! And with the anti-ringing filter, it's strange ! In fact, I would only use one these filters to upscale a high resolution image to a higher resolution (Spline36 + anti-ringing personally). But for the low resolution image, I think the bilinear filter is better. So, I still prefer the "Clean" filter in "Sonic Mania", with the resolution doubled with a Point resize filter and then the picture upscaled to the 1080p resolution with the bilinear filter. Oki ! End of the story ! :-D Edit : I changed my mind and finally have adopted the "None" filter, because with some phases of gameplay, it's easier when you see better ! ^_^ And it's more clean in fact (than the "Clean" filter...). But is just for playing ! Because even in 2160p, I would prefer the association of a "Simple X4" filter with a bilinear filter, than simply a "Simple X8" or "X9" filters, too blocky I find and therefore unsightly. In fact, I tried with lots of low resolution images (224p, 240p, 480p...) and for me the ideal would be to have the half of the output resolution with the PointResize filter and then achieve the output resolution with the Bilinear filter. In a perfect world, it would be the perfect compromise I think (particularly with 480p contents). If I take for example a Super Nes game with a resolution of "256 x 224", in the ideal I would like to get this :Language: AviSynthImagesource("H:\source image.png") ## 1080p Clean Filter PointResize(848, 480) # Simple 2X BilinearResize(1920, 1080)
Or this still for example :Language: AviSynthImagesource("H:\source image.png") PointResize(1024, 896) BilinearResize(2048, 1792)
But it's not the ideal for our current standards. So in 2160p, this is better, with the correction of the aspect ratio in addition :Language: AviSynthImagesource("H:\source image.png") PointResize(2048, 1792) BilinearResize(4096, 3584)
Si it's still equivalent to the Clean filter of Sonic Mania. But the only problem is that it seems a bit too blurry in 1080p. But with a 2160p resolution, I'm sure it's perfect ! ;-) I know it's a question of tastes, but I think it's the ideal for the old games ! For the modern 2D games in pixel art, it's another story... With recent games like "Celeste" or "Axiom Verge", I would never have the idea to use a Bilinear filter, and a pixel perfect mode is of course better ! But as I said before, these new games were thought to be displayed on modern screens, whereas the old weren't ! And I think that lots of people know how the blurriness of some cables and screens were important to have some proper effects in lots of these games with the dithering for example, etc. The interesting posts concerning the subject of the thread (the aspect ratio correction) : http://tasvideos.org/forum/viewtopic.php?p=486114#486114 (the end of the post) http://tasvideos.org/forum/viewtopic.php?p=486163#486163Language: AviSynthImagesource("H:\source image.png") PointResize(1024, 896) BilinearResize(2820, 2160)
A screenshot in-game that I took in windowed mode with window size 3X and the "None" filter (edit : it shouldn't be blurry) :
And the "None" filter that I reproduce with an AviSynth script :
Screenshot in-game windowed mode 3X with the "Clean" filter :Language: AviSynthA=Imagesource("H:\source image.png",end=0).convertToRGB24 A=A.PointResize(1272, 720) ## None Filter x = 1.0 y = 0.0 OP= 0.25 B=PointResize(A,A.Width,A.Height,-x,-y,A.Width,A.Height) A.Overlay(B,Opacity=OP) A=Last # Make A as above x = 0.0 y = 1.0 OP= 0.25 B=PointResize(A,A.Width,A.Height,-x,-y,A.Width,A.Height) A.Overlay(B,Opacity=OP)
The "Clean" filter reproduced with an AviSynth script :
But what's really interesting is this game is the "Fullscreen mode". I would even say that it is amazing, because I totally failed to try to recreate it ! Indeed, it looks like if there wasn't any interpolation to display the picture !Language: AviSynthA=Imagesource("H:\source image.png",end=0).convertToRGB24 A=A.PointResize(1272, 720) ## Clean Filter x = 1.0 y = 0.0 OP= 1.0/3.0 B=PointResize(A,A.Width,A.Height,-x,-y,A.Width,A.Height) A.Overlay(B,Opacity=OP) A=Last # Make A as above x = 0.0 y = 1.0 OP= 1.0/3.0 B=PointResize(A,A.Width,A.Height,-x,-y,A.Width,A.Height) A.Overlay(B,Opacity=OP)
I tried with a PointResize filter, but it didn't match :
Here is the image in-game zoomed :
And my reproduction with the PointResize filter :
But as you can see, it's less accurate...
You can even try with a LanczosResize filter, it will look blurry and inaccurate.
But the most interesting thing about the game, to return to the subject of the thread, is that the picture has in addition to be stretched a bit, because the aspect ratio of the game isn't a perfect 16:9 AR.
So, could somebody explain to me how the developers did to create this miracle ? :-P
I'm really interested, because it looks like a perfect solution ! :-)
It's good to scale the image by a non integrer number and to display the image with another aspect ratio apparently.
Bonus :
Super Metroid with a Simple 3X filter only :
Super Metroid 3X with the "None" filter of Sonic Mania (it's wrong, because it already wasn't correct in Sonic Mania on my desktop PC) :
Note :
You just need to put this at the beginning of the script :
The rest is always the same. Super Metroid 3X with the "Clean" filter of Sonic Mania :Language: AviSynthA=A.PointResize(768, 672)
I find this really interesting ! :-)
Personnally, it's the "Clean" filter that I prefer !
Edit : You were right Aktan, the picture shouldn't be blurry with the filter on "None", even with the windowed mode. Because on my laptop, I didn't notice any blur in Sonic Mania with no filter. So there is a strange problem with Sonic Mania on my desktop PC with the filter on "None" in the windowed mode.
Here is the same picture with an aspect ratio corrected with a bilinear filter, like Higan does :Language: AviSynthA=Avisource("G:\name_of_the_file.avi").convertToRGB24.PointResize(512, 448).AddBorders(0, 16, 0, 16) # the picture resolution is doubled and black borders are added to achieve the 480p resolution x = -1.0 # this shift the picture to the left y = 0.0 OP= 0.5 # the blend ratio B=PointResize(A,A.Width,A.Height,-x,-y,A.Width,A.Height) A.Overlay(B,Opacity=OP) # the shifted image and the original image are blended together BilinearResize(1024, 960) # the picture resolution is doubled with a bilinear filter
In addition, we can upscale the image in a 2160p resolution, for example with a "Spline36" resizer (the one I prefer, because it's equivalent to "Lanczos3", but with less ringing and artefacts) or a "Lanczos3" resizer :Language: AviSynthA=Avisource("G:\name_of_the_file.avi").convertToRGB24.PointResize(512, 448).AddBorders(0, 16, 0, 16) # the picture resolution is doubled and black borders are added to achieve the 480p resolution x = -1.0 # this shift the picture to the left y = 0.0 OP= 0.5 # the blend ratio B=PointResize(A,A.Width,A.Height,-x,-y,A.Width,A.Height) A.Overlay(B,Opacity=OP) # the shifted image and the original image are blended together BilinearResize(1170, 960) # the picture resolution is doubled and the aspect ratio corrected with a bilinear filter
I use the "Resize8" plugin because it uses an anti-ringing filter : http://avisynth.nl/index.php/Resize8
(But be careful ! Other defaults can appear with the anti-ringing, if the scaling factor is too high)
Or we can remove the black borders too :Language: AviSynthResize8(2632, 2160, kernel="Spline36", kernel_c="Spline36")
I know that some of you will find this blurry, but it's like Higan does. I will finish with the question of the aspect ratio, or rather remind what I found, to stay within the theme of the topic ;-) Higan use the same aspect ratio for the Super Nes games that the one which is in this list here : https://pineight.com/mw/?title=Dot_clock_rates I will quote some things that I said (sorry for the narcissism ^_^ ) to help you to understand :Language: AviSynthA=Avisource("G:\name_of_the_file.avi").convertToRGB24.PointResize(512, 448) # the picture resolution is doubled x = -1.0 # this shift the picture to the left y = 0.0 OP= 0.5 # the blend ratio B=PointResize(A,A.Width,A.Height,-x,-y,A.Width,A.Height) A.Overlay(B,Opacity=OP) # the shifted image and the original image are blended together BilinearResize(1170, 896) # the picture resolution is doubled and the aspect ratio corrected with a bilinear filter Resize8(2820, 2160, kernel="Spline36", kernel_c="Spline36")
And so, we calculate the new resolution like this : 256 x (8:7) = 292, 57 In fact, the original ratio of 8:7 correspond to : 256 x (1:1) = 256 Otherwise, you can simply do this : (64:49) x 224 = 292,57 With the standard 4:3, we get this : (4:3) x 224 = 298,66 And with the original 8:7 aspect ratio this : (8:7) x 224 = 256 Finally, with a 4:3 AR on a modern screen, we need to choose the resolution : 292 x 224 or 293 x 224 Higan proposes these resolutions in 4:3 : - Small : 585 x 448 (585 x 480) - Medium : 877 x 672 (877 x 720) - Large : 1170 x 896 (1170 x 960) And the Super Nes Classic Mini proposes a resolution of "877 x 672" too (1280 x 720 with borders).
Note that there is no difference between the "None" and the "Clean" filters when the picture size is 1X or 2X. It begins with 3X.
It's strange, because I had to search on Google to find a capture of the game in its native resolution without any blur :
So, this little blur with the "None" filter is always active.
Here is the game scaled 3X :
And in fullscreen in 1080p :
It's interesting to notice that the native resolution doesn't correspond exactly with a 16:9 aspect ratio, because :
424/240 = 1,7666666666666666666666666666667
But :
16/9 = 1,7777777777777777777777777777778
So the game has to be slightly stretched in fullscreen mode. I don't know if it's a bilinear filter that is used, something else or nothing. It's hard to compare with this blur.
But at least, we can compare how the blur works ! ;-)
I upscaled the original picture 3X with a Point resizer to achieve the 720p resolution (image left) and then compared it with the picture in-game (image right). The picture is zoomed at 400% :
As you can see, if we observe a big pixel (which has 12 pixels here, because of the 3X scaling and the zoom at 400%), the part which is blurry is all around the pixel (to the left, the right, the bottom and the top) and correspond to 1/3 of the pixel (4 pixels on 12 pixels).
If I show you this, it's because I think that this method of representation of the pixel art isn't bad and rather transparent. Maybe we can took our inspiration from this ;-)
Who suspected there is a little blur in this game when there is no filter ? :-P
The only problem is that I don't know what kind of blur it is... :-/
I found it here and just cut the borders :
http://www.nintendolife.com/news/2017/09/hardware_review_the_snes_classic_mini_is_the_perfect_link_to_the_past
There are others here :
https://www.eurogamer.net/articles/digitalfoundry-2017-nintendo-classic-mini-super-nes-system-review
The resolution is "877 x 672".
It's just a Simple X3 (or nearest neighbor) and a bilinear filter to correct the AR.
And just to check :
672 x (64:49) = 877
So even the "official" Super Nes Classic Mini doesn't use an exact 4:3 aspect ratio ;-)
=> List of the aspect ratios
But I think there is an idea like what I suggested, a kind of reversed deinterlacing (no interlacing of course) for the old progressive content made to work with scanlines.
In fact, I analysed what they did with the Super Nes games.
With the biggest scaling (the resolution is 1170 x 960), they :
- double the resolution to 512 x 480 (448 pxs + black borders)
- move the picture from 1 pixel horizontally (it's like a ghost image, it doesn't work with a simple blur)
- double the resolution and correct the aspect ratio with a bilinear filter to achieve the resolution of 1170 x 960
It's really smart and work quite well ! :-)
But lots of people will find the picture too blurry. But the effect in motion is good and rather natural I think !I thought the current script would be point resize to the target resolution or bigger in multiples of 2, then downscale to the target resolution if needed. For example:There is a slight color bleed which is intentional to make the pixel sizes consistent.Language: avisynthAVISource("movie.avi") PointResize(3408, 2928).LanczosResize(2880, 2160, taps=2) ConvertToYV24(matrix="Rec709", chromaresample="point") ConvertToYV12(matrix="Rec709", chromaresample="lanczos") # Notice the change in chromaresample
Yes, Lagarith YV12 is probably using Rec601 color matrix, but since you already know how to use Avisynth, why not capture in RGB and convert it yourself as a last step, then send to Handbrake?
What he did was upscale it above the target resolution, then downscaled to the target resolution with AreaResize. AreaResize uses weighted averages to figure out the end result.
This is why I personally use Lanczos with 2 taps instead of 3. Less ringing but more blurry.
So I tested this with a 240p image doubled to 480p. With a Super Nes game, I tested this :Language: AviSynthBlur(0, 1.0)
Language: AviSynthPointResize(512, 448) Blur(0, 1.0)
For me, it's only like this that I finally see a convincing relief in the image, like it was on a CRT.
But as everybody can see it, the result is blurry and not really nice ! Like a deinterlaced video with blended fields in fact ^_^
But I think that all the problem of the games in 240p is exactly the same that it is with interlaced contents on our modern screen.
It's a bit unnatural... :-/
It doesn't work without deinterlacing or something else and even with that, it's far from perfect.
For me, it's the only problem ! It really doesn't work on a modern screen ! Only the modern pixel art games are done to perfectly work on a modern screen I think.
With the old 2D games, we always have to use a trick to render them acceptable.
In the ideal, we should have the double of the definition for the vertical resolution !
(source : https://youtu.be/iPohK0D8qvM )
I know the picture is bad :-P
But what is interesting is that the guy used a VGA CRT monitor instead of a CRT TV with the real console and an OSSC.
I think it's better to compare with this than with a CRT TV and its scanlines, because it's closer to the conditions we have on a modern screen which hasn't scanlines.
But there is the version with a CRT TV too ^_^ :
(source : https://youtu.be/OxBXiCPFM78 )
And so, here is a test with (very basic) scanlines and a little boost of gamma to compensate :
Personnally, I wouldn't use scanlines for YouTube. It's just to compare ! :-) The same without scanlines :Language: avisynthPointResize(512, 448) Scanlines(STRENGTH=75) Levels(0, 1.25, 255, 0, 255) PointResize(1024, 896) BilinearResize(2820, 2160) # Personnally, with some other games like "Super Metroid", "Mr. Nutz" or "Super Mario World", I keep the 8:7 AR, so I choose a resolution of 2468 x 2160
Another capture for model :Language: avisynthPointResize(1024, 896) BilinearResize(2820, 2160) # Personnally, with some other games like "Super Metroid", "Mr. Nutz" or "Super Mario World", I keep the 8:7 AR, so I choose a resolution of 2468 x 2160
I tested something softer (without scanlines) :
I choose to change the aspect ratio with the bilinear filter to begin, because I think it's more convincing, but you can choose to do that only with the Spline36 resizer. The same picture without scanlines :Language: avisynthPointResize(512, 448) Scanlines(STRENGTH=75) Levels(0, 1.25, 255, 0, 255) BilinearResize(1170, 896) # Personnally, with some other games like "Super Metroid", "Mr. Nutz" or "Super Mario World", I keep the 8:7 AR, so I choose a resolution of 2468 x 2160 Resize8(2820, 2160, kernel="Spline36", kernel_c="Spline36") # Personnally, with some other games like "Super Metroid", "Mr. Nutz" or "Super Mario World", I keep the 8:7 AR, so I choose a resolution of 2468 x 2160
I tested so many other things (with Nnedi3 too ;-) ) that I can just say one thing : the simpliest is often the best. I know that lots of people hate the bilinear filter, but personnally, I think that the best result is this (from what I suggested of course) :Language: avisynthPointResize(512, 448) BilinearResize(1170, 896) # Personnally, with some other games like "Super Metroid", "Mr. Nutz" or "Super Mario World", I keep the 8:7 AR, so I choose a resolution of 2468 x 2160 Resize8(2820, 2160, kernel="Spline36", kernel_c="Spline36") # Personnally, with some other games like "Super Metroid", "Mr. Nutz" or "Super Mario World", I keep the 8:7 AR, so I choose a resolution of 2468 x 2160
There is no miracle with an upscale ! :-( Some people may think that it's to simple to be good, that it's inaccurate, but was it accurate in those days ? :-) The other problem, as I said above, it's the influence of the modern "pixel art" indie games and their pixel perfect blocky representation... :-P I'm curious to know what you think ! ;-) But I tested enough things (like a lunatic ^_^ ) to know that it's never finished if we are looking for the perfection ! The rest is too subjective... ! Personnally, I keep the PointResize filter with the bilinear. This with 1080p :Language: avisynthPointResize(1024, 896) BilinearResize(2820, 2160) # Personnally, with some other games like "Super Metroid", "Mr. Nutz" or "Super Mario World", I keep the 8:7 AR, so I choose a resolution of 2468 x 2160
This with 1440p :Language: avisynthPointResize(512, 448) BilinearResize(1410, 1080)
And this with 2160p :Language: avisynthPointResize(768, 672) BilinearResize(1880, 1440)
Voilà ! :-P Sorry, there is no big revelation ! :-/ Just some reflexions I think.Language: avisynthPointResize(1024, 896) BilinearResize(2820, 2160)
I know, it's very blocky ! :-P I used the "Resize8" plugin because it uses a anti-ringing filter by default : http://avisynth.nl/index.php/Resize8 The ringing isn't always bad, because it adds sharpness, but I find that the result with the anti-ringing filter is quite good (but it can adds other defaults if the scaling factor is too big). I didn't use the true 4:3 aspect ratio, but : 256 * (8:7) = 2048/7 So : (2048:7)/224 = (64:7)/7 = 64:49 YV24 then YV12 with AVS script (like feos did) :Language: avisynthPointResize(2048, 1792) Resize8(2820, 2160, kernel="Spline36", kernel_c="Spline36")
We can notice different pinks, reds and greens ! But the result is good ! ;-) YV12 with the "UtVideo YUV420 BT.709 VCM" codec :Language: avisynthPointResize(2048, 1792) Resize8(2820, 2160, kernel="Spline36", kernel_c="Spline36") luma = ConvertToYV24(matrix="Rec709", chromaresample="point").ConvertToYV12(matrix="Rec709", chromaresample="point") chroma = ConvertToYV24(matrix="Rec709", chromaresample="point").ConvertToYV12(matrix="Rec709", chromaresample="point") MergeChroma(luma, chroma)
The conversion of the color space is most blurry and less clean than the conversion with the AVS script. Maybe bicubic or something else is used to reduce the chroma resolution. But in theory, the reduction of the chroma needs interpolation too, like when we upscale a picture, so "PointResize" or something else, it's a question of taste I suppose ;-)
However, the color matrix is good and the file is taggued with it :
General Complete name : H:\UtVideo.avi Format : AVI Format/Info : Audio Video Interleave File size : 229 MiB Duration : 2 s 567 ms Overall bit rate : 750 Mb/s Writing library : VirtualDub2 build 41585/release Video ID : 0 Format : YUV Codec ID : ULH0 Codec ID/Info : Ut Video Lossless Codec Codec ID/Hint : Ut Video Duration : 2 s 567 ms Bit rate : 749 Mb/s Width : 2 820 pixels Height : 2 160 pixels Display aspect ratio : 4:3 Frame rate : 60.000 FPS Color space : YUV Chroma subsampling : 4:2:0 Compression mode : Lossless Bits/(Pixel*Frame) : 2.048 Stream size : 229 MiB (100%) Audio ID : 1 Format : PCM Format settings, Endianness : Little Format settings, Sign : Signed Codec ID : 1 Duration : 2 s 567 ms Bit rate mode : Constant Bit rate : 1 024 kb/s Channel(s) : 2 channels Sampling rate : 32.0 kHz Bit depth : 16 bits Stream size : 321 KiB (0%) Alignment : Aligned on interleaves Interleave, duration : 21 ms (1.23 video frame) Interleave, preload duratio : 500 ms
Oki doki ! :-) For the Nnedi3, yes, I already tested it ! ;-) It gives excellent results, but gives sometimes some artefacts too :-/ But I like it too. What did you use to upscale to the final resolution ? Lanczos3 ? I forgot to say that personnally, I prefer the "Spline36" algorithm rather than "Lanczos3" (I did lots of comparisons to be sure). The result is quite similar, but there is a bit less ringing ! ;-) Later, I will show you other scripts that I tested, often softer that what I showed here (maximum pixels, very blocky ! :-P ), not crazy things, but some things that I find pleasant... but never perfect of course ! ^_^ It's too subjective !Language: avisynthPointResize(2048, 1792) Resize8(2820, 2160, kernel="Spline36", kernel_c="Spline36") luma = ConvertToYV24(chromaresample="point").ConvertToYV12(chromaresample="point") chroma = ConvertToYV24(chromaresample="point").ConvertToYV12(chromaresample="point") MergeChroma(luma, chroma)
RGB 24 :
YV12 with the UtVideo codec :
