1. used software/material
2. preparation
3. execution
4. results
   1. testcase1 – big buck bunny 1920×1080 » lanczos 854×480 » 1920×1080
   2. testcase2 – sintel 1920×818 » lanczos 1126×480 » 1920×1080
   3. testcase3 – elephants dream 1920×1080 » bicubic 640×360 » 1920×1080
   4. overall result
   5. visual results
5. conclusion

 
used software/material
MPlayer, Avisynth, Bash, Gimp, ImageMagick, OpenMovie Sintel, OpenMovie Big Buck Bunny, OpenMovie Elephants Dream

 
preparation
I took screenshots of a movie, stored the original highres image and created a lowscaled version of it. Then I created upscaled (to the same resolution as the highres image) variants of that lowscaled variant. And finally I compared the upscaled variant with the original highres variant.

 
execution
To create screenshots I have written a little Bashscript which gets screenshots using mplayer. The quality of the jpegs is set to 100 to have “lossless” images (more or less). The script needs ffmpeg to get the duration of the movie (pretty sure that might work with mplayer aswell, just didn’t find out how to easily parse that):

#!/bin/bash

infile=$1;
amount=$2;

# getting the length of the movie in seconds
ffmpeg -i "$infile" 2>/tmp/video.log
h=$(grep Duration /tmp/video.log | awk '{ print $2 }' | cut -d: -f1);
m=$(grep Duration /tmp/video.log | awk '{ print $2 }' | cut -d: -f2);
s=$(echo "($h * 60 * 60) + ($m * 60) - 60" | bc);

for (( x=1; x<=$amount; x++)); do
  stime=$(echo "$x * ($s / $amount)" | bc);
  echo $stime;
  tmp=$(mplayer -frames 1 -ss $stime -vo jpeg:quality=100:outdir=screens $infile > /dev/null);
  mv screens/00000001.jpg screens/$x.jpg
done

Then I’ve used gimp to create low-res variants of that screens – For the first two testcases I used lanczos and downscaled to a height of 480px. For the third testcase I used bicubic and downscaled to a height of 360px.

Then I’ve used lots of avisynth scripts to do the upscaling. An example for blackman and nnedi3:

source = ImageSource("3.jpg").Trim(0,-1)
us3 = BlackmanResize(source, 1920, 1080)
us13 = nnedi3_rpow2(source, rfactor=4, cshift="spline36resize", fwidth=1920, fheight=1080)

#ImageWriter(us3, file="3_blackman", type="jpeg")
ImageWriter(us13, file="3_nnedi3", type="jpeg")

The resulting upscaled image I’ve compared to the original image using ImageMagick:

convert originalimage.jpg upscaledimage.jpg -fx "abs(u[0]-u[1])" pgm:- \
  | identify -verbose pgm:- \
  | grep -E "mean|max|devi"

 
results

 
Big Buck Bunny

1920×1080 » (lanczos) 854×480 » 1920×1080

screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	640K
	bicubicResize	63 (0.247059)	1.39138 (0.0054564)	2.02799 (0.00795292)	564K
	bilinearResize	66 (0.258824)	1.41046 (0.00553122)	2.1246 (0.00833176)	568K
	blackmanResize	60 (0.235294)	1.32716 (0.00520453)	1.7842 (0.00699688)	584K
	lanczosResize	59 (0.231373)	1.32695 (0.00520371)	1.76561 (0.00692397)	588K
	lanczos4resize	58 (0.227451)	1.31528 (0.00515796)	1.73246 (0.00679397)	592K
	pointresize	138 (0.541176)	1.93816 (0.00760062)	3.38685 (0.0132818)	688K
	sincresize	97 (0.380392)	1.94942 (0.00764479)	3.12623 (0.0122597)	712K
	spline16resize	60 (0.235294)	1.34655 (0.0052806)	1.85531 (0.00727572)	580K
	spline36resize	58 (0.227451)	1.32948 (0.00521366)	1.78602 (0.00700402)	584K
	spline64resize	59 (0.231373)	1.3242 (0.00519292)	1.77446 (0.00695865)	584K
	nnedi3 (cshift=spline36)	59 (0.231373)	1.34151 (0.00526083)	1.76169 (0.00690858)	616K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	56 (0.219608)	1.34097 (0.0052587)	1.76592 (0.00692518)	620K
	spline36resize(hq4x)	81 (0.317647)	1.61154 (0.00631977)	2.08531 (0.00817769)	568K
screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	1100K
	bicubicresize	131 (0.513725)	2.01965 (0.0079202)	2.58451 (0.0101353)	716K
	bilinearresize	129 (0.505882)	2.06215 (0.00808685)	2.66154 (0.0104374)	724K
	blackmanresize	128 (0.501961)	1.92173 (0.0075362)	2.37666 (0.00932023)	744K
	lanczosresize	128 (0.501961)	1.91967 (0.0075281)	2.36059 (0.00925722)	752K
	lanczos4resize	128 (0.501961)	1.89933 (0.00744836)	2.33001 (0.00913729)	756K
	pointresize	173 (0.678431)	3.04469 (0.01194)	3.97362 (0.0155828)	924K
	sincresize	167 (0.654902)	2.94485 (0.0115484)	3.62896 (0.0142312)	920K
	spline16resize	128 (0.501961)	1.95451 (0.00766474)	2.44045 (0.00957039)	740K
	spline36resize	128 (0.501961)	1.92393 (0.00754484)	2.37922 (0.00933026)	744K
	spline64resize	129 (0.505882)	1.91636 (0.00751512)	2.36858 (0.00928855)	744K
	nnedi3 (cshift=spline36)	119 (0.466667)	1.94348 (0.00762151)	2.34163 (0.00918287)	776K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	112 (0.439216)	1.94203 (0.00761579)	2.34288 (0.00918778)	776K
	spline36resize(hq4x)	122 (0.478431)	2.19204 (0.00859625)	2.6589 (0.0104271)	744K
screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	732K
	bicubicresize	49 (0.192157)	1.32602 (0.00520009)	1.51821 (0.00595376)	572K
	bilinearresize	53 (0.207843)	1.33697 (0.00524301)	1.57944 (0.0061939)	572K
	blackmanresize	43 (0.168627)	1.29434 (0.00507583)	1.3829 (0.00542314)	592K
	lanczosresize	41 (0.160784)	1.29722 (0.00508715)	1.37439 (0.00538977)	596K
	lanczos4resize	41 (0.160784)	1.28806 (0.00505121)	1.35241 (0.00530357)	596K
	pointresize	144 (0.564706)	1.86225 (0.00730295)	2.74764 (0.010775)	692K
	sincresize	110 (0.431373)	1.85213 (0.00726325)	2.47998 (0.00972541)	708K
	spline16resize	44 (0.172549)	1.306 (0.00512158)	1.42527 (0.00558931)	584K
	spline36resize	43 (0.168627)	1.29596 (0.00508218)	1.38413 (0.00542798)	588K
	spline64resize	42 (0.164706)	1.29306 (0.00507082)	1.37745 (0.00540178)	592K
	nnedi3 (cshift=spline36)	39 (0.152941)	1.30354 (0.00511192)	1.36729 (0.00536193)	620K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	39 (0.152941)	1.30032 (0.00509928)	1.36227 (0.00534222)	624K
	spline36resize(hq4x)	77 (0.301961)	1.52609 (0.00598468)	1.58047 (0.00619794)	572K

 
Sintel

1920×818 » (lanczos) 1126×480 » 1920×1080

screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	620K
	bicubicresize	76 (0.298039)	1.22795 (0.00481549)	1.64521 (0.00645182)	444K
	bilinearresize	78 (0.305882)	1.22377 (0.0047991)	1.66566 (0.00653199)	440K
	blackmanresize	72 (0.282353)	1.23057 (0.00482575)	1.57433 (0.00617384)	464K
	lanczosresize	71 (0.278431)	1.2383 (0.00485609)	1.57933 (0.00619346)	468K
	lanczos4resize	70 (0.27451)	1.24825 (0.00489511)	1.59137 (0.00624068)	472K
	pointresize	106 (0.415686)	1.48345 (0.00581747)	2.42587 (0.00951323)	508K
	sincresize	88 (0.345098)	1.47682 (0.00579147)	2.15301 (0.00844318)	492K
	spline16resize	73 (0.286275)	1.2257 (0.00480666)	1.58467 (0.00621438)	460K
	spline36resize	72 (0.282353)	1.23204 (0.00483153)	1.57656 (0.00618259)	464K
	spline64resize	71 (0.278431)	1.23371 (0.00483806)	1.57686 (0.00618377)	464K
	nnedi3 (cshift=spline36)	70 (0.27451)	1.2102 (0.00474587)	1.53526 (0.00602061)	484K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	76 (0.298039)	1.20684 (0.00473269)	1.53277 (0.00601086)	484K
	spline36resize(hq4x)	77 (0.301961)	1.4199 (0.00556825)	1.62984 (0.00639155)	416K
screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	1200K
	bicubicresize	68 (0.266667)	3.90677 (0.0153207)	4.63845 (0.01819)	756K
	bilinearresize	72 (0.282353)	3.93428 (0.0154286)	4.70239 (0.0184407)	772K
	blackmanresize	70 (0.27451)	3.75073 (0.0147087)	4.45619 (0.0174752)	824K
	lanczosresize	69 (0.270588)	3.77025 (0.0147853)	4.47537 (0.0175505)	832K
	lanczos4resize	70 (0.27451)	3.80719 (0.0149302)	4.51547 (0.0177077)	832K
	pointresize	141 (0.552941)	5.41135 (0.021221)	7.10313 (0.0278554)	992K
	sincresize	113 (0.443137)	5.13697 (0.020145)	6.00752 (0.0235589)	880K
	spline16resize	70 (0.27451)	3.76273 (0.0147558)	4.47469 (0.0175478)	812K
	spline36resize	70 (0.27451)	3.75862 (0.0147397)	4.46286 (0.0175014)	820K
	spline64resize	70 (0.27451)	3.7603 (0.0147463)	4.46454 (0.017508)	824K
	nnedi3 (cshift=spline36)	75 (0.294118)	3.69705 (0.0144982)	4.36505 (0.0171178)	836K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	72 (0.282353)	3.68776 (0.0144618)	4.35658 (0.0170846)	836K
	spline36resize(hq4x)	68 (0.266667)	3.9761 (0.0155926)	4.64142 (0.0182016)	760K
screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	652K
	bicubicresize	102 (0.4)	1.61719 (0.00634193)	3.41673 (0.013399)	516K
	bilinearresize	113 (0.443137)	1.62747 (0.00638224)	3.50645 (0.0137508)	516K
	blackmanresize	103 (0.403922)	1.57874 (0.00619113)	3.1816 (0.0124769)	544K
	lanczosresize	107 (0.419608)	1.58978 (0.00623445)	3.1924 (0.0125192)	548K
	lanczos4resize	118 (0.462745)	1.60308 (0.00628658)	3.20413 (0.0125652)	552K
	pointresize	212 (0.831373)	2.33259 (0.00914742)	5.96943 (0.0234095)	612K
	sincresize	141 (0.552941)	2.18924 (0.00858526)	4.94182 (0.0193797)	588K
	spline16resize	102 (0.4)	1.58086 (0.00619945)	3.22538 (0.0126486)	536K
	spline36resize	104 (0.407843)	1.58196 (0.00620377)	3.18951 (0.0125079)	544K
	spline64resize	106 (0.415686)	1.58257 (0.00620615)	3.18302 (0.0124824)	544K
	nnedi3 (cshift=spline36)	99 (0.388235)	1.52185 (0.00596802)	2.96699 (0.0116352)	560K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	101 (0.396078)	1.52184 (0.00596802)	2.98155 (0.0116923)	560K
	spline36resize(hq4x)	106 (0.415686)	1.80159 (0.00706505)	3.38661 (0.0132808)	496K

Averaged

 
Elephants Dream

1920×1080 » (bicubic) 640×360 » 1920×1080

screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	696K
	blackmanresize	182 (0.713725)	5.15758 (0.0202258)	9.2996 (0.036469)	672K
	lanczosresize	181 (0.709804)	5.17115 (0.020279)	9.25688 (0.0363015)	676K
	lanczos4resize	180 (0.705882)	5.19959 (0.0203906)	9.21027 (0.0361187)	684K
	spline16resize	183 (0.717647)	5.21444 (0.0204488)	9.46563 (0.0371201)	672K
	spline36resize	182 (0.713725)	5.1683 (0.0202678)	9.30998 (0.0365097)	672K
	spline64resize	182 (0.713725)	5.16437 (0.0202524)	9.28429 (0.036409)	672K
	nnedi3 (cshift=spline36)	174 (0.682353)	4.71817 (0.0185026)	8.52777 (0.0334422)	724K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	176 (0.690196)	4.70834 (0.0184641)	8.60432 (0.0337424)	732K
screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	328K
	blackmanresize	62 (0.243137)	1.10186 (0.00432103)	1.69206 (0.00663553)	496K
	lanczosresize	63 (0.247059)	1.10822 (0.00434597)	1.68183 (0.0065954)	676K
	lanczos4resize	62 (0.243137)	1.11478 (0.00437168)	1.67341 (0.00656238)	504K
	spline16resize	62 (0.243137)	1.10619 (0.00433802)	1.73069 (0.00678702)	488K
	spline36resize	62 (0.243137)	1.10259 (0.00432386)	1.69271 (0.00663806)	496K
	spline64resize	63 (0.247059)	1.10177 (0.00432066)	1.68822 (0.00662046)	496K
	nnedi3 (cshift=spline36)	56 (0.219608)	1.08019 (0.00423605)	1.54706 (0.00606689)	524K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	52 (0.203922)	1.07437 (0.00421321)	1.53682 (0.00602673)	524K
screenthumbnail	method used	peak	average	standard deviation	filesize
	original	-	-	-	648K
	blackmanresize	131 (0.513725)	3.69918 (0.0145066)	6.33968 (0.0248615)	688K
	lanczosresize	128 (0.501961)	3.70108 (0.014514)	6.31411 (0.0247612)	696K
	lanczos4resize	127 (0.498039)	3.72408 (0.0146042)	6.30599 (0.0247294)	700K
	spline16resize	132 (0.517647)	3.74263 (0.014677)	6.43383 (0.0252307)	684K
	spline36resize	129 (0.505882)	3.7027 (0.0145204)	6.3419 (0.0248702)	688K
	spline64resize	129 (0.505882)	3.70227 (0.0145187)	6.33526 (0.0248442)	688K
	nnedi3 (cshift=spline36)	127 (0.498039)	3.39755 (0.0133237)	5.79667 (0.022732)	736K
	nnedi3 (cshift=spline36, pscnr=4, etype=1)	125 (0.490196)	3.39746 (0.0133234)	5.7985 (0.0227392)	740K

 
