7 posts tagged “audio”

Remember a long time ago we built a few neat audio tools together? Then if you remember even further back I talked a bit about my involvement with some helpdesk systems. Well, we're going to revisit pieces of those in order to build something spectacular. We are going to build our own home-grown conference software. Here's a few ideas I had in mind for this:

Chatters

Chatters are little dots that radiate sound. Whenever someone logs-in or is available to talk to, or is in the queue to be talked to, then the little dot pops up on your desktop. If you click on the dot you can get more information about the person and options to talk with them.

Group Chatter

When you want to hold a conference you simply have to group a few people up together into a roughly drawn circle. A brush on the desktop to draw that circlish figure and dragging your buddies in there. Of course, this would have to notify the intending parties that a conference is being held, to which they may or may not join.

Let's start with those first and work our way up.

    In the absence of my coding articles I have created a starter kit for creating audio-visuals with the Bass.NET API. With this starter kit you will be able to have a nice starting point to work with Bass and different audio-visual techniques. The kit, once installed, can be run by hitting F5. You can immediately load up any of your favorite songs or a simple Shoutcast playlist. In a few of my future articles I will introduce some techniques for creating audio-visuals including: bars, waves and ambient lighting. Let's take a quick look at Adosi from where it stands.

Adosi-Starter

• Adosi Audio Starter Kit

• Visual C# Express 2008
• Bass.NET API 2.4

Bars Audio-Visual
    Before we can create our own audio-visual, we must first understand how most audio-visuals actually work. The idea is based on tracking two distinct variables in all audio: frequency and amplitude. In our case, to create an equalizer all we need to do is average amplitude values into a number of sections. The Bass api contains a simple method for obtaining all this data in the following snippet:

Bass.BASS_ChannelGetData(handle, buffer, length);

