blob: aa80a535ba2daeb8d15c829efe2d553f138c13c5 [file] [log] [blame]
 Duh, an 'easy' way to replicate Giess's behavior: For each frame, you have to mutate it by a transform matrix. This is easy, thought not cheap. First you precalculate the transform matrix how you want it, based on whatever rotations or whatever you want. The data stored in each spot on the matrix tells you how to transform a single pixel. The simple case is dx,dy, where both are relatively small. The probably ought to be a byte in any case, so you can scale the transform matrix on slow machines. A more complex case is some trick whereby a single pixel ends up splattered in several places. Idea below. The matrix consists of some number of 8bit arrays of the same size as the image. They'd probably be line-interleaved or better to help with cache effects (which are VERY serious here). Each channel represents some aspect of the transform. The first two would likely be dx and dy, the third might be a multiplier if that wasn't done statically. The idea: any number of transform sets could be applied, given available processing power. Just set the static scalar or the multiplier matrices so you don't completely swamp the output pixels. Note that this is fastest in 8-bit, but theoretically could be applied to 32 bit. 15 and 16 are hard, since you can't easily apply the multipliers unless they're 1/2^n, and even then it's significantly heavier (you'd have to mask the top n bits of each color out). This SCREAMS for MMX, in case you haven't figured it out yet. Unfortunately, MMX is only directly useful for the scalar matrix, unless you do a trick where all the pixels in that fit in 64 bits (8 8bit, 4 16bit, or 2 32bit) are always moved in a group. This is very possible, and might be a significant perf increase by being able to use MMX all the way through. Otherwise you have to place each pixel by extracting the MMX stuff back into normal registers, and that just plain sucks. A pseudo-C implementation: ----- BEGIN ----- gint x,y; /* image x and y size */ guchar old_image[x][y]; /* original image */ guchar new_image[x][y]; /* new image */ gchar x_xform[x][y]; /* dx matrix */ gchar y_xform[x][y]; /* dy matrix */ guchar s_xform[x][y]; /* intensity scalar matrix */ guchar scalar; /* global scalar */ gint i,j; /* indixes */ gulong p; /* pixel value in question */ guchar u,v,w; /* modifier variables */ /* clear the new image, we don't want anything getting in the way */ /* NOT NECESSARILY A GOOD THING, THOUGH */ memset(new_image,0,x*y); /* loop through all the lines in the image */ for (j=0;j