Averaged #2

first average result + picture 1 result + picture 2 result + picture 3 result / 4

 
visual results
At the top of this long article I already explained that visual results are very subjective; that is because things look differently on different screens (tft/crt/etc), also due to different brightness and similar settings. However, sometimes the visual difference is obvious. Here are some examples:

original	lanczos
spline36	nnedi3

 
Conclusion
What we can see, looking at the numbers, is that the higher the resolution of your source (or better, the more details the source has) the better upscaling works. If your source is too blurry, upscaling won’t work as good as it could. All scalers perform quite good (except for point and sinc, but that was to be expected). Spline16 performs worse than spline36 and spline64, for upscaling spline36 performs better than spline64. Lanczos and spline are quite similar the difference is very minimal, according to the numbers, lanczos performs better than spline; overall best resizer for upscaling is nnedi3. Another thing which you can see in the visual results above is that the nnedi3 image doesn’t have the stairs-effect.

If you have to decide which resizer (in avisynth) to use for upscaling, go this route:

nnedi3 > lanczos/lanczos4 > spline36 > everything else

MT Approach

Let’s first take a look at the multiple cores issue.

 3760 wdp       20   0 1573m  48m 6584 R   99  2.4   0:58.37 avs2yuv
 3761 wdp       20   0  104m  57m 1336 S    4  2.8   0:01.40 x264

What you can see here is simple – I’m running avisynth using

wine avs2yuv test.avs - | x264 --demuxer y4m --output output.264 -

avs2yuv has 99% CPU where as it should have 200% (taking both cores into account) and x264 needs only 4% cpu (because the avisynth script is way too slow for x264 to even notice) – And here we got our first problem. Let’s see if we can change that behaviour. So i installed MT() and played around.

• SetMtMode(2) doesn’t change this behaviour.
• MT(, threads=2) changes this behaviour

 3928 wdp       20   0 1574m 192m 6736 R  186  9.5   1:30.97 avs2yuv
 3929 wdp       20   0  105m  63m 1336 S    8  3.1   0:02.78 x264

The downside of this is, that MT() might be bad for quality, and it might not work for everything. However, let’s put this into real numbers now:

Intel(R) Core(TM)2 Duo CPU T7500 @ 2.20GHz, 1001 frames, FFmpegSource2 + TNLMeans(), 2 threads

• with MT encoded 1001 frames, 2.51 fps, 279.84 kb/s
• without MT encoded 1001 frames, 1.47 fps, 278.98 kb/s

AMD Athlon(tm) II X4 645 Processor (3,1 GHz), 1001 frames, FFmpegSource2 + TNLMeans(), 4 threads

• with MT encoded 1001 frames, 6.96 fps, 279.23 kb/s
• without MT encoded 1001 frames, 2.05 fps, 279.22 kb/s

AMD Athlon(tm) II X4 630 Processor (2,8 GHz), 1001 frames, FFmpegSource2 + TNLMeans(), 4 threads

• with MT encoded 1001 frames, 6.96 fps, 279.23 kb/s
• without MT encoded 1001 frames, 2.05 fps, 279.22 kb/s

I’d say that’s a good improvement and worth it.

Networking Approach

The networking approach has some flaws. For example: The Concept in Avisynth works like this: You’re filtering a video, you’re handing the clip to another box using TCPServer – After TCPServer you can’t do anything anymore (thus you can’t do TCPSource to get the clip back). This means, if you want to hand it back you have to run several avisynth instances, like this:

i.e.: box 1 instance 1 (10.0.0.1 port 7777) » box 2 (10.0.0.2) port 8888 » box 1 instance 2 (10.0.0.1 port 6666)

The next flaw is, this is still only linear processing, so it doesn’t matter how many boxes you add, if your boxes are equal in power a full encode will take just as much time as it would on one box, probably due to the networking a bit more. So this makes only sense, if you have expensive filters on a fast box and the rest on your slow box. However, we can try to work around that using Crop.

box1

FFMpegSource2()
_do_some_fast_filtering_
TCPServer()

box2

TCPSource().Crop() # take the upper half of the frame
do some filtering
TCPServer()

box3

TCPSource().Crop() # take the bottom half of the frame
do some filtering
TCPServer()

box1 instance2

top = TCPSource(box2)
bottom = TCPSource(box3)
StackVertical(top, bottom)

