Resolved Visualizations don't work in Windows Media Player 11. It just showed a black screen like in normal mode. My Media Player is pretty much fine and I haven't ran into any errors yet. I also went into C:/Program Files/Windows Media Player/Visualizations and discovered that the visualization folder was empty. Visualization for Windows Media Player 12. Hi, I'm looking to spice up the optic of my WMP 12. Until now I'm using Bars & Waves Scope but I could imagine something better. Hi, I wanted to ask if it is possible to set Windows media player to open as the default player inside media center. Hi, how to create a visualization in vb.net just like in windows media player visualization? It is possible to create visualization in vb.net or much better to create visualization in adobe flash? Can you give one example of the visualization made in vb.net or flash? Tuesday, March 8, 2011 6:54 AM.
Ever wondered what's behind a visualization? This is your opportunity to learn something new because there are only a couple of Windows Media Player Visualizations that deliver source code. You'll learn to build a new visualization with Visual C++ 2005 Express (you won't even require a Standard Edition)! Winter is here.. Snow is here.. we'll render Koch Snowflake Fractals that depend on the waveform of the playing song with the Windows Graphics Device Interface. This article will also change the way you ever looked at a visualization. Enjoy!
Paul-Valentin Borza - http://www.borza.ro
Difficulty: Intermediate
Cost: Free Time required: 1-3 hours Software:Visual C++ 2005 Express, Windows Server 2003 R2 Platform SDK, Windows Software Development Kit for Windows Vista Hardware: None Download Source: Winter Visualization Source Code How do we build a visualization?
Please install (don't change the default installation directory):
We need to make Visual C++ 2005 Express work with visualizations:
You'll notice that the created project won't compile because the 'atlbase.h', 'wmpplug.h', 'effects.h' and 'winres.h' can't be opened; to overcome:
One last trick.. Edit 'C:Program FilesMicrosoft Platform SDK for Windows Server 2003 R2Includeatlatlbase.h' usingNotepad. Find the following text (begins on line 287):
287 PVOID __stdcall __AllocStdCallThunk(VOID);
288 VOID __stdcall __FreeStdCallThunk(PVOID);
289
290#define AllocStdCallThunk() __AllocStdCallThunk()
291#define FreeStdCallThunk(p) __FreeStdCallThunk(p)
292
293#pragmacomment(lib,'atlthunk.lib')
Comment line 287 to 293 and add 'AllocStdCallThunk' and 'FreeStdCallThunk' to look like:
287/*
288PVOID __stdcall __AllocStdCallThunk(VOID);
289VOID __stdcall __FreeStdCallThunk(PVOID);
290
291#define AllocStdCallThunk() __AllocStdCallThunk()
292#define FreeStdCallThunk(p) __FreeStdCallThunk(p)
293
294#pragma comment(lib, 'atlthunk.lib')
295*/
296
297#define AllocStdCallThunk() HeapAlloc(GetProcessHeap(), 0,sizeof(_stdcallthunk))
298#define FreeStdCallThunk(p) HeapFree(GetProcessHeap(), 0, p)
You should now be able to compile a visualization. Compile your visualization and launchWindows Media Player.
How do we debug a visualization?
We know how to build and try a visualization; however, how do we debug one? Simple - we attach to the 'wmplayer.exe' process.
The Winter Visualization
From now on, we'll take a look at the source code for the Winter Visualization. A visualization can have one or morepresets (Bars and Wave for example). I've decided to go with two presents for the Winter Visualization and named them:Snow Flakes (draws blue snowflakes) and Snow Flames (draws red snowflakes).
Configuration
Open 'WinterVisualization.h' and check the configuration values:
18#define EQ_ANGLE -1.0471975511965977461542144610932f // - PI / 3
19#define SNOW_MIN_SIZE 23 // in pixels
20#define SNOW_MAX_SIZE 337 // in pixels
21#define SNOW_STEP_SIZE 4 // in pixels
22#define SNOW_COUNT 13 // number of snowflakes
23#define SNOW_FLAKE_COLOR_COUNT 5 // number of blue colors
24#define SNOW_FLAME_COLOR_COUNT 5 // number of red colors
25#define SNOW_ALPHA 237 // alpha value
26#define KOCH_IT 5 // number of iterations for Koch
Don't modify EQ_ANGLE as it's needed to make equilateral triangles for the Koch Snowflake Fractal. If you changeSNOW_FLAKE_COLOR_COUNT or SNOW_FLAME_COLOR_COUNT, modify the appropriate lines inCWinterVisualization::FinalConstruct. The visualization involves a lot of computations and changing any configuration value could potentially slow it down. However, you're more than welcome to try anything.. For example, increasingKOCH_IT to 6 will make the visualization run slower, but the snowflakes will have a more defined border. Try playing withSNOW_ALPHA (value should be between 0 and 255).
Initialization
Open 'WinterVisualization.cpp':
37 HRESULT CWinterVisualization::FinalConstruct()
38 {
39 tsPrev = 0; // previous time stamp
40 rcPrev.left = 0; // previous drawing surface
41 rcPrev.top = 0; // previous drawing surface
42 rcPrev.right = 0; // previous drawing surface
43 rcPrev.bottom = 0; // previous drawing surface
44
45 hdcPrev = 0; // previous handler to device context
46 hNewBitmapPrev = 0; // previous drawing bitmap
47
48 hdcMem = 0; // memory handler to device context
49 hNewBitmapMem = 0; // memory drawing bitmap
50
51/* Create Elapsed Font */
52 LOGFONT lfElapsed;
53 lfElapsed.lfHeight = 23;
54 lfElapsed.lfWidth = 0;
55 lfElapsed.lfEscapement = 0;
56 lfElapsed.lfOrientation = 0;
57 lfElapsed.lfWeight = FW_BOLD;
58 lfElapsed.lfItalic = FALSE;
59 lfElapsed.lfUnderline = FALSE;
60 lfElapsed.lfStrikeOut = FALSE;
61 lfElapsed.lfCharSet = DEFAULT_CHARSET;
62 lfElapsed.lfOutPrecision = OUT_DEFAULT_PRECIS;
63 lfElapsed.lfClipPrecision = CLIP_DEFAULT_PRECIS;
64 lfElapsed.lfQuality = ANTIALIASED_QUALITY;
65 lfElapsed.lfPitchAndFamily = FF_MODERN;
66 _tcscpy_s(lfElapsed.lfFaceName, TEXT('0'));
67 hfElapsed = CreateFontIndirect(&lfElapsed);
68
69/* Create Plus Font */
70 LOGFONT lfPlus;
71 lfPlus.lfHeight = 9;
72 lfPlus.lfWidth = 0;
![]()
73 lfPlus.lfEscapement = 0;
74 lfPlus.lfOrientation = 0;
75 lfPlus.lfWeight = FW_BOLD;
76 lfPlus.lfItalic = FALSE;
77 lfPlus.lfUnderline = FALSE;
78 lfPlus.lfStrikeOut = FALSE;
79 lfPlus.lfCharSet = DEFAULT_CHARSET;
80 lfPlus.lfOutPrecision = OUT_DEFAULT_PRECIS;
81 lfPlus.lfClipPrecision = CLIP_DEFAULT_PRECIS;
82 lfPlus.lfQuality = ANTIALIASED_QUALITY;
83 lfPlus.lfPitchAndFamily = FF_MODERN;
84 _tcscpy_s(lfPlus.lfFaceName, TEXT('0'));
85 hfPlus = CreateFontIndirect(&lfPlus);
86
87/* Flake Colors */
88 hpSnowColor[0] = CreatePen(PS_SOLID, 1, RGB(99, 184, 255)); // #63B8FF
89 hpSnowColor[1] = CreatePen(PS_SOLID, 1, RGB(92, 172, 238)); // #5CACEE
90 hpSnowColor[2] = CreatePen(PS_SOLID, 1, RGB(30, 144, 255)); // #1E90FF
91 hpSnowColor[3] = CreatePen(PS_SOLID, 1, RGB(28, 134, 238)); // #1C86EE
92 hpSnowColor[4] = CreatePen(PS_SOLID, 1, RGB(16, 78, 139)); // #104E8B
93/* Flame Colors */
94 hpSnowColor[5] = CreatePen(PS_SOLID, 1, RGB(220, 20, 60)); // #DC143C
95 hpSnowColor[6] = CreatePen(PS_SOLID, 1, RGB(255, 48, 48)); // #FF3030
96 hpSnowColor[7] = CreatePen(PS_SOLID, 1, RGB(238, 44, 44)); // #EE2C2C
97 hpSnowColor[8] = CreatePen(PS_SOLID, 1, RGB(205, 38, 38)); // #CD2626
98 hpSnowColor[9] = CreatePen(PS_SOLID, 1, RGB(139, 26, 26)); // #8B1A1A
99
100 hBrushBack = CreateSolidBrush(RGB(0, 0, 0));
101
102 iKochCount = (SNOW_MAX_SIZE - SNOW_MIN_SIZE) / SNOW_STEP_SIZE;
Ing Media Player Visualization Download
103 CreateSnow(); // populate pKoch
104
105// Make snowflakes re-initialize in DrawSnow
106for (INT i = 0; i < SNOW_COUNT; ++i)
107 iSnowSize[i] = iKochCount - 1;
108
109return S_OK;
110 }
The surface size, the device contexts, the fonts, the pens and the brushes are initialized (the variables are declared in 'WinterVisualization.h'). Notice that I'm also precomputing the Koch Snowflake Fractal because it doesn't make sense to compute it each time a snowflake is drawn; see CWinterVisualization::CreateSnow for more details.
Don't forget that we're in the native C++ world and we have to release memory! The article won't cover the memory deallocation, but you can find it insideCWinterVisualization::FinalRelease. Rendering the Elapsed Time
CWinterVisualization::DrawText renders the elapsed time in the top-right corner; use this method when you want to see how frequent yourCWinterVisualization::Render gets called by Windows Media Player.
414void CWinterVisualization::DrawText(TimedLevel * pLevels, HDC hdcMem, RECT rcMem)
415 {
416// don't display elapsed text when screen is too small
417if (rcMem.bottom < 240)
418return;
419
420 HFONT hfOld = static_cast<HFONT>(SelectObject(hdcMem, hfElapsed));
421
422 SetBkMode(hdcMem, TRANSPARENT);
423 SetTextAlign(hdcMem, TA_RIGHT | TA_TOP);
424 SetTextColor(hdcMem, RGB(255, 255, 255));
425
426/* Convert time stamp to string */
427 TCHAR tcElapsed[32];
428if (_i64tot_s(pLevels->timeStamp, tcElapsed, _countof(tcElapsed), 10) 0)
429 TextOut(hdcMem, rcMem.right, rcMem.top, tcElapsed, static_cast<int>(_tcslen(tcElapsed)));
430
431 SelectObject(hdcMem, hfOld);
432 }
pLevels->timeStamp is measured in 100 nanoseconds and indicates the elapsed time inside the playing song. Be aware that the 'SelectObject' method returns the previous/old selected object in the device context; you're advised to select the old object back in the device context after you've finished working with the new one.
Rendering the Wave
If you watched the video preview, you've seen that there is a wave in the middle of the screen. TheCWinterVisualization::DrawPlus method draws plusses ('+') to build the wave (drawing plusses instead of connected lines gives a better effect).
382void CWinterVisualization::DrawPlus(TimedLevel * pLevels, HDC hdcMem, RECT rcMem)
383 {
384// don't display plus line when screen is too small
385if (rcMem.right < 240)
386return;
387
388 HFONT hfOld = static_cast<HFONT>(SelectObject(hdcMem, hfPlus));
389
390 SetBkMode(hdcMem, TRANSPARENT);
391 SetTextAlign(hdcMem, TA_RIGHT | TA_TOP);
392switch (m_nPreset)
393 {
394case PRESET_FLAKE:
395 SetTextColor(hdcMem, RGB(176, 226, 255));
396break;
397case PRESET_FLAME:
398 SetTextColor(hdcMem, RGB(255, 64, 64));
399break;
400 }
401
402 TCHAR tcPlus[] = TEXT('+');
403 INT iPlusLen = static_cast<INT>(_tcslen(tcPlus));
404for (INT i = 0; i < SA_BUFFER_SIZE; ++i)
406 INT x = static_cast<INT>(rcMem.right * i / 1024.0f);
407 INT y = static_cast<INT>(rcMem.bottom * pLevels->waveform[0][i] / 256.0f);
408 TextOut(hdcMem, x, y, tcPlus, iPlusLen);
409 }
410
411 SelectObject(hdcMem, hfOld);
412 }
This method depends on the currently selected preset and changes the color of the wave: blue for Flakes and red for Flames. https://everinvestments473.weebly.com/blog/bosch-pst-52a-manual-transfer. We'll be rendering only the first channel (mono) waveformpLevels->waveform[0]. If you decide to use both channels (stereo), you'll have to usepLevels->waveform[0] and pLevels->waveform[1]; if the song is mono, then the second array is undefined (take care)! The method scales the values to the canvas size and draws the linked plusses.
Creating a Koch Snowflake
CWinterVisualization::CreateSnow computes the Koch Snowflake as described on theMathWorld Web Site. We construct an equilateral triangle with 3 vertices and start iterating: at the first iteration we have a polygon (which starts to resemble with a snowflake) with 12 vertices; at the second iteration we have a better snowflake/polygon with 48 vertices.. at the fifth iteration we have a snowflake with 3072 vertices.
272void CWinterVisualization::CreateSnow()
273 {
274/* Create Koch */
275 pKoch = new POINT * [iKochCount];
276
277/* Frames */
278for (INT w = 0; w < iKochCount; ++w)
279 {
280/* Initialize Koch Fractal Snowflake with the equilateral triangle */
281 INT iVertexNowCount = 3;
282 POINT * pVertexNow = new POINT[iVertexNowCount];
283
284 INT iSize = (SNOW_MIN_SIZE + w * SNOW_STEP_SIZE) / 2;
285 pVertexNow[0].x = - iSize; pVertexNow[0].y = 0; // A
286 pVertexNow[1].x = + iSize; pVertexNow[1].y = 23; // B
287 pVertexNow[2] = MakeEqTriangle(pVertexNow[0], pVertexNow[1]); // C
288
289/* http://mathworld.wolfram.com/KochSnowflake.html */
290for (INT q = 1; q < KOCH_IT + 1; ++q)
291 {
292 INT iVertexNewCount = iVertexNowCount * 4;
293 POINT * pVertexNew = new POINT[iVertexNewCount];
294
295for (INT i = 0; i < iVertexNowCount; ++i)
296 {
297 INT j = (i + 1) % iVertexNowCount;
298
299 POINT pA = pVertexNow[i];
300 POINT pE = pVertexNow[j];
301
302 LONG lWidth = pE.x - pA.x;
303 LONG lHeight = pE.y - pA.y;
304
305 POINT pB;
306 pB.x = pA.x + lWidth / 3;
307 pB.y = pA.y + lHeight / 3;
308 POINT pD;
309 pD.x = pA.x + lWidth * 2 / 3;
310 pD.y = pA.y + lHeight * 2 / 3;
311 POINT pC = MakeEqTriangle(pD, pB); // equilateral triangle for the inner third
312
313 INT k = i * 4;
314 pVertexNew[k + 0] = pA;
315 pVertexNew[k + 1] = pB;
316 pVertexNew[k + 2] = pC;
317 pVertexNew[k + 3] = pD;
318 }
319// move to the next Koch iteration
320delete[] pVertexNow;
321 pVertexNow = pVertexNew;
322 iVertexNowCount = iVertexNewCount;
323 }
324/* Done */
325 pKoch[w] = pVertexNow;
326 }
327 }
Rendering the Snowflakes
There are 13 (this is the default value) snowflakes that need to be rendered on the device context. When a snowflake reaches its maximum size, it gets reinitialized: its size depends on the waveform, its color depends on the preset and it's randomly distributed across the surface. Each snowflake is translated and rotated to its target position (this is required because of the precomputation where we considered the snowflake to be around x=0 and y=0).
329void CWinterVisualization::DrawSnow(TimedLevel * pLevels, HDC hdcMem, RECT rcMem)
330 {
331for (INT i = 0; i < SNOW_COUNT; ++i)
332 {
333/* Initialize snowflake when reached SNOW_MAX_SIZE */
334if (++iSnowSize[i] iKochCount)
335 {
336// size depends on waveform
337 iSnowSize[i] = iKochCount * pLevels->waveform[0][SA_BUFFER_SIZE * i / SNOW_COUNT] / 256;
338switch (m_nPreset)
339 {
340case PRESET_FLAKE:
341 iSnowColor[i] = rand() % SNOW_FLAKE_COLOR_COUNT;
343case PRESET_FLAME:
344 iSnowColor[i] = SNOW_FLAKE_COLOR_COUNT + rand() % SNOW_FLAME_COLOR_COUNT;
345break;
346 }
347// distribute snowflakes on the screen
348 pSnowPosition[i].x = rcMem.right * i / SNOW_COUNT;
349 pSnowPosition[i].y = rand() % rcMem.bottom;
350 }
351
352/* Prepare snowflake for drawing */
353 INT iVertexNowCount = static_cast<INT>(3 * pow(4.0f, KOCH_IT));
354 POINT * pVertexNow = new POINT[iVertexNowCount];
355
356for (INT j = 0; j < iVertexNowCount; ++j)
357 {
358/* Just translation */
359//pVertexNow[j].x = pKoch[iSnowSize[i]][j].x + pSnowPosition[i].x;
360//pVertexNow[j].y = pKoch[iSnowSize[i]][j].y + pSnowPosition[i].y;
361/* Translation and rotation */
362 FLOAT fAngle = pLevels->waveform[0][SA_BUFFER_SIZE * i / SNOW_COUNT] * 3.1415926535897932384626433832795f / 256.0f;
363 FLOAT fAngleCos = cos(fAngle);
364 FLOAT fAngleSin = sin(fAngle);
365 pVertexNow[j].x = static_cast<LONG>(fAngleCos * pKoch[iSnowSize[i]][j].x - fAngleSin * pKoch[iSnowSize[i]][j].y + pSnowPosition[i].x);
366 pVertexNow[j].y = static_cast<LONG>(fAngleSin * pKoch[iSnowSize[i]][j].x + fAngleCos * pKoch[iSnowSize[i]][j].y + pSnowPosition[i].y);
367 }
368
369/* Draw Koch Snowflake */
370 HPEN hpOld = static_cast<HPEN>(SelectObject(hdcMem, hpSnowColor[iSnowColor[i]]));
371
372 MoveToEx(hdcMem, pVertexNow[0].x, pVertexNow[0].y, 0);
373 PolylineTo(hdcMem, pVertexNow, iVertexNowCount);
374 LineTo(hdcMem, pVertexNow[0].x, pVertexNow[0].y);
375
376 SelectObject(hdcMem, hpOld);
377
378delete[] pVertexNow;
379 }
380 }
PolylineTo is the fastest way to draw a polygon when you use a pen with width1. The width of the pen has to be one!
Wrapping up: Blending and Rendering
So far, we've seen some methods that did something if someone called them. CWinterVisualization::Render calls those methods and in turn is called by Windows Media Player (which decides how frequent to call it). Notice the line169 which allows this method to be called only 30 times per second. Because the size of the drawing surface can change (when you resizeWindows Media Player), the device contexts are deleted and created again.
167 STDMETHODIMP CWinterVisualization::Render(TimedLevel *pLevels, HDC hdc, RECT *prc)
168 {
169if (_abs64(pLevels->timeStamp - tsPrev) < 333333)// 10^7 is 1 second; use only 30fps
170return S_OK;
171 tsPrev = pLevels->timeStamp; // keep time stamp
172
173 RECT rcMem = {0, 0, prc->right - prc->left, prc->bottom - prc->top};// memory rectangle
174
175/* Check whether drawing surface changed */
176if ((rcMem.left != rcPrev.left) || (rcMem.top != rcPrev.top) ||
Eric hanson trial begins for maine. 177 (rcMem.right != rcPrev.right) || (rcMem.bottom != rcPrev.bottom))
178 {
179 rcPrev = rcMem; // keep memory rectangle
180
181/* Delete Prev */
182if (hNewBitmapPrev)
183 {
184 SelectObject(hdcPrev, hOldBitmapPrev);
185 DeleteObject(hNewBitmapPrev);
186 }
187 hNewBitmapPrev = 0;
188 hOldBitmapPrev = 0;
189if (hdcPrev)
190 DeleteDC(hdcPrev);
191 hdcPrev = 0;
192
193/* Delete Mem */
194if (hNewBitmapMem)
195 {
196 SelectObject(hdcMem, hOldBitmapMem);
197 DeleteObject(hNewBitmapMem);
198 }
199 hNewBitmapMem = 0;
200 hOldBitmapMem = 0;
201if (hdcMem)
202 DeleteDC(hdcMem);
203 hdcMem = 0;
204
205// Make snowflakes re-initialize in DrawSnow
206for (INT i = 0; i < SNOW_COUNT; ++i)
207 iSnowSize[i] = iKochCount - 1;
208 }
209
210/* Create Prev */
211if (!hdcPrev)
212 hdcPrev = CreateCompatibleDC(hdc);
213if (!hNewBitmapPrev)
214 {
215 hNewBitmapPrev = CreateCompatibleBitmap(hdc, rcMem.right, rcMem.bottom);
216 hOldBitmapPrev = static_cast<HBITMAP>(SelectObject(hdcPrev, hNewBitmapPrev));
217 }
218
219/* Create Mem */
220if (!hdcMem)
221 hdcMem = CreateCompatibleDC(hdc);
Ing Media Player Visualization App
222if (!hNewBitmapMem)
223 {
224 hNewBitmapMem = CreateCompatibleBitmap(hdc, rcMem.right, rcMem.bottom);
225 hOldBitmapMem = static_cast<HBITMAP>(SelectObject(hdcMem, hNewBitmapMem));
226 }
227
228/* Draw background on Mem */
229 FillRect(hdcMem, &rcMem, hBrushBack);
230
231/* Blend Prev with Mem */
232 BLENDFUNCTION bfPrev = {AC_SRC_OVER, 0, SNOW_ALPHA, AC_SRC_ALPHA};
233 AlphaBlend(hdcMem, rcMem.left, rcMem.top, rcMem.right, rcMem.bottom,
234 hdcPrev, rcMem.left, rcMem.top, rcMem.right, rcMem.bottom, bfPrev);
Geforce Media Player Visualization
235
236/* Draw Snow on Mem */
237 DrawSnow(pLevels, hdcMem, rcMem);
238/* Draw Plus on Mem */
239 DrawPlus(pLevels, hdcMem, rcMem);
240
241/* Copy Mem to Prev */
242 BitBlt(hdcPrev, rcMem.left, rcMem.top, rcMem.right, rcMem.bottom,
243 hdcMem, rcMem.left, rcMem.top, SRCCOPY);
244
245/* Draw Text on Mem */
246/* Uncomment the following line to draw elapsed text in the top-right corner */
247 DrawText(pLevels, hdcMem, rcMem);
248
249/* Copy Mem to WMP */
Windows Media Visualizations
250 BitBlt(hdc, prc->left, prc->top, prc->right - prc->left, prc->bottom - prc->top,
251 hdcMem, rcMem.left, rcMem.top, SRCCOPY);
252
253return S_OK;
Media Player Visualizations Windows 10
254 }
I haven't said anything about the flicker.. how was that avoided? Take a good look at this method (especially at line250): we weren't drawing directly on the default device context as the wizard-generated visualization did, instead we were drawing on a memory device contexthdcMem which was copied to the default device context only when everything was ready. It's a simple solution and it avoids the flicker! Never draw directly to thehdc received as the argument!
What about the smooth effect? We needed the msimg32.lib, especially the AlphaBlend method which blends two device contexts together. The blend betweenhdcPrev and hdcMem lets the previous rendered scene to be drawn again with a darker shade, while the new scene is as vivid as it should be;hdcMem is saved to hdcPrev to keep it for the next rendering when it becomes the old scene. That's it! Conclusion
Winter Visualization, Snow Flakes:
Winter Visualization, Snow Flames:
You've created a beautiful winter visualization.. Watch the dancing snowflakes and download theWinter Visualization Source Code or download only the installer WinterVisualizationSetup.msi (share the Winter Visualization with your friends). I hope you enjoyed working with C++ and you like what you've learned today!
Thanks to the Microsoft Student Partners - Microsoft Academic Program Team Romania for support. Happy Holidays! ReferenceIng Media Player Visualizations DownloadBio
Paul-Valentin Borza is in its third year of study at the Babeş-Bolyai University of Cluj-Napoca, Romania. Driven by his passion for technology, he was invited in 2005 to be aMicrosoft Student Partners member - Microsoft Academic Program at theFaculty of Mathematics and Computer Science. He can be reached through his web site atwww.borza.ro or on the Windows Live Network with [email protected].
-->
Ing Media Player Visualizations
Microsoft Windows Media Player provides visualizations that enable the user to see visual imagery that is synchronized to the sound of the media content as it plays. Several standard visualizations are included with Windows Media Player, including Spikes, Bars, and DotPlane. This section of the SDK provides programming information that will enable you to create your own visualizations.
The custom visualization documentation is divided into three sections:
Related topicsComments are closed.
|
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |