So, I did another re encode to 1080p for YT: http://www.youtube.com/watch?v=SQTvk9v-CGs&hd=1
(the original resolution was 640x480).
It is just a bit tedious to do a second upscaled encode just that YT retains some quality.

With my videos I don't do a second upscale. If I do a 4:3 recording with my S-Video capture device, I crop the image and then scale to 1440 x 1080.

I do the same for my DOSBox videos, though they don't need cropping as they are perfect 320 x 200 already.

The other option is you just upload at 640 x 480.

Mau1wurf1977 wrote:

If your footage is 640 x 480 just use your encoding program and resize is to 1440 x 1080.

You shouldn't be doing a lossy upscale before uploading to Youtube. It'll force the generation of a 1080p encode, but what's the use when it's just an upscaled 480p? Youtube's 480p encodes are pretty high quality, so there's pretty much no gain in quality (in fact, any upscale loses some quality).

If you're going to upscale, go to 1920x1440 (original x 3), which will create the 720p and 1080p versions whilst keeping the 480p sharp.

If your content is pixel art, consider doing a point upscale instead of a regular bicubic/Lanczos upscale. (Example)

edit: btw, Youtube is capped at 30 fps, so you can safely decimate it while encoding the final version. Should speed things up.

This is probably a quite difficult topic.
I don't see why an upscale is lossy. I think if you use identical algorithms for up- and downscaling the result is more or less reversible. For downscaling on playback you are right that integer scaling factors will keep the sharpness.

Comparing videos of a original 480p vs a 1920x1440 encode downscaled to 480p is more complex. In both cases you have a 8x8 pixel area for iDCT which means a finer granularity for the higher resolution. So the idea is that the upscaled video requires only a small increase in bitrate to keep the same quality as overall iDCT factors can be reduced by the same amount as before. Still youtube bitrates for higher resolution videos increase more rapidly than required for just upscaled content. This would mean you have for upscaled content a comparably higher bitrate that YT can use for reencoding.

The framerate reduction YT does is another problem. What tool would you use to reduce a video featuring a 70 fps (usual DOS mode) video with fluid animation to 30 fps?

elianda wrote:

The framerate reduction YT does is another problem. What tool would you use to reduce a video featuring a 70 fps (usual DOS mode) video with fluid animation to 30 fps?

Any tool will do. Virtualdub, AviSynth are good ones. The x264 binary can do it directly. It might (not sure about this) be better to encode only every third frame, reducing the framerate to 23.33 fps.

elianda wrote:

I think if you use identical algorithms for up- and downscaling the result is more or less reversible.

No, they're not reversible. Only a point upscale (nearest neighbor) is lossless. Every time you scale using bilinear, bicubic or some other lossy algorithm, you lose some information. Take any screenshot of a game, scale it up and then back down, and you'll see what I mean. Using integer scaling factors reduces the effect but doesn't avoid it.

It might not matter all that much, though. It really depends on the circumstances and the quality of your input material. But personally I prefer not to upscale content except with point upscale (because it allows you to see nice and crisp pixel art in the HD encodes).