That’d be very basic threading. And it works fine. The problematic part is that some filters aren’t processing the edges – So you might have trouble at the edges where you cropped. Some Way to come around that, would be to crop 16px more and when setting it together, average those 16px or remove them completly.

Alltogether

Now you can use MT() also, of course if you hand your clip to another box. i.e.

TCPSource()
MT("filter", threads=x)
TCPServer()

But let’s see, what do i get when doing both?

Conclusion

Well well, i’m a bit disapointed, because the networking stuff is pretty complicated. Features i’m missing for example are giving filters from one box to another. i.e. some feature like:

TCPRun(“Filter1().Filter2().Filter3()”, “ip”, port, compression)

The way it’s currently done, i have to write scripts and place them onto the specific box. In Linux it’s even more complicated (no idea how the windows guys are doing that) i have to open the .avs in virtualdub in wine first, before i can connect to em using TCPSource. Thus the administrative part behind this magic is quite high.

Alright. First of all, some basics: GeneralConvolution takes an RGB Clip. RGB has 16 million colours (255 per channel, that means: 255 red, 255 green, 255 blue, and 255*255*255 = 16581375) – The Convolution thingy is processing each channel seperatly. You don’t even need to care.

Our first test movie is 1×5 pixel in resolution (let’s assume 0 0 255 0 0 which’d mean, the first 2 px are black, then a white px then 2 black ones – so in simple, a black movie with a white dot in the middle)

Now we can decide between a 3×3 and a 5×5 matrix. For simplicity we take a 3×1 matrix. A 3×1 matrix would be 0 0 1, a 5×1 matrix would be 0 0 0 0 1. So every value represents a pixel. Every pixel-value is done for every pixel in the movie. For the edges the outer px is mirrored. So you can look at it this way:

As you can see the result of our matrix is, that it just shifted the white dot 1px to the left. So: 1 0 0 would shift the image to the right. In the matrix you can have any value, negative and positive. I guess mostly used are 0 -1 and some positive value. We’ll come later to -1. Anyway. You’ve just seen how shifting via convolution works – lemme show you how to blur. You can do a simple blur by just doing a matrix of 1 1 1. However at this matrix we have to talk about something else, called “divisor”. Basically all values in your matrix are sumed to make the divisor. So a matrix of 1 1 1 means a divisor of 3. A matrix of 2 4 2 would make a divisor of 8. A matrix of -1 2 -1 would mean a divisor of 0 (here the divisor’s auto detection fails). Let’s take a look at a table which shows what it does. Still using 0 0 255 0 0 (our white dot 5×1 px video)

So you can see that instead of 0 0 255 0 0 we now have: 0 85 85 85 0 that means the white dot px value was copied 1px to left and right and reduced (which we can refer to as blurred). Not that difficult, or? By the way, that should be Blur(1.58) (so blur, with it’s max value).

Now, let’s take a look at a more complicated example. We want to do “unsharping” this is possible with a convolution. In simple you’d do a matrix like: -1 4 -1. That’s basically unsharping. However, unsharping at a white dot doesn’t make much sense, so we’re going to use another “video”. This time: 9x1px resolution represented by 100 100 150 200 200 200 150 100 100. Let’s look at the following table:

So, you can see that we get

100 75 150 225 200 225 150 75 100

from

100 100 150 200 200 200 150 100 100

which results in a sharpened image. The center is 200 (the value in the middle) around that it’s highering the brightness a bit (making it more white from 200 to 225) and before the 150 it’s lowering the brightness from 100 to 75, making it more black. What this does you can easily see in an image at wikipedia. Just take a look at:

http://en.wikipedia.org/wiki/File:Usm-unsharp-mask.png

You can see the black and the white, which looks like shadow in the bottom part of the picture? That’s exactly what we did here, and that’s exactly what unsharping is about. This “white” stuff is also called “halos” those nasty things everyone tries to remove.

However, we still didn’t finished understanding the matrices. What we did so far was: unsharping, shifting, bluring. Now i’ll give two examples for edge detection, and then we’ll have to talk about dimensions.

Video: 100 100 100 200 200 200 200 100 100 100
Matrix: 0 -1 1
Divisor: 1 (so.. none)
Result: 0 0 100 0 0 0 -100 0 0 0

Values above 255 are clipped to 255.
Values below 0 are clipped to 0. So -100 = 0

As you can see at the result, we’ve got a black image with just the edge selected. Though this is only detecting the left edges (the point is, it will cause edges in one direction to fall below 0). For both directions you have to use a 2dimensional matrix or mt_edge for example.

Now, let’s talk about dimensions. This is where it get’s difficult. With our 5×1 videos we just faced 1 dimensional matrices. However, we want to do 2 dimensional matrices because our video is 2d. So let’s take a look at a 2d video with a white dot in the middle:

That’s a 5×5 video. a 3×3 matrix would look like this:

