Victor%27s Video Scaler Cook Book

Video Scaler CookBook Victor Ramamoorthy Software Engineering Group Information Appliance National Semiconductor Corp Santa Clara, CA 30 October 2002

________________________________________________________________________ Video Scaler CookBook Victor Ramamoorthy Page: 1 (30) 10/13/2004


Contents Video Scaler CookBook ..................................................................................................... 1 Video Scaler Cook Book .................................................................................................... 3

Introduction..................................................................................................................... 3 Performance of a Video Scaler ....................................................................................... 4 Scaling Fundamentals ..................................................................................................... 6

Example ...................................................................................................................... 7 Linear Interpolation .................................................................................................... 8

Choosing a better predictor............................................................................................. 9 Mirroring Pixels ............................................................................................................ 11 Implementing the Interpolating Filter........................................................................... 11 Putting It All Together .................................................................................................. 14 Finally ........................................................................................................................... 15 Tables............................................................................................................................ 17

Video Scaler Cook Book

Introduction Video Scaler is a device that stretches or shrinks images or video frames. For the purposes of illustration, we have a source image as shown below:

Source Image When expand the size of the image, the total number of pixels contained in the destination image is more than what is available in the source image. Hence a whole lot of new pixels have to be created by the scaler. When we shrink the image, we may keep a part of the pixels and throw the rest. In addition, we may still have to generate new pixels even if we are shrinking the image. The scaler’s job is simple: (1) It decides what pixels to keep in the source image and (2) what pixels have to be recreated. In this cookbook we will explore the scaler’s anatomy.

Destination Image: Shrinking Note that a scaler can stretch an image only in X direction or only in Y direction or both. We want to design a scaler that can achieve arbitrary1 image sizes without noticeable quality loss. There is no restriction to keep the aspect ratio2 as constant while scaling.

1 Arbitrary sizes, memory size permitting, filter lengths conducive.


2 The ratio of width and height of an image is called the aspect ratio.

Destination Image: Expansion No distinction is made between shrinking and expansion of an image as far as the scaler algorithm is concerned. They are the opposite sides of the same problem. The scaler will operate exactly the same way if we are expanding or squeezing the source image. This cookbook describes the process with which smooth expansion/contraction scaling is obtained. It also details the construction of a hardware system, which can operate at video frame rates. In particular, the focus of the treatment is to spell out the different parameters that control the performance of the scaler. This cookbook is aimed at engineers who are not familiar with video scaling problem. Experts on the subject are warned that they may be wasting their time reading this cookbook. Many of the theoretical issues are merely glossed over and the attention is centered on the implementation. Useful tables at the end contain filter coefficients that can be used in a practical situation.

Performance of a Video Scaler As with any engineering design, we have to ask critical questions like “what are we designing and how do we know it is good”. When it comes to video scaler, that kind of questions are tough to answer because the quality of the end result simply cannot be measured. Video quality is a subjective thing. It varies with the content and viewing conditions. More importantly, when we scale video frames, there is no reference to compare. We are creating a new frame that was not there before, and we have to compare it with the original frame with a different size. It is like comparing apples and oranges. The best way to get around this problem is to ask if the scaled frame “looks” like the original and hunt for artifacts that might have crept in the scaling process. Still we are looking for something that has no reference and has some how appeared on the end result – which is not a good way to measure performance. So we come back and settle down to the measurement of “how it looks” after scaling.


The primary performance measure is undoubtedly the visual quality of the scaler. In general, visual quality is not easily measured by metrics such as Picture Signal-to-Noise Ratio and Mean Square Error, though they are often quoted in the literature. The secondary performance measures are Computational Load or Complexity of Design. We will attempt to quantify these measures wherever meaningful. Another thing to remember is that performance is a function of color conversion stages employed. For instance, if the source image is RGB, see fig. 1 below, the scaling can be done in the RGB domain. Notice that scaling is done on the component images. If the image is only available as YUV domain then scaling can be done in YUV domain as in fig.2:

R

G

B

Scaler

Scaler

Scaler

R

G

B

Source Image

Destination Image

Fig.1

Y

U

V

Scaler

Scaler

Scaler

Y

U

V

Source Image

Destination Image

Fig.2

_______________________________________________Video Scaler CookBook Victor Ramamoorthy 10/13/2004

Fig. 3 As suggested by fig.3 above, the color conversion can be included in the last stage before destination image is displayed. Or it also can be done before scaling as shown below:

R

G

B

Scaler

Scaler

Scaler

DestinationImage (YUV)

R

G

B

Source Image (RGB)

Color Conversion

YY

U

V

Color Conversion

Source Image (RGB)

Fig.4

Scaler

UDestinationImage
Scaler
V(YUV)

Scaler

_________________________ Page: 5 (30)

The performance of the system in fig.3 and fig.4 will in general be different. Because of additional operations involved with color conversion, there is ample opportunity to inject additional noise in the system. However, by careful choice, we can make the visual qualities of these two systems to approach each other. Another important thing to note is that the scaler operates on Planar images. A planar image could be an image containing just red color, or Y values. It is a component image. Repeating the scaling on all other component images does complete scaling.

Scaling Fundamentals Let be the size in the X direction and Y direction respectively of a planar source

image. Let the corresponding sizes of the destination image be . This means that

the source image has pixels in a row, which must be converted to pixels in the destination image. The ratio of these two numbers is called scaling factor

yx ss,

yx dd,

xs xd

xxS

s

dx = . (1)

Similarly the scaling factor in the Y direction is yy

Ss

dy = . Note that the scaling factor

is the ratio of two integers and is hence a real (floating-point) number. We will just illustrate the method for scaling in the X direction in this cookbook as the same kind of operations can be duplicated for Y direction. The key idea here is to expand the source size range to include floating point numbers. What is the size range? Well, it is the set of integers I S

x ={0, 1, 2, 3, … -1} which denote the pixel positions

xs3 in the X direction of the source image. The first pixel position

starts at 0. The last one ends at -1. We can expand this range to contain all real numbers – not just integers. Note that this is our mental construct and not a real thing. When everything is finished we will map this back into integers, as a pixel position cannot be a fractional number. Let us denote this new range as containing all

