nBASS: A sound libary for .NET

• Download source, bin + tests - 306 Kb

Introduction

Many times I have seen people asking in the forums for sound support for .NET. Unfortunately, we had to make do with difficult unmanaged dll's or use the media player interface. Then one day I came along a "little" sound library called BASS. This is a sound library that provides you with various static functions for playing, creating, streaming and recording sound. It has support for WAV/MP3/MP2/MP1/OGG sound formats as well a variety of popular MOD formats. With the addition of their WMA addon, the library supports WMA playback as well as WMA creation and network streaming. Having a VB.NET API on the BASS website, I used that as my starting point. NOTE: You must download the BASS and BASSWMA package from the BASS website and copy the 2 dll's to the application folder.

Design

One of the big problems with consuming unmanaged code is the fact that you do not deal directly with objects, but rather with handles to undefined objects. But more on that later. Like I said my starting point was the VB.NET "API". All it is really is a mapping to all the functions provided by the BASS dll. Still that was too unfriendly for me. I then started rewriting all the functions over to C#, and adding more meaningful functions to be used from within .NET. In the code you will notice all unmanaged calls start with an underscore (_) and they usually will have a "friendly" public counterpart.

After remapping all the functions, I started working on the class hierarchy. Several options down the line, I finally came up with a solution that would work. This was essential as several of the static functions can be preformed on a variety of objects (handles). Basically, I created a base class (ChannelBase) and let my defined objects inherit from there or from an object already inheriting from  ChannelBase. In some cases like Stream and Music, I created an intermediate abstract class (AdvancedChannel) from which they inherited. All in all, the structure works very well and saves a lot on duplicate code. Unfortunately, when consuming unmanaged dll's there always seems to be a fair amount of duplicate code (obviously having the source to BASS would have simplified things, but I am not that lucky).

Having the structure in place, I started designing my own classes for managed use. Basically, I went by wrapping a class around a handle and "hiding" the handle from the user and let him/her rather work with an object directly. On object creation, a handle would be passed to the constructor and the resulting object would be returned. I opted not to have public constructors for my objects as most need to have BASS initialized first. So once a BASS class was created, further objects can be created from there, with the exception of the CD and Record class.  They are allowed to be instantiated with public constructors.

Having objects (with handles) made it possible for me to rewrite all unmanaged functions from:

static int UnmanFunc(IntPtr handle, int someparam);

to

void ManFunc(int someparam);

All "freeing" functions from BASS dll has also been implemented into their respective finalizers, so the implementer does not have to worry about freeing up unmanaged resources. I didn't go for the IDisposable model as it seemed to create more "work" than that is supposed to prevent. UPDATE: IDisposable has been implemented.

An exception model was also implemented, by using the static GetErrorCode() function provided. In other words, the user does not check for an error, but rather wait for an exception.

An event model was also implemented for when the "sound" stops playing. The marshalling required for this was quite tricky. You can have a look inside AdvancedChannel.

Finally, it came round to testing all the functions provided by the BASS dll. There were some really "weird" (from a C# perspective anyways) marshalling to be done to get the functions to behave like they should. I had to implement some classes to solve some problems, for example the ChannelAttributes class. This is really only a "placeholder" for some variables , making life alot easier when having to modify some settings. You can also have a look at the FX class to see how I handled the void * type from my code.

Testing

I have created various test projects to test various functions. Here are some screenshots:

CD (very basic):

Stream (with stereo visualization):

Music (with 3D positioning and EAX presets):

WMAStream (with stereo visualization, playing previously encoded WMA file):

WMAEncoder (encoding to network):

Implementation

The implementation is very easy and a sound can be played with very little work.

BASS bass = new BASS(-1 , 44100, DeviceSetupFlags.Default, 
            new IntPtr(0)); //we use foreground window
bass.Start(); //we call this to INIT BASS.dll
Stream stream = bass.LoadStream(false, "test.mp3", 0, 0, StreamFlags.AutoFree);
stream.Play(true, StreamPlayFlags.Default);