This would do the same, as our 1d blur. You could change the blurring (shape) to produce less strong blurrying, for example like this:

If you run this twice, the first one should look a bit blocky, the second will be as strong as the original blur but it will look a bit different. So.. You can really do a lot with this. However, you have to keep in mind, while at 1d the matrix was done to the left, current and right px, it’s different now. now it’s applied to the surrounding px.

For example:

That’d be our unsharp mask in 2d. The matrix is applied to ALL surrounding px. That means: not just to left and right, and not just to top and bottom and left and right – it’s also applied to the top left, top right, bottom left, bottom right.

Apart from 2d convolution there’s also 3d convolution (a filter made for that) this one is working temporal (using the previous frame) which “might” be useful in very slow motion to improve things, tho in high motion it will create ghosting and thus might not be very useful.

I hope this article helps other people to better understand about this.

There are three things, which can be tuned easily to provide better colors: Brightness, Contrast, Saturation. Going a bit deeper, you could also handle the color-channels independently, for example if you convert the clip to RGB you could higher the saturation for the red channel, for the green channel and/or for the blue channel (so if you think theres too much blue, you’d just limit blue a bit without touching red and green). Apart from that, there are some more techniques which might be useful. For example color-enhancement – Sometimes you got dark parts in a picture (nearly black) – Such parts contain some information, for example there might be a table but you won’t see it. If you higher gamma/brightness you’ll start to see it. So yes, it’s there, even if you don’t see it. You got two options: a) you’re increasing brightness/gamma just in that black part to see more of the frame or b) you’re making it even darker (more black) and blur it a bit (to remove such information which you won’t see anyway) to enhance compressibility. So, as you can see, there’s a lot you can do to colors in a video. And believe me, that’s not all.

TV & PC

At a PC you got a range from 0 to 255 at the YUV signal. On a TV these are limited, at the luma component from 16 to 235 and for the chroma component 16 to 240. I don’t think that this is still important today, however, just to make sure (Because they’re causing problems with some tv sets / and well it’s an legacy thing out of analogue times), we should limit this accordingly. However, let’s take a look at some example:

You can see in the first histogram (the top thing) that there are brown borders on the left and on the right, these define the “invalid” parts. As you can also see on the left, there’s a bit in the invalid part (marked yellow), and also a bit on the right (not that easy to see).

ColorYUV(levels="PC->TV")

or

Limiter(16, 235, 16, 240)

The ColorYUV example leads to a more bright image / less saturation, we can correct this later. You can see that the histogram changed “noticable” with coloryuv – With Limiter the invalid ranges are just removed and nothing else changed. I’d prefer ColorYuv. However – Whatever you did, we got now good values for a TV (Always assumed, you want to be able to watch that video flawlessly on your TV)

Brightness & Contrast

As you can see on the histogram above (the coloryuv one) the white doesn’t start at the left brown bar. We need to change that by tuning off_y of ColorYUV. In case you’re using this to manually tune the colors, you don’t need to do the conversation (pc->tv) above. So start by doing:

ColorYuv(off_y=6, gain_y=0) 

and adjust off_y till there’s no yellow parts in the brown bar anymore. This should look like this:

Now you can see that a lot goes into the right brown bar, so we need to limit it there, too, you can do that by tuning gain_y, for example (the white stuff should always be between the brown bars):

ColorYuv(off_y=6, gain_y=-12)

This looks in my source like this:

Saturation / Hue

Changing the Saturation and Hue is way easier, though i’d recommend to not deal with it, except you got a very bad source. Because let’s imagine you’re noticing that some picture is way too red. You could now limit the red color a bit, by doing so “every” red would be limited in your movie, so some parts might look worse than before. Also highering red – Faces might look weird. So this is something you should try to avoid in my humble opinion. However:

You could use TweakColor to work on the colors. For example:

# just a wrapper around TweakColor not useful at all
function pseudoColors(clip input)
{
    # magenta: 20 - 80 (center: 50) - higher saturation of magenta with 1.2
    TweakColor(input, startHue=20, endHue=80, sat=1.2)
    # red: 80 - 140 (center: 110) - lower saturation of red with 0.5
    TweakColor(startHue=80, endHue=140, sat=0.5)
    # yellow: 140 - 200 (center: 170) - don't do anything
    TweakColor(startHue=140, endHue=200, sat=1.0)
    # green: 200 - 260 (center: 230) - higher green by 2.0
    TweakColor(startHue=200, endHue=260, sat=2)
    # cyan: 260 - 320 (center: 290) - make cyan greyscale/filter it out
    TweakColor(startHue=260, endHue=290, sat=0)
    # blue: 320 - 20 (center: 350) - do nothing
    TweakColor(startHue=320, endHue=20, sat=1)

    return last
}

Instead of “sat” you might also use bright cont and hue. For example: There’s something yellow in your video, which should be green. So you want to shift the hue of “yellow” to “green”. Negative values in “hue” will do that. For example (not tested):

