Old news - virtualdub. News: Bicubic resampling Long, lengthy rant^H^H^H^Hdiscourse on 3.

You have not yet voted on this site! If you have already visited the site, please help us classify the good from the bad by voting on this site.

D to follow. One of the features I've been working on for 1. D support. We've been using simply bilinear for too long, and it's time we had better quality zooms accelerated on the video card. Problem is, 3. D pipelines aren't really set up for generic FIR filters, so the task is to convolute and mutate the traditional 4x. GPU understands. To review, the 1. D cubic interpolation filter used in Virtual. Dub is a 4- tap filter defined as follows: tap 1 = Ax - 2. Ax. 2 + Ax. 3; tap 2 = 1 - (A+3)x.

A+2)x. 3; tap 3 = - Ax + (2. A+3)x. 2 - (A+2)x.

Ax. 2 - Ax. 3; where taps 2 and 3 straddle the desired point and x is the fractional distance from tap 2 to that point. Applying this both horizontally and vertically gives the bicubic filter. The fact that you calculate the 2. D filter as two 1. D passes means that the 2.

Latest trending topics being covered on ZDNet including Reviews, Tech Industry, Security, Hardware, Apple, and Windows. Offers online listening with the possibility to create playlists and send music.

Old news 5/15/2004 News: Bicubic resampling. Long, lengthy rant^H^H^H^Hdiscourse on 3D to follow. One of the features I've been working on for 1.6.0 is the ability to. No-registration upload of files up to 250MB. Not available in some countries. Find great deals on eBay for trucks and commercial trucks. Shop with confidence. Free Downloads for Microsoft Office. Please report any broken links immediately so we may keep this resource up to date! If you would like your download listed here. Latest NEWS Simi Announces Release Date And Title For Album Another Collabo Alert?! Wizkid Links Up With Nicki Minaj KCee Commences Campaign, Shares Rice & Oil To.

D filter is separable; this reduces the number of effective taps for the 2. D filter from 1. 6 to 8.

We can do this on a GPU by doing the horizontal pass into a render target texture, then using that as the source for a vertical pass. As we will see, this is rather important on the lower- end 3. D cards. Now, how many different problems did I encounter implementing this? Let's start with the most powerful cards and work down: DX9, some DX8 class cards (Pixel Shader 1. NVIDIA Ge. Force FX, ATI RADEON 8.

Six texture stages, high- precision fixed point arithmetic or possibly even floating- point. There really isn't any challenge to this one whatsoever, as you simply just bind the source texture to the first four texture stages, bind a filter LUT to the fifth texture stage, and multiply- add them all together in a simple PS1. On top of that, you have fill rate that is obscene for this task so performance is essentially a non- issue.

Total passes: two. NVIDIA has some interesting shaders in their FXComposer tool for doing bicubic interpolation using Pixel Shader 2. However, it chews up a ton of shader resources and burns a ton of clocks per pixel — I think the compiler said somewhere around 5. I'm not sure that's faster than a separable method and it chews up a lot of shader resources.

Did I mention it requires PS2. How To Uninstall Mcafee Internet Security On Mac. It does compute a more precise filter, however. I might add a single- pass PS2. I have a Ge. Force FX 5. I first wrote this path, I had no PS1. I had to prototype on the D3. D reference rasterizer.

Refrast's awe- inspiring 0. Now we run into a problem: the framebuffer is limited to 8- bit unsigned values, and more importantly, can't hold negative values. The way we get around this is to compute the absolute value of the two negative taps first into the framebuffer, then combining that with the sum of the two positive taps using REVSUBTRACT as the framebuffer blending mode. Sadly, clamping to . And no, I won't consider whacking the gamma ramp of the whole screen to avoid the last pass. DX7 class card (Fixed function, two texture stages: NVIDIA Ge.

Force 2) This is where things get uglier. Only two texture stages means we can only compute one tap at a time, since we need one of the stages for the filter LUT. This means that 9 passes are required, four for the horizontal filter, four for the vertical, and one to double the result. As you may have guessed a GF2 or GF4. Go doesn't have a whole lot of fill rate after dividing by nine and I have trouble getting this mode working at 3.

