I upgraded my app from Windows Forms to WPF. One of the high points of the app was the spectrum supplied with BASS.NET, and I definitely wanted to take that along with me. I've written a small guide for other people who want to do the same.
In case you haven't seen the visualisations, take a look at Simple.cs in the samples – they're great. Essentially, the functions draw bitmaps of the music during the timer tick event, and putting the bitmaps on controls works like an animation.
WPF introduced a new way of handling bitmaps. Windows Forms uses items from the System.Drawing namespace. WPF uses System.Windows.Media.Imaging, a different Bitmap object, plus a different way of initialising it.
The strategy was to translate the bitmap in memory. Then there were two threading issues to solve. First, WPF threading is much less forgiving in general. With Windows Forms I had a PictureBox, and changing the image "just worked", even though I was calling the UI from a music-playing thread. WPF complains. Therefore you need to call the UI with a delegate function, using the Dispatcher from the UI thread.
There's one more threading complication. Because of the new bitmap style, you can't send bitmaps across threads. A WPF bitmap is initialised by setting the .Source member, and initialisation happens when it's appropriate. WPF still complains, (probably) because the Stream assigned to the .Source member is on the music-playing thread. The workaround is to convert the bitmap to a byte array, send the array across the threads, and then convert it to a bitmap after it reaches the UI thread. It's a little roundabout, but it does the job.
Here's how it works.
// In the class definition, before the constructor:
public delegate void DrawMeterDelegate(Byte [] buffer);
/// <summary>
/// Slightly altered Drawing function (mSpectrumBackground and mUiDispatcher set elsewhere)
/// </summary>
/// <param name="width">Bitmap width</param>
/// <param name="height">Bitmap height</param>
private void DrawSpectrum(int width, int height)
{
System.Drawing.Bitmap bitmap;
Byte [] buffer;
try
{
bitmap =
mPlayerVisuals.CreateSpectrumLinePeak(mPlayerStream, width, height,
System.Drawing.Color.LightBlue, System.Drawing.Color.SlateBlue, System.Drawing.Color.Cyan,
mSpectrumBackground, 2, 1, 2, 10, false, false, false);
}
catch
{
return;
}
if (bitmap != null)
{
// Convert bitmap to byte[] array
buffer = DrawingToBuffer(bitmap);
// Update control with UI dispatcher we passed ourselves elsewhere
mUiDispatcher.Invoke(new DrawMeterDelegate(DrawMeter), buffer);
}
}
/// <summary>
/// Converts a System.Drawing.Bitmap to a byte [] array
/// </summary>
/// <param name="drawingBitmap">Bitmap to convert</param>
/// <returns>Byte [] array</returns>
private byte [] DrawingToBuffer(System.Drawing.Bitmap drawingBitmap)
{
MemoryStream ms;
Byte[] buffer;
ms = new MemoryStream();
drawingBitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
buffer = new byte[ms.Length];
buffer = ms.ToArray();
ms.Dispose();
return buffer;
}
/// <summary>
/// On the UI thread, translates a bitmap, and sets the Image control named "Meter" (reference passed elsewhere)
/// </summary>
/// <param name="buffer">System.Drawing.Bitmap as byte[] array</param>
private void DrawMeter(byte [] buffer)
{
BitmapImage bitmapImage;
MemoryStream ms;
ms = new MemoryStream(buffer);
bitmapImage = new System.Windows.Media.Imaging.BitmapImage();
ms.Seek(0, SeekOrigin.Begin);
// Create the bitmap in risk-averse fashion
bitmapImage.BeginInit();
bitmapImage.CreateOptions = BitmapCreateOptions.IgnoreColorProfile;
bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
bitmapImage.StreamSource = ms;
bitmapImage.EndInit();
// Get rid of memory stream
ms.Dispose();
// Assign new bitmap to Image control
Meter.Source = bitmapImage;
}