# selected yellow with start and endhue, and shifting hue to -50, negative values -> green, positive values -> red
TweakColor(input, startHue=140, endHue=200, hue=-50)

You see, there’s much you can do, you could even just remove some annoying colors. The usual way of doing such tuning is watching the video and looking for parts which seems to have wrong colors. Tuning them, and making sure it doesn’t make any other frame worse.

Automatism

However, the above stuff needs to be applied to every frame; you need to find out the brightest and the darkest frame in the whole movie, and tune the settings accordingly. so with these settings you can make some frames too bright and some not bright enough; something which does this automatically would be cool, hm? Well, i’m using “autolevels” for that, which does a quite good job if you feed it with many frames. It’s default value (5) isn’t very useful in the source i’m using here, while a value of 50 gives very good results. Take a look at the histogram:

Autolevels got a few problems though; due to the automatism weird light(ning) effects occur sometimes and on real dark frames like a star-field it makes the whole black into grey – So while it might be good for some sources, for most of the sience-fiction movies you probably have, you should look at it skeptical

Enhancing

there are three other plugins, which might be useful to you, when dealing with colors:

1. HDRAGC – Enhances Shadows (I never got good settings with it for my sources)
2. ExpLabo – Can be used for Color Correction (haven’t tried it yet)
3. FilmYlevels – Gives a filmish look (haven’t tried it yet)

Haven’t tried it yet means, the screenshots looked promising, but well as you might (or should) know, screenshots are.. hehe. Usually optimized for a specific source; it’s simply not a good way to say something’s good or bad just because of a awesome good screenshot.

Update: I tried ylevels and flimylevels today, it seems those things are most useful on anime and not really useful on “normal” video, because of the light-changes. If you use one of those (also hdragc, even if its lower there) it might well be that you notice a fading light from frame to frame (which looks bad) with autolevels the frames get a bit over-saturated, too – So finding good values is not that easy. autolevels has the advantage of using many frames, thus you can reduce the noticeable lighting. So.. Well, you have to check yourself. For very bad old sources this might be good, for anime this might be good also, for everything else.. Be skeptical and use your eyes.

Making White really White

At one old movie i noticed that they used a white paper to simulate “lightning” the thing which occurs at a thunder. So they hold a white paper in front of the camera for one or two frames – At the bottom right edge this was noticable because there’s a curve. Here’s a screenshot:

So instead of using that it might be useful to turn such a frame into real white. Like saying: If 95% of the Screen is white, make it real white or something like that. Kuukuunen (thanks once again!) helped me a bit to get something which is doing that. There’s also a Thread which he wrote regarding “Understanding YUV, Luma, Luminance” because there are some problems with greyscale -> i linked his thread at the bottom. Here’s by the way the function which would do the above:

function turnWhite(clip v, int "threshold")
{
    threshold = default(threshold, 235)
    v.converttorgb()
    grayscale()
    converttoyv12()
    conditionalfilter(last, blankclip( v, pixel_type="YV12", color_yuv=$FF8080 ), v, "averageluma()", ">", string(threshold))
}

play around with threshold and test for yourself. A value of 200 did what i wanted at the frame, i guess highering this would be possible, haven’t tried yet. Try to make the threshold as high as possible to not cause any false-positives. Whether thats useful or not you have to decide yourself; in fact as those are only 1-2 frames, you wouldn’t notice in normal motion. You should only notice this in slowmotion (like playing it with mplayer and using the dot to look at it frame by frame) however, it MIGHT enhance compressibility.

Other useful information

• Videotuning
• Postprocessing Avisynth.html (scroll down to: 7.2.9 Color adjustment)
• Understanding YUV, Luma, Luminance

If you run Lunar Linux like I do, you want to update first, followed by installing wine, if not already done. In Debian you’d do something like “apt-get update” .. “apt-get dist-upgrade” .. “apt-get install wine”.

# retrive updates/new versions
lin moonbase; lin theedge

# install wine
lin -cr wine

When I initially wrote this article, I was using wine 1.2.2. Currently I’m using version 1.2.3. Right after installing wine, download required files:

Requirenments

• DirectShowSource_2588.zip
• Avisynth_258.exe
• DevIL-EndUser-x86-1.7.8.zip
• fftw3win32mingw.zip
• fftw-3.3-dll32.zip
• avs2yuv.exe

cp DirectShowSource.dll .wine/drive_c/Program\ Files/AviSynth\ 2.5/plugins/DirectShowSource.dll
cp DevIL.dll .wine/drive_c/windows/system32/devil.dll
cp ILU.dll ILUT.dll .wine/drive_c/windows/system32/
cp fftw3win32mingw/fftw3.dll .wine/drive_c/windows/system32/
cp libfftw3-3.dll libfftw3f-3.dll libfftw3l-3.dll .wine/drive_c/windows/system32/
cp avs2yuv.exe .wine/drive_c/windows/system32/