That sucks, because my development platform is a GF4. Go. 44. 0. I came up with an alternate way to heavily abuse the diffuse channel in order to do one tap per texture stage: draw one- pixel wide strips of constant filter (vertical for the horizontal pass, horizontal for the vertical pass) and put the filter coefficients in the diffuse color. This cuts the number of passes down to five as with the GF3/4 path. Unfortunately, this turns out to be slower than the nine pass method. I doubt it's T& L load, because 5. I'm blowing the tiling pattern by drawing strips.

I've been racking my brain trying to bring this one below nine passes, but I haven't come up with anything other than the method above that didn't work. DX7 class card (Fixed function, three texture stages: ATI RADEON) Three texture stages means we can easily do two taps at a time for a total of five passes, which should put the original ATI RADEON on par with the Ge. Force 3 for this operation. Yay for ATI and the third texture stage!

Oh wait, this card doesn't support alternate framebuffer blending operations and thus can't subtract on blend. On top of that, D3. D lets us complement on input to a blending stage but not output, and we can't do the multiply- add until the final stage. Never mind, the original RADEON sucks. So now what? We first compute the two negative taps using the ugly but useful D3.

DTOP. How do we handle the negation? By clearing the render target to 5. INVSRCCOLOR, basically computing 0.

We then add the two positive taps with their filter scaled down by 5. The result is the filtered pixel, shifted into the . The vertical pass is computed similarly, but with input complement on both passes to flip the result inverted to . Rather fugly, but it does work. The precision isn't great, though, slightly worse than the Ge.

Force 2 mode. Interestingly, the RADEON doesn't really run any better than the Ge. Force 2 despite having half the passes. DX0 class card (Intel Pentium 4- M 1.

GHz) Here's the sad part: a highly optimized SSE2 bicubic routine can stretch a 3. That means systems with moderate GPUs and fast CPUs are better off just doing the bicubic stretch on the CPU. You might be wondering why I'm using Direct.

D instead of Open. GL. That is a valid question, given that I don't really like Direct. D (which I affectionately call . The reason is that I wrote a basic Open.

GL display driver for 1. NVIDIA drivers that caused a stall of up to ten seconds when switching between display contexts. The code has shipped and is in 1. Video. Display. Drivers.

I might resurrect it again as NVIDIA reportedly exposes a number of features in their hardware in Open. GL that are not available in Direct. D, such as the full register combiners, and particularly the final combiner. However, I doubt that there's anything I can use, because the two critical features I need for improving the GF2 path are either doubling the result of the framebuffer blend or another texture stage, both of which are doubtful.

News: YV1. 2 is b. My daily commute takes me across the San Mateo Bridge. Coming back from the Peninsula there is a sign that says: . Sorry, not good enough. Not only does naked disable the frame pointer omission (FPO) optimization and prevent inlining, but it also doesn't stop the compiler from using spill space if it needs to — which means you basically have to set up a stack frame anyway. I've been trying for some time to get YV1.

The problem is that different drivers and applications are inconsistent about how they treat or format odd- width and odd- height YV1. Some support it by truncating the chroma planes (dumb). Some do that and have unused space betweeen the Cr and Cb planes (weird). Many simply crash (very dumb). And a few simply don't support it (lame but pragmatic). YVU9 tends to be even more broken.

Now, if people had sense, they would have handled this the way that MPEG and JPEG do, and simply require that the bitmap always be padded to the nearest even boundaries and that the extra pixels be ignored on decoding. Unfortunately, no one seems to have bothered to ever define the YV1. News: Taking the 6. First, I finally fixed the FAQ link from the program, and also updated the knowledge base for known bugs in 1. I dropped the older KB entries, but they're basically redundant with the change log in Virtual.

Dub. I put together a new Athlon 6. Windows XP for 6. Extended Systems and the prerelease AMD6. Virtual. Dub source code a bit. The above is the result.

It plays MPEG- 1 files, but nearly all of the assembly optimizations are disabled and none of the video filters work, so it's still far behind the 3.