numbers from 0 to -1.

xs

RSx

xs

Now we are ready to map the destination pixel positions back onto the source pixel positions, i.e., mapping onto the range . Why is this needed? We have the job of generating new pixels in the destination image and they must have the resemblance of the source image. We need to know where to place these new pixels. We also need to know

RSx


3 We are talking about pixel positions which are sequential numbers starting at 0 from left. Do not confuse this with the value of a pixel. We will use the notation V(.) to denote the value of a pixel.

their values. Because we only know about the source image and know nothing about the destination image, we must make the connection between these two. We need to derive the destination pixel values from the source image. We can do that only if we know where these pixels are located.

From (1), we see that Sxx

x

ds = . Then the mapping of destination range back to

become: {0,

RSx

,1

S x

,2

S x

,3

S x

… S

xx

d1−

}. Out of this set, we will force that pixel position

at 0 will map onto pixel position 0. The other end condition is also forced: the pixel position at -1 will go to the pixel position at -1. This means that for i-th pixel,

, position of the destination image falls on the position

xd xs

01 >>− ixd S x

i in the expanded

range of the source image. The position RSx S x

i is a real number and not an integer.

That is why we expanded the range to include real numbers in the first place! The next

thing to do is to find where exactly the position S x

i is located.

To do this, we need to find the integer part of S x