You should have all basic things which might be needed now. I’d suggest you to step through the import-filters on avisynth’s external-plugins page and install those, you might need. If such a tool comes with .exe files (like ffmpegsource’ ffindex.exe) I’d suggest you to place them into .wine/drive_c/windows/system32 because then they’ll be in wine’s PATH and issuing “wine ffindex.exe” will just work without the hassle to write down the whole path all the time.

Now you’re able to encode videos with avisynth. Here’s an example:

wine avs2yuv test.avs - | x264 --stdin y4m --crf 0 --fps 25 --output output.264 -

Troubleshooting
You might get one or some of the following errors:

Avisynth error: AVISource: couldn't locate a decompressor for fourcc xvid

Time to get winetricks from here.

# Now make it executable using:
chmod a+x winetricks

# and install some codecs:
./winetricks allcodecs

Another error:

Avisynth error: No compatible ACM codec to decode 0x2000 audio stream to PCM.

If you get that error, just use another Source filter, for example DirectShowSource() instead of AviSource(). Or you might use FFmpegSource.

fixme:actctx:parse_depend_manifests Could not find dependent assembly L"Microsoft.VC80.CRT" (8.0.50727.762)
err:module:import_dll Library MSVCP80.dll (which is needed by L"C:\\windows\\system32\\DevIL.dll") not found
err:module:import_dll Library DevIL.dll (which is needed by L"C:\\windows\\system32\\avisynth.dll") not found
failed to load avisynth.dll

Some plugins and above dll’s need a few things which you might obtain by winetricks. For example:
winetricks -> select the default wineprefix (whatever they mean by that) -> install a windows dll or component -> tick vcrun2003, vcrun2005 and vcrun2008

Another hint: use WINEDEBUG=”-all” in front of wine or create a bash script for that. It will remove wine’s debug output, a nice bash script could be this one:

avisynth.sh

#!/bin/bash
#
#  avisynth/avs2yuv/wine wrapper
#
#  Syntax:
#    avisynth mode script.avs [output.264] [parameters]
#  Modes:
#    lossless (pipe to x264)
#      --crf 0
#    normal (pipe to x264)
#      --preset slower --tune film --ref 6 --bframes 5
#      --b-adapt 2 --direct auto --crf 18 --me umh
#      --subme 8 --trellis 2 --weightp 0
#    user (pipe to x264)
#    display (output using mplayer (realtime playback)
#    picture (output to /dev/null)
#  Explaination:
#    lossless and normal should be obvious, normal uses
#    the settings I'm usually using, you might want to
#    change them below. picture is a special case: sometimes
#    I'm using ImageWriter and thus I don't need x264 or
#    a pipe. You can use "user" to set your own settings.
#    display will just let mplayer
#    display the movie - useful for realtime playback.
#  Examples:
#    avisynth display test.avs
#    avisynth lossless test.avs myfile.264 "--fps 50"
#    avisynth picture test.avs
#    avisynth user test.avs output.264 "--preset placebo --fps 25"
#

# general x264 parameters
genparm="--stdin y4m --thread-input"
# parameters for the normal/my usual x264 encode
normparm="--preset slower --tune film --ref 6 --bframes 5 --b-adapt 2 --direct auto --crf 18 --me umh --subme 8 --trellis 2 --weightp 0"

mode="$1"
avsf="$2"
outf="$3"
parm="$4"

if [ -z "$mode" ]; then
  echo " + Error: Mode needs to be given (display, lossless, normal, none, picture)";
  exit 1;
fi

if [ -z "$avsf" ]; then
  echo " + Error: AVS needs to be given (path to your .avs file)";
  exit 1;
fi

#
# x264 encoding
#
if [ "$mode" == "lossless" ] || [ "$mode" == "normal" ] || [ "$mode" == "user" ]; then
  if [ -z "$outf" ]; then
    echo " + Error: Given mode requires an output filename";
    exit 1;
  fi
  if [ "$mode" == "user" ]; then
    if [ -z "$parm" ]; then
      echo " + Error: Given mode requires additional parameters";
      exit 1;
    else
      x264="$genparm $parm"
    fi
  elif [ "$mode" == "normal" ]; then
    x264="$genparm $normparm $parm"
  else
    x264="$genparm --crf 0"
  fi
  WINEDEBUG="-all" wine avs2yuv $avsf - | x264 $x264 --output $outf -
else
  #
  # mplayer display
  #
  if [[ "$mode" == "display" ]]; then
    WINEDEBUG="-all" wine avs2yuv "$avsf" - | mplayer -cache 2048 -noidx -
  #
  # picture part
  #
  elif [[ "$mode" == "picture" ]]; then
    WINEDEBUG="-all" wine avs2yuv "$avsf" -frames 1 /dev/null
  else
    echo " + Error: mode not implemented (yet?)";
    exit 1;
  fi
fi

That’s all about it