for WMPto install simply save the dll somewhere and run the batch file along side it.
then go into WMP and select the Radix visualization.
it's a GLSL based visualization, basically it presents the frequency level graph radially and the wave form wrapped around it, and uses dominant frequencies and a rather complex reaction to determine colors. it requires PS v2 to run, I imagine most everyone has that by now, but if you get an ugly blue mess, rather than a neat looking set of concentric circles then something whent wrong compiling the shader (ie your card doesn't support PSv2)
it's sort of hard to get to but if you know any GLSL (which is basically a dialect of C) you can make your own shader to run on this (don't have any file support unfortunately so copy/paste is your friend). to get to the editor you need to go view->plugins->options->(it should already be on the plugin tab and have visualizations selected)->select radix from the available visualizations->click the properties button. you should probably have some goggles on to prevent the blood that will come from your eyes from damaging any nearby computer equipment or stain your carpeting/clothes, this was not a thought through project, this is probably the most hacked together POS code I've ever written, mostly because I've had to try ten different ways to get particular thing to work, the HLSL code is just horrible, just me screwing around with a bunch of random variable until it makes something that looks nice, it's uncommented and has no apparent design to it because there is none. fortunately there are only two not too long functions and one of those is a fairly easy to grasp on how to use (if not how it works, but it does work AFAIK) utility for converting HSL to RGB.
the shader works thusly;
main() is called for every pixel on the visualization's buffer, to get your x/y position use gl_TexCoord[0].xy it will return a value between -sqrt(2) and sqrt(2). at the end of main() is a statement where gl_FragColor is set to something, gl_FragColor is the color of the pixel (note that the frames are alpha blended together, if you don't want to deal with this make sure your output pixel color has it's alpha value set to 0.0). I have all the frequency levels and wave forms packed into a 1D texture (the left and right freq and waveform are packed into rgba respectively), to get access to them you need to sample tex0 with texture1D, the basic syntax is
vec4 levels_and_waveform = texture1D(tex0,some_value_between_0_and_0);. if you wanted to get some low frequency level (ie how much bass was going on at that time) you'd use a value close to 0.0 to sample with and you'd use the r (red == right channel freq levels) and/or g (green == left freq levels) as the result.
so if you have experience with C you should be able to use this to make some visualizations
here is a simpler and more readable shader than what you will be presented with when you go into the editor.
uniform sampler1D tex0;
const float sqrt2d2 = 0.7071067811865*2.0;
void main()
{
//sample for the wave form, note this sample will have both wave form and freq levels,
//but we aren't going to use levels so who cares
//note there is a bit of coordinate transformation
//the coords are in the range of -sqrt2d2 to sqrt2d2
//we want them in the range of 0.0 to 1.0
vec4 wave_sample = texture1D(tex0,gl_TexCoord[0].x/sqrt2d2+0.5);
//we want to deal with just one value for a wave form, so let's average left and right together
//-0.5 puts the value into the -1.0 to 1.0 range
//note that the left and right wave forms are in the blue and alpha chanels
float avg_wave = (wave_sample.b+wave_sample.a)-1.0;
//now we cannot choose the output position for this pixel, we can only use it's position, so lets
//set the brightness of the pixel based upon it's 1D distance from the wave for height
//pow is used to make only the brightest point of the color bright
float brightness = pow(1.0-abs(avg_wave - gl_TexCoord[0].y),30);
//let us define a base color, white with no alpha sounds good (rgba)
vec4 col = vec4(1.0, 1.0, 1.0, 0.0);
//now we scale the base color by the brightness,
//GLSL performes vector processing of the color components. cool huh?!
gl_FragColor = col*brightness;
}