edit: (I'd only recommend point upscale when your content is lossless to begin with, though.)

dada wrote:

Youtube's 480p encodes are pretty high quality, so there's pretty much no gain in quality (in fact, any upscale loses some quality).

I've done all these tests and I disagree.

And I can't be bothered to prove it either. I used to post screen-shots and video examples and all of that. But now I just do my thing and others can do theirs 😀

I'm pretty sure the >480p encodes are rendered at a slightly better rate factor than 480p, but the difference probably isn't that big. The 480p content I've uploaded usually ends up being converted very decently. So you're basically just serving upscaled content, and, in my view, that doesn't really justify the difference in file size, but if you need an extra push in quality without regard for file size then yeah you could do it. It's like you say, people should do what works for them.

Oh yea th files are much larger...

I found an old post that I used to explain why I upscale videos:

http://forums.overclockers.com.au/showpost.ph … 7&postcount=292

It's not so much the upscaling, but more what / how YouTube handles 1080 compared to 480.

dada wrote:

elianda wrote:

I think if you use identical algorithms for up- and downscaling the result is more or less reversible.

No, they're not reversible. Only a point upscale (nearest neighbor) is lossless. Every time you scale using bilinear, bicubic or some other lossy algorithm, you lose some information. Take any screenshot of a game, scale it up and then back down, and you'll see what I mean. Using integer scaling factors reduces the effect but doesn't avoid it.

Let me illustrate this on a usual cubic spline interpolation:

As you can see I made a table on the left with a starting array with 10 points of arbitrary integer values. The second array was (wave0_CS) was scaled up using a cubic spline algorithm by a factor of 2.5, so there are 25 points. Then I scaled it back down to 10 points. As you see the deviation is marginally from the original integer values. It is also illustrated as plot on the right. The original and up+downscaled points are basically identical.
I would not call this a lossy transformation.

For more details about cubic spline interpolation implementation see
this chapter from "Numerical Recipes in C"
http://www.arcetri.astro.it/irlab/library/rec … okcpdf/c3-3.pdf

dada wrote:

It might not matter all that much, though. It really depends on the circumstances and the quality of your input material. But personally I prefer not to upscale content except with point upscale (because it allows you to see nice and crisp pixel art in the HD encodes).

edit: (I'd only recommend point upscale when your content is lossless to begin with, though.)

Any upscaling that uses more than zero order (linear a.s.o.) reduces sharpness. To keep sharp edges a integer point upscale is as you write probably the correct way to go. I think I will do some encodes for comparison for myself. 😀

So here something new with point upscale: http://www.youtube.com/watch?v=MQDRLOPem48&hd=1

some update:
90210 by 7 Gods:
HQ: ftp://78.47.153.163/video/90210_by_7Gods.mkv
LQ: http://www.youtube.com/watch?v=_YnlVK4GdAw

Paniq / Future Crew:
LQ: http://www.youtube.com/watch?v=MQDRLOPem48

Unreal gameplay (V2 SLI):
HQ: ftp://78.47.153.163/video/unreal_effect.mkv
LQ: http://www.youtube.com/watch?v=QLBgaLOi7N4&hd=1

Edit: Now the YT video seems to be in sync. So enjoy some Unreal ambience and more action in the end.

Haha perfect... Yeah the V2 SLI was the ultimate config for Unreal back then and nothing came close or beat it (at least until the V3 came along).

Well here some footage from my Creative Videoblaster: http://www.youtube.com/watch?v=5LrwSGRflPE&hd=1

elianda wrote:

As you can see I made a table on the left with a starting array with 10 points of arbitrary integer values. The second array was (wave0_CS) was scaled up using a cubic spline algorithm by a factor of 2.5, so there are 25 points. Then I scaled it back down to 10 points. As you see the deviation is marginally from the original integer values. It is also illustrated as plot on the right. The original and up+downscaled points are basically identical.
I would not call this a lossy transformation.

.... I think the key thing is that you don't have the original values back; they're not identical, therefore you've therefore lost information. So it is a lossy conversion.

ok let me sketch how this works:

You have a source graph with n points and want to have interpolated values.
between two points you look for a function
f(x)=a*x^3+b*x^2+c*x+d
so for the points from x1 to x2 let's call this function f12(x).

As boundary condition the spline is defined to have
f12(x1)=y1 and f12(x2)=y2
also the right (+) and left (-) derivatives at this points are set
f12'(x1)=g'+(x1) and f12'-(x2)=g'-(x2) with g' as the derivative of the original graph at this point. To get the spline smooth the derivatives of connected function parts are set to the same value f12'-(x2)=f23'+(x2).
From this four values the equation can be solved.

So if the number of interpolated values are an integer factor to the original values, there are new x_n that hit exactly the original graphs x positions. By definition of the spline those values are identical.
In such cases it is lossless because only the values in between the identical x positions are added.

In the example I scaled up by 2.5. There this behaviour is also visible.
In the upscaled table the 8th value equals the 3rd value of the original and if scaled down again it stays identical.