i . This is also known as the F-center4,

]][[)(SF

xc

ii = . The fractional part is denoted by ))(()(Sf

xc

ii = . This means that the

i-th pixel position of the destination image falls in between source pixels in positions )(iF c and )(iF c + 1 and is fractional value off from the F-center )(if c

)(iF c . Are you with me? Let us do an example and clarify the notation.

Example Let the source X size be 4 pixels and the destination X size is 7 pixels. That is = 4

and = 7. The source pixel positions are denoted by {0, 1, 2, 3} and the destination pixel positions are denoted by {0, 1, 2, 3, 4, 5, 6}.

xs

xd

The scaling factor is 75.147===

xxS

s

dx . Let us now map onto the expanded range of

source image.


4 The F-center is actually the pixel on which the filter is centered. You will get it later. Keep cool.

Destination Pixel Position

Map onto Source Range

F-Center )(iF c

Fractional Part )(if c

Notes

0 0 0 By design this will map onto pixel at 0

1 0.5714 0 0.5714 2 1.1426 1 0.1426 3 1.7143 1 0.7143 4 2.2857 2 0.2857 5 2.8571 2 0.8571 6 3 3 By design, this

will map onto pixel at 6

Hence the simplest way to scale from 4 pixels to 7 pixels is to do the following: Value of pixel 0 at destination = Value of pixel 0 at the source (end condition) Value of pixel 1 at destination = Value of pixel 0 at the source Value of pixel 2 at destination = Value of pixel 1 at the source Value of pixel 3 at destination = Value of pixel 1 at the source Value of pixel 4 at destination = Value of pixel 2 at the source Value of pixel 5 at destination = Value of pixel 2 at the source Value of pixel 6 at destination = Value of pixel 3 at the source (end condition) We wanted 7 pixels and we got them all. Unfortunately such a simple minded scaling does not offer good visual quality!

Linear Interpolation What can we do better? Since we know the fractional values of the pixel positions, we can put them to work. This is called as Linear Interpolation. This can be illustrated as follows: Value of pixel 0 at destination = Value of pixel 0 at the source (end condition) Value of pixel 1 at destination = Value of pixel 0 at the source x (1.0 – 0.5714) + Value of pixel 1 at the source x 0.5714 Value of pixel 2 at destination = Value of pixel 1 at the source x (1.0 – 0.1426) + Value of pixel 2 at the source x 0.1426 Value of pixel 3 at destination = Value of pixel 1 at the source x (1.0 – 0.7143) + Value of pixel 2 at the source x 0.7143 Value of pixel 4 at destination = Value of pixel 2 at the source x (1.0 – 0.2857) + Value of pixel 3 at the source x 0.2857 ________________________________________________________________________ Video Scaler CookBook Victor Ramamoorthy Page: 8 (30) 10/13/2004

Value of pixel 5 at destination = Value of pixel 2 at the source x (1.0 – 0.8571) + Value of pixel 3 at the source x 0.8571 Value of pixel 6 at destination = Value of pixel 3 at the source (end condition) The above can be succinctly written for the middle pixels as:

)())1)((()}(1)){((())(( iiViiViV fFxfFxx ccsccsd++−= (3)

Where V(. ) denotes the value of a pixel. This may be considered as an improvement over the case where we just copied pixels. Using the fractional part indeed helps in improving the quality. However the quality improvement with adjacent pixel linear prediction is not very great. The next big improvement can occur if we can extend the linear prediction idea and concoct a workable system.

Choosing a better predictor The previous section explained the notion of using two adjacent pixels in defining the value of a new pixel that falls in between. This is equivalent to using just a 2-tap linear filter with varying filter coefficients. Getting to know additional pixels is only good5. But there is a big problem. Since the fractional part can assume any value between 0 and 1, extending to multi-tap filter has inherent computational problems: Depending on the value of the fractional part, we need to design a filter for every pixel! A better idea is to quantize the fractional part to M regions and choose an appropriate filter from the stored set of filter coefficients. It is a common practice to use M as a power of 2, but is not necessary. The quantized fractional part )()( ˆ iiQ ff

cc= now takes values from 0 to M-1. For

each value, a different set of filter coefficients will be used to predict the pixel value. What would be an ideal filter to use? That is a separate topic by itself. We would not go into details as ample texts cover the subject of digital signal processing. It is suffice to say that optimal interpolation filter has an impulse response described by the Sinc function:


5 Recall the statistical motto: The more you know, the better you compute the estimate.

)(

)sin(

MkMk

π

π

for k = … -2, -1, 0, 1, 2, … and M is the number of

quantization levels used. Corresponding time response of the PolyPhase Interpolation Filters is given by:

nM

Mn

Mn

nhnh all and ,1,...3 ,2 ,1 ,0 ,)(

)](sin[)()(~

−=+

+== ρ

ρπ

ρπ

ρ (4)

The direct way designing a scaler is to use the above equation and truncate the ideal prototype given in (4). Unfortunately this leads to ringing and Gibbs phenomenon, which can be visually disturbing in the end result. A better way is to taper the filter coefficient gradually to zero with a windowing function as shown below: )(kw

21

21- ),()(~)( −

≤≤−= NkNkwkhkh (5)

There are a number of windows shown to have good properties in handling Gibbs phenomenon. Here we use a generalized Hamming window given by

2

1 2

1 ,Otherwise 0

2cos)1()( −≤≤

−−

⎪⎩

⎪⎨⎧

⎥⎦⎤

⎢⎣⎡−+=

NkNN

kkwH

πγγ (6)

where γ is in the range 10 ≤≤ γ . If γ =0.54, the window is called a Hamming Window, and if γ = 0.5, it is called a Hanning Window. The filter coefficients given by equations (4), (5), and (6) are still real numbers. They need to be quantized to digital numbers to operate in a digital filter. As far as you, the reader, is concerned you do not need to worry about the above equations and theoretical stuff. We give you all these in the form of tables which you can readily use without losing sleep. Though most scalers use odd-number of filter taps, here we use even number filter taps. The reason is that odd-numbered filter taps generate phase switching noise– unless they are big enough –and we suggest looking into a nicer solution of even-numbered filter tap designs.



ig. 5

ince images have finite support – that is, finite width and height – employing filtering is

hat happens if you do not do mirroring? Nothing. Except that you end up with a black

Implementing the Interpolating Filter

irst let us see how to design a Finite Impulse Response filter for scaling. The theory of

Mirroring Pixels

Source Image

FEDCBAABCDEFGHIJKL

Mirrored border

F Sa little tricky. To alleviate the “border” problems, an artificial border is created around the source image by mirroring the pixels both column-wise and row-wise. With mirroring filtering can start right at the image edge and stop at the corresponding edge on the other side. Each row of pixels is extended as shown in fig.5 as if there is a mirror right on the border to reflect the pixels. The width of the border is related to the half-length of the filter used. Fig.5 illustrates the case when 6-pixel border is created with mirroring. Wborder on your destination image!

Fthe filtering was covered in a previous section. The section “Tables” give a set of filters that can be used in practice. Here let us construct a simple 6-tap filter system, see table 8. The next figure illustrates how a filter works on the source image to produce the content of the destination image.

The table chosen has 6 filter coefficients depending on the quantized value of the fractional part )()( ˆ iiQ ff

cc= . The integer part, )(iF c selects the center pixel in the

source image, which will support the filtering in the immediate neighborhood. In the case of 6-tap filter, 2 pixels before and 3 pixels after the center pixel form the six pixels that will be used in the creation of the corresponding destination pixel as shown in the fig 6.


Fig.6 Since the filter uses 12 bits of coefficient precision, dividing the sum (formed by the filter coefficients and the pixel values) by 4095 normalizes the product sum. This leads to the destination pixel value of 6. This type of Finite Impulse Response filtering is routinely done in DSP applications. Over the years, the hardware required for filtering has been almost standardized. A DSP engine is constructed by having a multiplier, adder, shifter and coefficient RAM. Coefficients are first loaded into the RAM before operations begin. The multiplier typically has two registers for loading the multiplicands. After values are multiplied, they are added with the previous sum. Appropriate shifting is needed for normalization to avoid overflow.



Putting It All Together

the time to assemble all the previous knowledge and put them to work. Fig. 7 the micro architecture of the scaler. It uses all the familiar digital building blocks

A Register

B RegisterX

16

16 Adder 3

32

Shifter 2

32

16

16

Load

Destination ImageFrame Buffer

Overflow

MirroredSource Image Frame Buffer

8

8

16

16

Coef. RAM

Video Scaler Micro Architecture

Adder 1

Frac. Reg16

Adder 2

Int. Reg

Load16 16

Address

Shifter 1

IRFR

Log M

DSP

Fig. 7 Now is

ows shlike multipliers, adders, and shifters. Details of clocking are not shown in fig.6 for the sake of clarity and brevity.

First going back to our notation, we need to compute the scaling factor xxS d= . It must

sx

al part ofbe computed by another entity controlling the scaler. In fact, what we need is just the reciprocal of the scaling factor: we separate the integer and fraction the

))1((]]1[[1

SSS xxx

+= . Why do we do this? Our goal is to compute S x

i . This can be by a

parate fractional and integer parts and add them p as we increase i.

Note that

pair of adders if we se u

))1((]][[SSS xxx

. The integer part is already a whole number. We can 1 iii+=


nteger part into the 16lied by 65536 to m

ent of the Integer register is loaded into 16-bit Adder 2. This behavior

e overflow, which will be an address of the source

the DS engine shown in fig.6. The

-bit output, and a 32-bit adder called Adder 3. The output of Adder

r taps used.

e have the theory. We have the architecture. We have the tables. Next thing is to put od use. To help in the design process, we have a Video Scaler Design Tool as

load this i -bit Integer Register IR. The fractional part is a real number is multip ake that into a 16-bit number and then is loaded into the Fractional Register FR. These loadings are done as a part of initialization. The coefficient RAM also needs to be filled with correct numbers before the scaling operations begin. Note that the content of the Fractional Register is also loaded into 16-bit Adder 1. Similarly the contof loading Adder 1 and Adder 2 will be repeated for every pixel in the destination image. In addition, note that Adder 1 feeds back into itself while supplying its output as an address to the Coefficient RAM. To get the correct address, we need the Shifter 1 to drop all bits except what is needed to generate the right filter coefficients. Hence if we use a M level quantization of the fractional part, then we just need Mlog2

bits for the address in

selecting the correct filter coefficients in the coefficient RAM. Since Adder 1 feeds back its output into its input, it will generatadded as input to Adder 2. Adder 2 has its output pointing topixel being operated on. If the scaling is being performed for X direction, then the Adder 2 output will be a number representing the column of the pixel. If the scaling is done in Y direction, this will be the row number of the pixel. How does the interpolation work? First we need to load the pixel value from the mirrored source image buffer into A Register of P corresponding filter coefficient is taken from the coefficient RAM and loaded into B Register of the DSP. The DSP engine consists of 2 16-bit registers (called A Register and B Register), a 16 bit full multiplier with 323 is fed back to its input. When computations are completed, the Shifter 2 scales the output to 8 bit and sends it to the destination location. The clocks governing the DSP engine run p times faster than the clock governing Adder 1, Adder 2, and Shifter 1, where p is the number of filte The rest is, as the saying goes, elementary.

Finally Wthem to goshown in the fig.8. This tool allows one to change all the pertinent parameters and arrive at a useful design that satisfies the design goal.

Fig.8 Figure 8 shows the GUI of the tool. It accepts BMP files and scales the input on the fly. The first combo box allows the selection of M (Inter Pixel Quantization) in bits. The second combo box offers selection of number of bits used in representing each filter coefficient. The third combo box selects the number of filter taps. The fourth one selects the window. When the “Input File” button is clicked, a pop up window helps in choosing an input BMP file. A thumbnail of the chosen file appears in the small picture box below. By operating the sliders around the picture box, one can scale the input both in X and Y direction.



Tables Here we provide an illustrative set of filters useful in scaling: Table 1: 4 tap Filter; M = 16; Coefficient length = 8 bits; Hamming Window Filter 0 0 255 0 0Filter 1 -7 252 10 0Filter 2 -12 246 22 -1Filter 3 -15 235 37 -2Filter 4 -17 221 55 -4Filter 5 -16 202 73 -4Filter 6 -15 181 95 -6Filter 7 -13 160 116 -8Filter 8 -11 138 139 -11Filter 9 -8 115 161 -13Filter 10 -6 94 182 -15Filter 11 -4 72 203 -16Filter 12 -4 55 221 -17Filter 13 -2 37 235 -15Filter 14 -1 22 246 -12Filter 15 0 10 252 -7 Table 2: 4 tap Filter M = 16; Coefficient length = 9 bits; Hamming Window Filter 0 0 511 0 0Filter 1 -15 507 20 -1Filter 2 -25 494 45 -3Filter 3 -31 472 75 -5Filter 4 -33 442 109 -7Filter 5 -33 405 149 -10Filter 6 -31 366 190 -14Filter 7 -27 322 234 -18Filter 8 -23 278 279 -23Filter 9 -18 233 323 -27Filter 10 -14 189 367 -31Filter 11 -10 148 406 -33Filter 12 -7 108 443 -33Filter 13 -5 75 472 -31Filter 14 -3 46 493 -25Filter 15 -1 21 506 -15 Table 3: 4 tap Filter M = 16; Coefficient length = 10 bits; Hamming Window Filter 0 0 1023 0 0Filter 1 -30 1015 40 -2


Filter 2 -51 989 91 -6Filter 3 -62 944 150 -9Filter 4 -68 885 221 -15Filter 5 -68 815 298 -22Filter 6 -64 735 382 -30Filter 7 -56 648 469 -38Filter 8 -48 560 559 -48Filter 9 -38 469 648 -56Filter 10 -30 382 735 -64Filter 11 -22 297 816 -68Filter 12 -15 220 886 -68Filter 13 -9 149 945 -62Filter 14 -6 92 988 -51Filter 15 -2 41 1014 -30 Table 4: 4 tap Filter M = 16; Coefficient length = 11 bits; Hamming Window Filter 0 0 2047 0 0Filter 1 -60 2032 80 -5Filter 2 -102 1979 182 -12Filter 3 -126 1891 302 -20Filter 4 -137 1773 442 -31Filter 5 -137 1632 597 -45Filter 6 -128 1471 765 -61Filter 7 -113 1299 940 -79Filter 8 -97 1121 1120 -97Filter 9 -79 940 1299 -113Filter 10 -61 764 1472 -128Filter 11 -45 597 1632 -137Filter 12 -31 442 1773 -137Filter 13 -20 301 1892 -126Filter 14 -12 183 1978 -102Filter 15 -5 81 2031 -60 Table 4: 4 tap Filter M = 16; Coefficient length = 12 bits; Hamming Window Filter 0 0 4095 0 0Filter 1 -121 4066 161 -11Filter 2 -205 3960 364 -24Filter 3 -254 3784 606 -41Filter 4 -276 3549 885 -63Filter 5 -275 3266 1195 -91Filter 6 -257 2945 1530 -123Filter 7 -228 2599 1882 -158Filter 8 -195 2243 2242 -195Filter 9 -158 1882 2599 -228Filter 10 -123 1530 2945 -257Filter 11 -91 1196 3265 -275


Filter 12 -63 886 3548 -276Filter 13 -41 605 3785 -254Filter 14 -24 365 3959 -205Filter 15 -11 162 4065 -121 Table 5: 4 tap Filter; M = 32; Coefficient length = 8 bits; Hamming Window Filter 0 0 255 0 0Filter 1 -4 255 4 0Filter 2 -7 253 9 0Filter 3 -10 251 15 -1Filter 4 -12 246 22 -1Filter 5 -14 242 29 -2Filter 6 -15 235 37 -2Filter 7 -15 227 45 -2Filter 8 -16 219 54 -2Filter 9 -16 211 63 -3Filter 10 -15 201 73 -4Filter 11 -15 191 84 -5Filter 12 -14 181 94 -6Filter 13 -14 171 105 -7Filter 14 -13 160 116 -8Filter 15 -12 149 127 -9Filter 16 -10 137 138 -10Filter 17 -9 126 150 -12Filter 18 -8 115 161 -13Filter 19 -7 104 172 -14Filter 20 -6 93 182 -14Filter 21 -5 83 192 -15Filter 22 -4 72 202 -15Filter 23 -3 62 212 -16Filter 24 -2 53 220 -16Filter 25 -2 44 228 -15Filter 26 -2 37 235 -15Filter 27 -2 30 241 -14Filter 28 -1 22 246 -12Filter 29 -1 16 250 -10Filter 30 0 10 252 -7Filter 31 0 4 255 -4 Table 6: 4 tap Filter; M = 32; Coefficient length = 9 bits; Hamming Window Filter 0 0 511 0 0Filter 1 -8 510 9 0Filter 2 -14 507 19 -1Filter 3 -20 502 31 -2Filter 4 -25 494 45 -3Filter 5 -28 484 59 -4Filter 6 -31 472 75 -5


Filter 7 -32 457 91 -5Filter 8 -33 441 109 -6Filter 9 -33 424 128 -8Filter 10 -32 405 148 -10Filter 11 -32 386 169 -12Filter 12 -30 366 189 -14Filter 13 -29 344 212 -16Filter 14 -27 323 233 -18Filter 15 -25 300 256 -20Filter 16 -22 277 278 -22Filter 17 -20 255 301 -25Filter 18 -18 233 323 -27Filter 19 -16 211 345 -29Filter 20 -14 188 367 -30Filter 21 -12 168 387 -32Filter 22 -10 147 406 -32Filter 23 -8 127 425 -33Filter 24 -6 108 442 -33Filter 25 -5 90 458 -32Filter 26 -5 75 472 -31Filter 27 -4 59 484 -28Filter 28 -3 46 493 -25Filter 29 -2 32 501 -20Filter 30 -1 20 506 -14Filter 31 0 10 509 -8 Table 7: 4 tap Filter; M = 32; Coefficient length = 10 bits; Hamming Window Filter 0 0 1023 0 0Filter 1 -16 1022 18 -1Filter 2 -29 1014 40 -2Filter 3 -41 1005 63 -4Filter 4 -50 989 90 -6Filter 5 -57 969 119 -8Filter 6 -61 944 149 -9Filter 7 -65 916 183 -11Filter 8 -67 884 220 -14Filter 9 -67 850 257 -17Filter 10 -67 814 297 -21Filter 11 -65 775 338 -25Filter 12 -62 733 381 -29Filter 13 -59 691 424 -33Filter 14 -55 647 468 -37Filter 15 -51 603 513 -42Filter 16 -46 557 558 -46Filter 17 -42 513 603 -51Filter 18 -37 468 647 -55Filter 19 -33 424 691 -59


Filter 20 -29 380 734 -62Filter 21 -25 338 775 -65Filter 22 -21 296 815 -67Filter 23 -17 256 851 -67Filter 24 -14 219 885 -67Filter 25 -11 182 917 -65Filter 26 -9 148 945 -61Filter 27 -8 119 969 -57Filter 28 -6 91 988 -50Filter 29 -4 64 1004 -41Filter 30 -2 40 1014 -29Filter 31 -1 19 1021 -16 Table 7: 4 tap Filter; M = 32; Coefficient length = 11 bits; Hamming Window Filter 0 0 2047 0 0Filter 1 -32 2044 37 -2Filter 2 -59 2031 80 -5Filter 3 -82 2010 127 -8Filter 4 -101 1980 180 -12Filter 5 -115 1940 238 -16Filter 6 -124 1889 301 -19Filter 7 -131 1834 368 -24Filter 8 -135 1772 440 -30Filter 9 -136 1704 515 -36Filter 10 -135 1630 595 -43Filter 11 -131 1552 677 -51Filter 12 -125 1469 762 -59Filter 13 -118 1383 849 -67Filter 14 -111 1297 937 -76Filter 15 -102 1207 1027 -85Filter 16 -93 1116 1117 -93Filter 17 -85 1027 1207 -102Filter 18 -76 937 1297 -111Filter 19 -67 848 1384 -118Filter 20 -59 762 1469 -125Filter 21 -51 677 1552 -131Filter 22 -43 595 1630 -135Filter 23 -36 515 1704 -136Filter 24 -30 440 1772 -135Filter 25 -24 367 1835 -131Filter 26 -19 300 1890 -124Filter 27 -16 239 1939 -115Filter 28 -12 181 1979 -101Filter 29 -8 128 2009 -82Filter 30 -5 81 2030 -59Filter 31 -2 38 2043 -32


Table 8: 4 tap Filter; M = 32; Coefficient length = 12 bits; Hamming Window Filter 0 0 4095 0 0Filter 1 -64 4090 74 -5Filter 2 -119 4064 160 -10Filter 3 -165 4022 255 -17Filter 4 -202 3960 361 -24Filter 5 -230 3880 477 -32Filter 6 -250 3782 603 -40Filter 7 -264 3672 737 -50Filter 8 -272 3547 881 -61Filter 9 -273 3410 1032 -74Filter 10 -270 3262 1191 -88Filter 11 -263 3106 1355 -103Filter 12 -251 2940 1524 -118Filter 13 -238 2769 1699 -135Filter 14 -223 2594 1877 -153Filter 15 -206 2416 2056 -171Filter 16 -189 2237 2236 -189Filter 17 -171 2056 2416 -206Filter 18 -153 1876 2595 -223Filter 19 -135 1698 2770 -238Filter 20 -118 1524 2940 -251Filter 21 -103 1355 3106 -263Filter 22 -88 1191 3262 -270Filter 23 -74 1031 3411 -273Filter 24 -61 881 3547 -272Filter 25 -50 737 3672 -264Filter 26 -40 602 3783 -250Filter 27 -32 478 3879 -230Filter 28 -24 362 3959 -202Filter 29 -17 256 4021 -165Filter 30 -10 161 4063 -119Filter 31 -5 75 4089 -64 Table 9: 6 tap Filter; M = 32; Coefficient length = 8 bits; Hamming Window Filter 0 0 0 255 0 0 0Filter 1 1 -5 254 6 -1 0Filter 2 2 -11 253 13 -2 0Filter 3 3 -15 250 21 -4 0Filter 4 3 -19 248 29 -6 0Filter 5 4 -23 243 37 -7 1Filter 6 4 -26 239 46 -9 1Filter 7 5 -28 232 56 -11 1Filter 8 4 -29 226 65 -12 1Filter 9 5 -31 219 76 -16 2Filter 10 5 -32 211 87 -18 2


Filter 11 5 -32 202 97 -20 3Filter 12 5 -32 193 108 -22 3Filter 13 5 -32 184 119 -24 3Filter 14 5 -31 173 130 -26 4Filter 15 4 -30 163 141 -27 4Filter 16 4 -29 153 152 -29 4Filter 17 4 -27 141 163 -30 4Filter 18 4 -26 130 173 -31 5Filter 19 3 -24 120 183 -32 5Filter 20 3 -22 108 193 -32 5Filter 21 3 -20 97 202 -32 5Filter 22 2 -18 88 210 -32 5Filter 23 2 -16 77 218 -31 5Filter 24 1 -12 66 225 -29 4Filter 25 1 -11 56 232 -28 5Filter 26 1 -9 47 238 -26 4Filter 27 1 -7 37 243 -23 4Filter 28 0 -6 30 247 -19 3Filter 29 0 -4 21 250 -15 3Filter 30 0 -2 13 253 -11 2Filter 31 0 -1 6 254 -5 1 Table 10: 6 tap Filter; M = 32; Coefficient length = 9 bits; Hamming Window Filter 0 0 0 511 0 0 0Filter 1 2 -11 510 12 -2 0Filter 2 4 -22 508 26 -5 0Filter 3 5 -30 502 41 -7 0Filter 4 7 -39 496 58 -12 1Filter 5 8 -46 487 75 -15 2Filter 6 9 -52 478 93 -19 2Filter 7 9 -56 466 112 -22 2Filter 8 10 -59 452 131 -26 3Filter 9 11 -63 438 153 -32 4Filter 10 11 -65 422 174 -36 5Filter 11 10 -64 405 194 -39 5Filter 12 11 -65 386 217 -44 6Filter 13 10 -65 368 239 -48 7Filter 14 10 -63 347 261 -52 8Filter 15 10 -61 326 283 -55 8Filter 16 8 -57 305 304 -57 8Filter 17 8 -55 283 326 -61 10Filter 18 8 -52 261 347 -63 10Filter 19 7 -48 240 367 -65 10Filter 20 6 -44 217 386 -65 11Filter 21 5 -39 195 404 -64 10Filter 22 5 -36 174 422 -65 11Filter 23 4 -32 153 438 -63 11


Filter 24 3 -26 132 451 -59 10Filter 25 2 -22 113 465 -56 9Filter 26 2 -19 94 477 -52 9Filter 27 2 -15 75 487 -46 8Filter 28 1 -12 58 496 -39 7Filter 29 0 -7 42 501 -30 5Filter 30 0 -5 27 507 -22 4Filter 31 0 -2 12 510 -11 2 Table 11: 6 tap Filter; M = 32; Coefficient length = 10 bits; Hamming Window Filter 0 0 0 1023 0 0 0Filter 1 4 -23 1022 25 -5 0Filter 2 8 -44 1015 54 -11 1Filter 3 11 -62 1006 83 -16 1Filter 4 14 -78 992 116 -23 2Filter 5 16 -92 976 150 -30 3Filter 6 18 -104 956 187 -38 4Filter 7 20 -113 932 225 -46 5Filter 8 21 -120 904 265 -54 7Filter 9 21 -126 877 306 -63 8Filter 10 22 -129 844 348 -71 9Filter 11 22 -131 810 391 -80 11Filter 12 21 -131 774 435 -88 12Filter 13 21 -130 735 480 -97 14Filter 14 20 -126 695 523 -104 15Filter 15 19 -122 652 566 -110 16Filter 16 18 -118 612 611 -118 18Filter 17 16 -110 566 652 -122 19Filter 18 15 -104 524 694 -126 20Filter 19 14 -97 480 735 -130 21Filter 20 12 -88 436 773 -131 21Filter 21 11 -80 392 809 -131 22Filter 22 9 -71 349 843 -129 22Filter 23 8 -63 307 876 -126 21Filter 24 7 -54 266 903 -120 21Filter 25 5 -46 226 931 -113 20Filter 26 4 -38 188 955 -104 18Filter 27 3 -30 151 975 -92 16Filter 28 2 -23 117 991 -78 14Filter 29 1 -16 84 1005 -62 11Filter 30 1 -11 54 1015 -44 8Filter 31 0 -5 26 1021 -23 4 Table 12: 6 tap Filter; M = 32; Coefficient length = 11 bits; Hamming Window Filter 0 0 0 2047 0 0 0Filter 1 9 -47 2043 51 -10 1Filter 2 16 -88 2031 107 -21 2


Filter 3 23 -125 2011 168 -34 4Filter 4 30 -158 1983 233 -47 6Filter 5 34 -186 1951 302 -62 8Filter 6 38 -209 1911 375 -78 10Filter 7 41 -228 1865 451 -94 12Filter 8 43 -243 1810 530 -110 15Filter 9 44 -253 1753 613 -127 17Filter 10 45 -260 1688 696 -144 20Filter 11 45 -263 1618 783 -161 23Filter 12 44 -263 1548 871 -178 25Filter 13 42 -259 1471 959 -194 28Filter 14 41 -254 1390 1046 -209 31Filter 15 39 -245 1307 1134 -222 34Filter 16 36 -235 1223 1222 -235 36Filter 17 34 -222 1135 1306 -245 39Filter 18 31 -209 1046 1390 -254 41Filter 19 28 -194 960 1470 -259 42Filter 20 25 -178 872 1547 -263 44Filter 21 23 -161 783 1618 -263 45Filter 22 20 -144 696 1688 -260 45Filter 23 17 -127 614 1752 -253 44Filter 24 15 -110 530 1810 -243 43Filter 25 12 -94 452 1864 -228 41Filter 26 10 -78 376 1910 -209 38Filter 27 8 -62 303 1950 -186 34Filter 28 6 -47 234 1982 -158 30Filter 29 4 -34 169 2010 -125 23Filter 30 2 -21 108 2030 -88 16Filter 31 1 -10 51 2043 -47 9 Table 13: 6 tap Filter; M = 32; Coefficient length = 12 bits; Hamming Window Filter 0 0 0 4095 0 0 0Filter 1 17 -93 4087 102 -20 2Filter 2 34 -177 4060 215 -43 6Filter 3 48 -252 4022 337 -69 9Filter 4 61 -317 3966 466 -96 13Filter 5 70 -373 3901 604 -126 17Filter 6 78 -420 3820 750 -157 22Filter 7 84 -456 3727 903 -189 26Filter 8 88 -487 3621 1061 -222 31Filter 9 90 -508 3505 1226 -256 36Filter 10 91 -520 3378 1395 -290 41Filter 11 91 -526 3239 1566 -324 47Filter 12 89 -527 3094 1742 -357 52Filter 13 86 -521 2941 1918 -389 58Filter 14 83 -509 2779 2094 -419 64Filter 15 79 -492 2613 2270 -446 69


Filter 16 74 -471 2445 2444 -471 74Filter 17 69 -446 2270 2613 -492 79Filter 18 64 -419 2094 2779 -509 83Filter 19 58 -389 1918 2941 -521 86Filter 20 52 -357 1742 3094 -527 89Filter 21 47 -324 1566 3239 -526 91Filter 22 41 -290 1396 3377 -520 91Filter 23 36 -256 1226 3505 -508 90Filter 24 31 -222 1061 3621 -487 88Filter 25 26 -189 904 3726 -456 84Filter 26 22 -157 750 3820 -420 78Filter 27 17 -126 604 3901 -373 70Filter 28 13 -96 466 3966 -317 61Filter 29 9 -69 338 4021 -252 48Filter 30 6 -43 216 4059 -177 34Filter 31 2 -20 103 4086 -93 17 Table 14: 8 tap Filter; M = 32; Coefficient length = 8 bits; Hamming Window Filter 0 0 0 0 255 0 0 0 0Filter 1 0 2 -6 254 7 -2 0 0Filter 2 -1 3 -12 254 14 -4 1 0Filter 3 -1 5 -18 252 23 -7 1 0Filter 4 -1 7 -23 248 31 -9 2 0Filter 5 -2 8 -27 245 40 -12 3 0Filter 6 -2 9 -30 240 50 -15 4 -1Filter 7 -2 10 -34 234 60 -17 5 -1Filter 8 -2 11 -36 227 70 -20 6 -1Filter 9 -2 12 -38 220 81 -23 6 -1Filter 10 -3 12 -40 215 91 -26 7 -1Filter 11 -3 12 -40 205 102 -28 8 -1Filter 12 -3 12 -41 198 113 -31 9 -2Filter 13 -2 12 -41 187 124 -33 10 -2Filter 14 -2 12 -40 177 135 -35 10 -2Filter 15 -2 12 -40 167 146 -37 11 -2Filter 16 -2 11 -38 157 156 -38 11 -2Filter 17 -2 11 -37 146 167 -40 12 -2Filter 18 -2 10 -35 135 177 -40 12 -2Filter 19 -2 10 -33 125 186 -41 12 -2Filter 20 -2 9 -31 114 197 -41 12 -3Filter 21 -1 8 -28 103 204 -40 12 -3Filter 22 -1 7 -26 92 214 -40 12 -3Filter 23 -1 6 -23 81 220 -38 12 -2Filter 24 -1 6 -20 70 227 -36 11 -2Filter 25 -1 5 -17 61 233 -34 10 -2Filter 26 -1 4 -15 51 239 -30 9 -2Filter 27 0 3 -12 41 244 -27 8 -2Filter 28 0 2 -9 32 247 -23 7 -1


Filter 29 0 1 -7 24 251 -18 5 -1Filter 30 0 1 -4 15 253 -12 3 -1Filter 31 0 0 -2 7 254 -6 2 0 Table 15: 8 tap Filter; M = 32; Coefficient length = 9 bits; Hamming Window Filter 0 0 0 0 511 0 0 0 0Filter 1 -1 4 -13 510 14 -4 1 0Filter 2 -2 8 -25 508 29 -9 2 0Filter 3 -2 11 -36 503 46 -14 3 0Filter 4 -3 14 -46 498 63 -19 5 -1Filter 5 -3 16 -53 487 81 -23 6 0Filter 6 -4 19 -62 481 101 -30 8 -2Filter 7 -5 21 -68 469 121 -35 10 -2Filter 8 -5 23 -73 456 141 -41 12 -2Filter 9 -5 24 -77 444 162 -47 13 -3Filter 10 -6 25 -80 428 184 -52 15 -3Filter 11 -6 25 -82 412 205 -57 17 -3Filter 12 -6 25 -82 394 228 -62 18 -4Filter 13 -5 25 -82 375 249 -67 20 -4Filter 14 -5 25 -81 355 271 -71 21 -4Filter 15 -5 24 -80 336 293 -74 22 -5Filter 16 -5 23 -77 315 314 -77 23 -5Filter 17 -5 22 -74 294 335 -80 24 -5Filter 18 -4 21 -71 272 354 -81 25 -5Filter 19 -4 20 -67 250 374 -82 25 -5Filter 20 -4 18 -62 228 394 -82 25 -6Filter 21 -3 17 -57 206 411 -82 25 -6Filter 22 -3 15 -52 184 428 -80 25 -6Filter 23 -3 13 -47 163 443 -77 24 -5Filter 24 -2 12 -41 141 456 -73 23 -5Filter 25 -2 10 -35 122 468 -68 21 -5Filter 26 -2 8 -30 102 480 -62 19 -4Filter 27 0 6 -23 80 488 -53 16 -3Filter 28 -1 5 -19 64 497 -46 14 -3Filter 29 0 3 -14 46 503 -36 11 -2Filter 30 0 2 -9 30 507 -25 8 -2Filter 31 0 1 -4 14 510 -13 4 -1 Table 16: 8 tap Filter; M = 32; Coefficient length = 10 bits; Hamming Window Filter 0 0 0 0 1023 0 0 0 0Filter 1 -2 8 -26 1021 28 -8 2 0Filter 2 -4 16 -50 1016 59 -18 5 -1Filter 3 -5 22 -72 1008 92 -28 7 -1Filter 4 -7 29 -92 997 127 -39 10 -2Filter 5 -8 34 -109 980 164 -49 14 -3Filter 6 -9 39 -124 962 202 -60 17 -4Filter 7 -10 43 -136 940 242 -72 20 -4


Filter 8 -11 46 -146 915 283 -83 24 -5Filter 9 -11 48 -154 888 325 -94 27 -6Filter 10 -12 50 -160 856 369 -104 30 -6Filter 11 -12 51 -164 824 412 -115 34 -7Filter 12 -12 51 -165 789 456 -125 37 -8Filter 13 -12 51 -165 752 500 -134 40 -9Filter 14 -11 50 -164 712 544 -142 43 -9Filter 15 -11 49 -160 672 587 -149 45 -10Filter 16 -10 47 -155 630 629 -155 47 -10Filter 17 -10 45 -149 588 671 -160 49 -11Filter 18 -9 43 -142 544 712 -164 50 -11Filter 19 -9 40 -134 501 751 -165 51 -12Filter 20 -8 37 -125 456 789 -165 51 -12Filter 21 -7 34 -115 412 824 -164 51 -12Filter 22 -6 30 -104 369 856 -160 50 -12Filter 23 -6 27 -94 326 887 -154 48 -11Filter 24 -5 24 -83 284 914 -146 46 -11Filter 25 -4 20 -72 243 939 -136 43 -10Filter 26 -4 17 -60 203 961 -124 39 -9Filter 27 -3 14 -49 165 979 -109 34 -8Filter 28 -2 10 -39 128 996 -92 29 -7Filter 29 -1 7 -28 93 1007 -72 22 -5Filter 30 -1 5 -18 60 1015 -50 16 -4Filter 31 0 2 -8 28 1021 -26 8 -2 Table 17: 8 tap Filter; M = 32; Coefficient length = 11 bits; Hamming Window Filter 0 0 0 0 2047 0 0 0 0Filter 1 -4 16 -53 2045 57 -17 4 -1Filter 2 -8 32 -101 2034 119 -37 10 -2Filter 3 -11 45 -145 2018 185 -57 15 -3Filter 4 -14 58 -184 1994 255 -78 21 -5Filter 5 -17 69 -218 1962 328 -99 28 -6Filter 6 -19 78 -248 1926 405 -121 34 -8Filter 7 -21 86 -273 1881 486 -144 41 -9Filter 8 -22 92 -293 1831 568 -166 48 -11Filter 9 -23 97 -309 1775 652 -188 55 -12Filter 10 -24 101 -322 1715 738 -209 61 -13Filter 11 -24 103 -328 1648 825 -230 68 -15Filter 12 -24 103 -333 1579 914 -250 74 -16Filter 13 -24 103 -332 1504 1001 -269 80 -18Filter 14 -23 101 -329 1427 1090 -286 86 -19Filter 15 -22 99 -321 1344 1175 -299 91 -20Filter 16 -21 95 -312 1262 1261 -312 95 -21Filter 17 -20 91 -299 1175 1344 -321 99 -22Filter 18 -19 86 -286 1091 1426 -329 101 -23Filter 19 -18 80 -269 1001 1504 -332 103 -24


Filter 20 -16 74 -250 914 1579 -333 103 -24Filter 21 -15 68 -230 825 1648 -328 103 -24Filter 22 -13 61 -209 739 1714 -322 101 -24Filter 23 -12 55 -188 652 1775 -309 97 -23Filter 24 -11 48 -166 568 1831 -293 92 -22Filter 25 -9 41 -144 486 1881 -273 86 -21Filter 26 -8 34 -121 406 1925 -248 78 -19Filter 27 -6 28 -99 329 1961 -218 69 -17Filter 28 -5 21 -78 256 1993 -184 58 -14Filter 29 -3 15 -57 186 2017 -145 45 -11Filter 30 -2 10 -37 120 2033 -101 32 -8Filter 31 -1 4 -17 58 2044 -53 16 -4 Table 18: 8 tap Filter; M = 32; Coefficient length = 12 bits; Hamming Window Filter 0 0 0 0 4095 0 0 0 0Filter 1 -8 33 -106 4089 115 -35 9 -2Filter 2 -16 64 -203 4070 239 -74 20 -5Filter 3 -23 92 -291 4036 371 -114 31 -7Filter 4 -29 116 -369 3989 511 -156 43 -10Filter 5 -35 138 -439 3929 658 -199 56 -13Filter 6 -39 157 -498 3853 812 -243 69 -16Filter 7 -42 173 -548 3765 972 -288 82 -19Filter 8 -45 185 -588 3664 1137 -332 96 -22Filter 9 -47 195 -621 3555 1306 -378 110 -25Filter 10 -48 202 -644 3430 1478 -421 123 -27Filter 11 -48 206 -659 3300 1652 -462 136 -30Filter 12 -48 207 -666 3159 1828 -501 149 -33Filter 13 -48 206 -665 3010 2005 -538 161 -36Filter 14 -46 203 -658 2854 2179 -571 172 -38Filter 15 -45 198 -645 2691 2354 -601 182 -41Filter 16 -43 191 -624 2523 2524 -624 191 -43Filter 17 -41 182 -601 2354 2691 -645 198 -45Filter 18 -38 172 -571 2180 2853 -658 203 -46Filter 19 -36 161 -538 2005 3010 -665 206 -48Filter 20 -33 149 -501 1829 3158 -666 207 -48Filter 21 -30 136 -462 1653 3299 -659 206 -48Filter 22 -27 123 -421 1478 3430 -644 202 -48Filter 23 -25 110 -378 1307 3554 -621 195 -47Filter 24 -22 96 -332 1137 3664 -588 185 -45Filter 25 -19 82 -288 972 3765 -548 173 -42Filter 26 -16 69 -243 813 3852 -498 157 -39Filter 27 -13 56 -199 659 3928 -439 138 -35Filter 28 -10 43 -156 511 3989 -369 116 -29Filter 29 -7 31 -114 372 4035 -291 92 -23Filter 30 -5 20 -74 240 4069 -203 64 -16Filter 31 -2 9 -35 116 4088 -106 33 -8

Victor%27s Video Scaler Cook Book

Documents

Transcript of Victor%27s Video Scaler Cook Book