BASSData.BASS_DATA_FFT2048
    - you can use any of the given values in the enumeration. Note the actual length in the comments (where 2048       FFT actually refers to 1024 allocated to a single buffer.

    If you remember from my previous tutorial on Recording audio in C#, streaming from the microphone was quite simple. Within about 10 minutes of coding you were able to create a recording application that worked with any recording device plugged into or connected to your machine. In another article, I talked about my XNA TCP Networking API. In this article, I'm going to show you how easy it is to create your own voice chat application using the two apis. In this article I will be teaching you the following techniques:

• Streaming audio from the microphone
• Sending audio data over the network
• Playing network audio data back
  

• Visual C# Express
• TCP Networking API
• Bass.NET 2.4 (download the zip in the forum)
• Un4seen Bass 2.4 (download the zip in the forum)

VoiceChat-CreateProject

Voicechat-solution

    Next, we need to build the playback stream as well as the recording stream. Create a new C# class called RecordUtil. This class will contain the bare minimum necessities for recording audio and obtaining buffers to be sent and played back. We need to add the following methods to it.

• Init - Should initialize recording and audio devices
• Record - Should create the playback and recording streams
  
• Play - Should play the playback and recording streams
  
• Stop - Should stop all playback and recording
• Free - Should free all resources and streams
  
• PlayBuffer - Should play a byte stream buffer
• SendBufferHandler - Delegate for sending a buffer.

    First, the Init method. To do this, we need to use the Bass.BASS_RecordInit method. We will also use the Bass.BASS_Init method to initialize the audio playback that we will use to play a byte stream buffer.

VoiceChat-Init

    This method will first initialize the default recording device followed by initializing the default audio playback device and allocating that device stream by the 8Bit flag or byte flag. The 8Bit flag correlates to our byte output stream that we will later deal with on the recording callback function. Next, the Record method.

VoiceChat-Record

   Within this method there are three field level variables being used: myRecordProc, recordStream, and playbackStream. The first, myRecordProc, is the delegate that refers to the callback on each sample recorded from Bass. The second, recordStream, refers to the actual handle created when starting the recording channel and it is designated as an int. You can see that in Bass.BASS_RecordStart the first parameter refers to the sampling rate (44100), the second as mono output, the third as the starting flags, the fourth as the period (in milliseconds) between each sample callback, the fifth referring to the callback, and the user.

    Lastly, playbackStream, uses a new feature in Bass 2.4 called push streaming. Push streaming gives us the ability to create a stream and effectively push a byte stream buffer in order to create playback. Nice, huh!? We simply pass in the frequency (sample rate) of 44100, set the channels to mono, pass in the default bass flag, and the user.

VoiceChat-SendBufferCallback

    For the MyRecording method we will need to first create a callback method that we will later use in the network. I have created the delegate SendBufferCallback with the parameters being a byte[] buffer and the integer length. I have then created the local delegate variable callback and added the parameter to the constructor of RecordUtil. Now that the callback is in place we can fill in the MyRecording method.

VoiceChat-BufferCallback

    At each sample callback, we will reallocate the local myBuffer byte array when either the local buffer is null or the sample buffer length is greater than the local. It would be unwise to allocate at every interval as new can be quite costly. Next, we use the Marshal.Copy method to copy the IntPtr buffer memory into our local myBuffer at index 0 and the length being the parameter length. Lastly, we simply trigger our callback function passing in the two variables.

   
    As I mentioned before Bass provides a new push streaming feature to actually provide the stream with a buffer in order to playback. This is done with the Bass.BASS_StreamPutData method.

VoiceChat-PlayBuffer

    The last thing we need to do for our RecordUtil is provide the Play, Stop, Free and destructor methods. We will use the corresponding Bass calls to perform each action.

VoiceChat-Lastly

    And there we have it! A fully functional recording utility that we can use for the rest of this project. We need a user interface to support what we want from our application, let's design that now. At the very least, our application will be able to connect to an existing voice chat session or create a local one.

VoiceChat-UI

1 comment

Each button refers to a call associated with the Session class located in the Networking api. Let's move into that now.
Networking
    This TCP Networking API was built with bare minimum requirements for a stable TCP Network implementation. It is enhanced with a few features like multithreaded callbacks with the ability to throttle expected transfer rates. The newest addition is the Session class. This class allows you to create servers and clients fairly easily. Create a new class called NetworkUtil. We will add our network layer to the application within it. We will accomplish the following:

• Constructor - Should call Session.Init to initialize the network api.
• Join - Should call Session.Join passing in the destination ip and port
• Leave - Should call Session.Leave passing in the session id
• Create - Should call Session.Create passing in the local service port to start on
• Close - Should call Session.Close passing in the session id to close the server
• Send - Should call Session.SendData passing in the byte stream buffer and session id (as a client)
• Send - Should call Session.SendData passing in the byte stream buffer, client, and session id (as the server)

VoiceChat-SessionInit

    See, couldn't be easier. To join any session, you use the Session.Join method. All network sessions are managed via Dictionary, so we need to specify the name of the session for later reference. As well, we need to provide the ip address and port number. The method also requires a callback function for when data arrives from the server.

VoiceChat-SessionJoin

     We'll get to filling in that method a little later when we know what the data will contain specifically. The api also allows you to wire to events that occur on the client or server-side. There are quite a few events, the only one we really need to worry about is the StateChanged event. The StateChanged event will let us know what connection state we are in with reference to an AsyncClient.

VoiceChat-StateChanged

     As you can see, it makes since to stop recording and sending data when we're not connected and vice-versa we should start sending and recording as soon as we are connected. The only issue here is that we would be coupling our RecordUtil with our NetworkUtil if we coded it this way. We need to create two events. Start and Stop.

VoiceChat-Events

     With these two events, we can reuse them with our AsyncServer component. To finish, we need to replace the comments with the triggering of these two events. We can also fill in our Leave method at this time.

VoiceChat-StateLeave

   Next on the list is the Session Create method. Creating your own session works very much like joining one. The only difference is that you will be creating the session on your local ip address and you pass in the port. We can use the same StateChange event in the AsyncServer class located in the Session.OpenSessions dictionary. However, we will only need to worry about the ServerState.Shutdown to Stop. Starting will depend on when a client joins, as well stopping when our only client disconnects. Wire to the events and fill in the code below.

VoiceChat-Create

VoiceChat-State

    The session gets created with the given session id, port and client data callback. The client callback is necessary for being able to receive data from more than one client at a time. In our case, we will be only dealing with a Peer-to-Peer voice chat so the SocketManager client will be of no use to us. Again, since we haven't specified what the data is going to look like we can't be sure to fill that code in yet. Fill in the Close session with the code below.

VoiceChat-Close

   Almost done, we need to fill in the Send method. Since the data will be virtually the same, we will follow the delegate heading for SendBufferCallback in the RecordUtil class. The next step will be to write the length into a new packet along with the buffer being sent. After that, we can send the data to it's rightful owner.

VoiceChat-Send

   The nice part about the Networking API is that sending data can be as seamless as you like. The SendData in the Session class is overloaded. You may send the data to a specific destination, or send the data to the the endpoint. The key on this method is that if you attempt to send data as a server, it assumes you mean to Broadcast the data. You can access the all the clients within a given created server with the OpenSessionClients property. Also, if you're not connected the session class will simply throw your packet away before even getting to the sockets.

    In the last part, receiving the data, we will create one final event called Receive which will effectively just pass the  byte stream buffer. If you noticed in the Send method we wrote the length to the buffer and then we wrote the actual byte stream based on the length provided.

VoiceChat-Receive

   To receive the actual data, we need to first find out the length of the buffer. Then once we know that, we simply grab the bytes from the data and trigger the Receive event. (Simply declare a new EventHandler called Receive at the top). You'll notice that in each of the Receive and Send I am using the number 4. I use 4 because an int is four bytes.
Finale
    Excellent! I think we're ready to finish off the last details in our application. Open up the code-behind for Form1.cs. Declare two variables at the top for RecordUtil, and NetworkUtil. Next, override the onload method. In this method, create initialize the two variables and wire to each of their events. As well, we will call the RecordUtil's Init method. Be sure to wire NetworkUtil's SendBuffer event to NetworkUtil's Send method.

VoiceChat-FormLoad

   To ensure that our UI looks superb we will disable portions when the session has started, and enable them when the session has stopped. We can also change the text of the buttons from "Join" to "Leave" (or "Create to Close") and vice-versa. With each event in the Form code there won't be much code to insert.

VoiceChat-Anon

    When the networker determines that the session can start, the recorder can begin recording. As well, the ui can then be disabled via a method we will create in a moment. When the networker stops, the recorder should stop the recording and free the streams; as well, the ui can be enabled.

    NOTE: Because this is called asynchronously we need to use the BeginInvoke method to switch to the UI thread when we are using it. To do this we simply use the EmptyDelegate that we declared at the top and use anonymous syntax to invoke.

    Now we can fill in the Enable and Disable ui methods. The buttons will change text depending on which was pressed and all the other fields will be enabled or disabled.

VoiceChat-Joining

    The ui is changed based on which button is enabled (btnJoin or btnCreate). In order to make the right calls to the networking class, we need to first add the button click methods to our code. The easiest way to do this is check the text of the button to determine what action to take. ("Create" should call create, "Close" should call close, "Join" should call join, and "Leave" should call leave.

VoiceChat-btnCreate

VoiceChat-btnJoin

    We need to call network_start when we join a session because the api will already have finished it's code structure before we can even wire to the event. As well, we need to call disable ui when btnCreate is pressed because the start event is triggered when the client joins.
We're Done!
    Congratulations! You have successfully created your own Voice Chat program. To test it, put the executing assemblies on one computer and another on your computer. To determine what your IP address is, just type ipconfig in the command prompt. (Your firewall may ask you to allow the service to run.) If you both have microphones you should be hearing each other talk with an incredible quality of sound. There are plenty of upgrades we can make to this program, but we got the basics across.

Up until now, the tutorials on this blog have been about a few multimedia concepts including: streaming audio, recording from the microphone, playing internet radio, loading playlists and even networking. In this tutorial you will learn how to accomplish the following:

• Load a video from the file system and play it

• Visual C# Express
  
• Bass.NET 2.4 (click on forums under Bass, should be a topic on Bass.NET 2.4)
  
• Un4seen Bass api (version 2.4 beta) (click on forums, find bass 2.4 beta.)
  
• BassVideo (unofficial release of the bassvideo delphi api created by KSoft)
  

unit BassVideo;

interface

uses Windows;
const // video display
      BassVideoDLL = 'bassvideo.dll';
      BassVideo_Renderer           = $100; // for BassVideo_GetConfig/SetConfig

      BassVideo_Default            = 0;
      BassVideo_VMR9               = 1;
      BassVideo_VMR9_Windowless    = 2;
      BassVideo_EVR                = 3;
      BassVideo_Overlay            = 4;
      BassVideo_NOVIdeo            = 5;
      // action
      BassVideo_OpenDone     = 1;
      BassVideo_Buffering    = 2;
      BassVideo_FoundVideo   = 3;

//      BassVideo
type TVideoSync = procedure(Action, param1, param2, user : DWORD);
     VIDEOPROC = procedure(Handle : DWORD; Action, param1, param2, user : DWORD); stdcall;
     HSTREAM = DWORD;
     TAudioInfo  = record
       Channels  : integer;
       Frequency : integer;
       Bit       : integer;
       Float     : BOOL;
       SPDIF     : BOOL;// reserverd, currently not supported!
       DTS       : BOOL;// reserverd, currently not supported!
     end;

     TVideoType = (RGB8, RGB32, RGB24, RGB16, YUY2, YUV,
                   // reserved type, not supported at this time :(
                   YV12, YUV12, YVYU, UYVY, YUY9, Y800);//, 444P, 422P 411P );

     PCodecName = ^TCodecName;
     TCodecName = array[0..100] of char;

     TVideoInfo  = record
       Height : integer;
       Width  : integer;
       VideoType : TVideoType;
       Codec  : PCodecName;
     end;

    QWORD = int64;

function BassVideo_ErrorGetCode : integer; stdcall; external BassVideoDLL;
function BassVideo_StreamCreate(FileName : Pointer; Flags, BassFlags : DWORD; CallBackProc : VIDEOPROC) : DWORD; stdcall; external BassVideoDLL;
procedure BassVideo_SetConfig(Option : DWORD; Value : DWORD); stdcall; external BassVideoDLL;
function BassVideo_GetConfig(Option : DWORD) : DWORD; stdcall; external BassVideoDLL;

function BassVideo_Play(handle: DWORD; restart : BOOL) : BOOL; stdcall; external BassVideoDLL;
function BassVideo_Stop(handle: DWORD) : BOOL; stdcall; external BassVideoDLL;
function BassVideo_Pause(handle: DWORD) : BOOL; stdcall; external BassVideoDLL;
function BassVideo_SetPosition(handle: DWORD; pos: QWORD): BOOL; stdcall; external BassVideoDLL;
function BASSVideo_GetPosition(handle: DWORD): QWORD; stdcall; external BassVideoDLL;
function BASSVideo_GetLength(handle: DWORD): QWORD; stdcall; external BassVideoDLL;
procedure BassVideo_StreamFree(handle: DWORD); stdcall; external BassVideoDLL;
function BassVideo_Init : BOOL; stdcall; external BassVideoDLL;
procedure BassVideo_Free; stdcall; external BassVideoDLL;

// for video windows function
procedure BASSVideo_SetVideoWindow(handle : HSTREAM; VideoWindowHandle : THandle; VideoRect : TRect); stdcall; external BassVideoDLL;
procedure BASSVideo_Repaint(handle : HSTREAM; WinHandle : HWND; DC : HDC); stdcall; external BassVideoDLL;
procedure BassVideo_WindowResize(handle : HSTREAM; Rect : TRect); stdcall; external BassVideoDLL;
procedure BassVideo_WindowMove(handle : HSTREAM; Msg : DWORD; wParam, lParam : LongInt); stdcall; external BassVideoDLL;
function BassVideo_SetFullScreen(handle : HSTREAM; FullScreen : BOOL) : BOOL; stdcall; external BassVideoDLL;

implementation

end.

Before I move into explaining what the above code is doing, I would first like to give a brief overview on the history of delphi and it's architect Anders Hejlsberg.

Delphi, officially Borland Delphi and chief architected by Anders Hejlsberg, is known as one of the first RAD tools when it was released in 1995 for 16-bit Windows 3.1. Delphi 2, released a year later, supported 32-bit Windows environments, and a C++ variant, C++ Builder, followed a few years after. Hejlsberg would later move to Microsoft in 1996, where he worked on Visual J++, and was a key participant in the creation of the Microsoft .NET Framework, becoming the chief designer of C#.

In 2001 a Linux version known as Kylix became available. However, due to low quality and subsequent lack of interest, Kylix was abandoned after version 3.

Support for Linux and Windows cross platform development (through Kylix and the CLX component library) was added in 2002 with the release of Delphi 6.

Delphi 8, released December 2003, was a .NET-only release that allowed developers to compile Delphi Object Pascal code into .NET CIL. It was also significant in that it changed its IDE for the first time, from the multiple-floating-window-on-desktop style IDE to a look and feel similar to Microsoft's Visual Studio.NET. But still, the new IDEs have the "Classic Undocked" windows layout available, for a classical look and feel.

[Borland Delphi History]

Okay, now that that's underway, we can see that we can compare a few object-oriented concepts from C# to that of Delphi. The first on the list is constants.

All of the variables BassVideoDLL, BassVideo_Renderer, BassVideo_Default are considered constants in delphi. As such, we can create those constants in our own class, BassVideo.

Constants

Delegate

Struct

     TVideoType = (RGB8, RGB32, RGB24, RGB16, YUY2, YUV,
                   YV12, YUV12, YVYU, UYVY, YUY9, Y800);//, 444P, 422P 411P );

We can replicate this like we would create any enum as in the following code snippet.

Enum

Struct2

Now that that's done we can move onto functions and procedures. A procedure in delphi is a method that does not return anything in C#. (Or it returns void). The only catch here is that in order to use each of these functions as a reference from C#, we need to use the DllImport attribute. We can import any unmanaged dll into C# by using this attribute in the following manner.

[DllImport("nameofdll.dll")]

If you notice, many of the definitions in the delphi header include the stdcall variable name. Stdcall is a calling convention where subprogram parameters are pushed onto the stack by the caller from right to left. The callee (and not the caller) is responsible the stack on it's routine exit. This calling convention is the default when using the DllImport attribute, however we may specify it in the constructor as a Named Parameter. So, by the end of the definitions your code may look something like the following.

    public class BassVideo
    {
        // Video display
        public const string BassVideoDLL             = "bassvideo.dll";
        public const int BassVideo_Renderer          = 100;

        public const int BassVideo_Default           = 0;
        public const int BassVideo_VMR9              = 1;
        public const int BassVideo_VMR9_Windowless   = 2;
        public const int BassVideo_EVR               = 3;
        public const int BassVideo_Overlay           = 4;
        public const int BassVideo_NOVIdeo           = 5;

        // Action
        public const int BassVideo_OpenDone          = 1;
        public const int BassVideo_Buffering         = 2;
        public const int BassVideo_FoundVideo        = 3;

        public delegate void VIDEOPROC(int Handle, int Action, int param1, int param2, int user);

        public struct TAudioInfo
        {
            public int Channels;
            public int Frequency;
            public int Bit;
            public bool Float;
            public bool SPDIF;
            public bool DTS;
        }

        public enum TVideoType
        {
            RGB8, RGB32, RGB24, RGB16, YUY2, YUV, YV12, YUV12, YVYU, UYVY, YUY9, Y800
        }

        public struct TVideoInfo
        {
            public int Height;
            public int Width;
            public TVideoType VideoType;
            public IntPtr Codec;
        }

        [DllImport("bassvideo.dll")]
        public static extern int BassVideo_GetErrorCode();

        [DllImport("bassvideo.dll")]
        public static extern int BassVideo_StreamCreate(string FileName, int Flags, int BassFlags,
                VIDEOPROC CallBackProc);

        [DllImport("bassvideo.dll")]
        public static extern void BassVideo_SetConfig(int Option, int Value);

        [DllImport("bassvideo.dll")]
        public static extern int BassVideo_GetConfig(int Option);

        [DllImport("bassvideo.dll")]
        public static extern bool BassVideo_Play(int handle, bool restart);

        [DllImport("bassvideo.dll")]
        public static extern bool BassVideo_Stop(int handle);

        [DllImport("bassvideo.dll")]
        public static extern bool BassVideo_Pause(int handle);

        [DllImport("bassvideo.dll")]
        public static extern bool BassVideo_SetPosition(int handle, long pos);

        [DllImport("bassvideo.dll")]
        public static extern long BassVideo_GetPosition(int handle);

        [DllImport("bassvideo.dll")]
        public static extern long BassVideo_GetLength(int handle);

        [DllImport("bassvideo.dll")]
        public static extern void BassVideo_StreamFree(int handle);

        [DllImport("bassvideo.dll")]
        public static extern bool BassVideo_Init();

        [DllImport("bassvideo.dll")]
        public static extern void BassVideo_Free();

        [DllImport("bassvideo.dll")]
      public static extern void BASSVideo_SetVideoWindow(int handle, IntPtr VideoWindowHandle, Rectangle rect);

        [DllImport("bassvideo.dll")]
        public static extern void BASSVideo_Repaint(int handle, IntPtr WinHandle, IntPtr DC);

        [DllImport("bassvideo.dll")]
        public static extern void BassVideo_WindowResize(int handle, Rectangle Rect);

        [DllImport("bassvideo.dll")]
        public static extern void BassVideo_WindowMove(int handle, int Msg, long wParam, long lParam);

        [DllImport("bassvideo.dll")]
        public static extern bool BassVideo_SetFullScreen(int handle, bool FullScreen);
    }

Awesome! Now all we have to do is use the api in our media player. I'm going to use the previous MyRadio application and add a few things to get it working. Open up your previous project and add the bass (version 2.4) and bassvideo library to your solution. Make sure to set the Copy to Output Directory to Output if newer. Then, replace the Bass.NET library reference to the new 2.4 version. Your solution explorer should look something like the following.

Videosolution

After that, open up the Form that you will use to display the video. Add a picture box to the form. Here is mine:

Videopicturebox

Now that we have something the display the video on, we need to modify our load code to be able to take in a video. Since there are plenty of types, we need to know whether a file is a video. Luckily, we can determine the supported types from the Bass api using the variable SupportedStreamName. This property shows the possible music extensions supported by the Bass api. I have created a function in the Player class below.

Isvideo

Now, in order to support this case when a file gets loaded we need to modify our original Load function. I have changed the original Load function to simply load in the playlist or add to it and the code that actually loads the file is in the LoadIndex function (called by the form when an index is selected on the playlist).

Loadfile

Since streaming video from the internet is currently unavailable to the api, I use the IsLocal to determine whether or not we need to use the LoadVideo, LoadSong, or LoadURL functions. Both the bassvideo and bass api use our stream declaration in the Player class. Hence, we need to declare a state when a video is loaded. Once we have that boolean set we can create the LoadVideo function below.

Loadvideo

Notice the callback variable being used in the BassVideo.BassVideo_StreamCreate method call. The callback is a delegate reference whenever the video is processed on certain actions. If you remember, one of the parameters in the delegate is Action which is an integer. We can compare this to processing states also declared as constants in the api like BassVideo.BassVideo_FoundVideo. When we have that we can call the BassVideo.BASSVideo_SetVideoWindow to our picture box that we declare before. Since the picture box is something in the form, we need to create this function in our form code.

Videoproc

Since this code is in our form code, we need to let the Player class know about it. I have modified the constructor to include the BassVideo.VIDEOPROC as a parameter. I have also added a field variable called callback.

Playerctor

NOTE:  Bass.NET version 2.4 updated the Bass_Init to use IntPtr when referring to the user. I have specified IntPtr.Zero.

In the constructor here, I am also initializing the BassVideo api by calling the BassVideo.BassVideo_Init method. The last thing we need to do is modify our Player to use either Bass or BassVideo depending on the videoLoaded boolean field. This is modified in the FreeStream, PlaySong and StopSong methods.

Videoloaded

The very last thing we need to do is update our destructor to free the bassvideo api by calling the BassVideo.BassVideo_Free method.

Dtor

And that's it! Hit F5, load up a video and see your new beauty shine. In this tutorial you learned about a new bass video api developed by a member of the Bass api community. You learned about delphi and even converted a delphi library header into C# not to mention you completed another aspect of multimedia within your media player.

Videoplayer

[Source Code]

In the previous tutorial I taught you how to use Bass to stream audio from the internet. While our radio player is amazing enough, there is, however, a missing factor in it pertaining to playlists. In this tutorial you will learn:

• How to load a playlist from an internet radio station
• How to create your own playlist

This tutorial builds off of the previous one and so you will need the following requirements.

• Visual C# Express (sorry, Visual C# Express 2005 is no longer available)
  
• Bass.NET 2.3 (scroll down until you find the .NET 2.0 link)
  
• Un4seen Bass api (top download link for Windows)

While there are a few streaming formats for playlist (ASX, M3U, XSPF) the most common playlist format is PLS. PLS as a playlist format is a fairly expressive format. The specification is listed below (via Wikipedia):

Header

• [playlist] : This tag indicates that it is a Playlist File
  
• NumberOfEntries : This variable indicates the number of tracks
  

Track Entry
Assuming track entry #X

• FileX : Variable defining location of stream.
  
• TitleX : Defines track title.
  
• LengthX : Length in seconds of track. Value of -1 indicates indefinite.
  

Footer

• Version : Playlist version. Currently only a value of 2 is valid.
  

[playlist]
NumberOfEntries=3

File1=http://streamexample.com:80
Title1=My Favorite Online Radio
Length1=-1

File2=http://example.com/song.mp3
Title2=Remote MP3
Length2=286

File3=/home/myaccount/album.flac
Title3=Local album
Length3=3487

Version=2

Knowing this format, we can read it in with a simple PLS parser to load in any PLS supported radio station. Specifically, we can support Shoutcast stations in our little media player. First, I will create a new class called PLSHelper. Using the StreamReader class, we can read in the playlist and determine where all the songs are located as well as their associated titles. First, declare the variables that are included in a playlist.

Variables

Next, create the readonly property for each of the above variables. After that, we need to actually load the playlist. The following code snippet will accomplish this using the StreamReader class.

Loadpls

CreateProperty

Indexofnonnumber

Createpropertycall

Createproperties

1=http....
2=http...
3=http....

Createpropertiescall

PlayerLoad

Playlistbox

Playlistupdate

Indexchanged

Loadcode

public void ClearPlaylist()
{
    locations = new string[0];
    titles = new string[0];
    lengths = new string[0];
    version = 2;
    pls = string.Empty;
    count = 0;
}

 And next, the Add method.

Addtoplaylist

And that's it! Call the Add method from your Player class and you should be good to go. Hit F5, load up a playlist and see your creation shine. In this tutorial you learned how to use internet radio playlist standards to load in any .pls file. As well, you were able to create your own playlist in the making of. As an extra bonus, add save functionality to your list; shouldn't be too difficult just remember to follow the playlist standard.

UPDATE: The source code also includes file loading with default program settings and it will run in a single process.
[Source code]

Internet radio, a phenomena that appeared in the early 90's that soon made it's way to it's grand stature today. Sure politics are trying to destroy it, but it's not going away any time soon. There is a great deal of history in Internet Radio from war protests to social networking. The latest advent in internet radio, Pandora, from the Music Genome Project, combines the analysis of each song to provide users the ability to listen to similar music; thus creating their own stations based on style, rhythms, lyrics and more. Nevertheless, I suggest you review the history on Wikipedia. I believe the next step in Internet Radio is playing from your mobile phone which doesn't seem that far off. [note project]

At any rate, our little music player doesn't seem to support internet radio at all. Well, I simply won't have that! Especially because supporting internet streams is so very simple with the Bass.NET api. In this tutorial you will learn to accomplish the following:

• Play streaming audio from an internet radio station.

• Visual C# Express (sorry, Visual C# Express 2005 is no longer available)
  
• Bass.NET 2.3 (scroll down until you find the .NET 2.0 link)
  
• Un4seen Bass api (top download link for Windows)

Solution

Once you have that setup look for the Player code from the previous tutorial. If you can't find it, you will find the code layout here.

We are going to modify this class to support internet radio streams. Open up the Player class and add the following code snippet.

public void LoadURL(string url)
{
    stream = Bass.BASS_StreamCreateURL(url, 0,
        BASSStream.BASS_SAMPLE_FLOAT, null, 0);
}

Bass provides this function for loading a stream from a url. In most cases, it won't matter if the stream is a file or a broadcasting stream; bass handles this for you.

You'll notice that this function looks a lot like our original. Except, instead of StreamCreateFile we are using StreamCreateURL. With the fourth parameter, specified as null, is a callback to the function to receive the stream as it's being downloaded. Also, the BASSStream contains a few flags that may allow us to obtain tags about the music including the title, author, genre and more. There are many flags that have a very specific purpose, but for now we are just going to use the default like in our previous case.

The only thing left for us to do is to provide access in our user interface. I have simply copied our previous UI and added a textbox to allow the url to be entered. When you're done, your user interface may look like the following.

Myradio

Radiocode