MP3 Sound Recording Tool

Introduction

Here is a single dialog utility for recording from the sound card in MP3 format. This is simply a repackaging of a console application described by rtybase in an article which appeared in here on CodeProject a while ago.

Background

I have put this utility together fairly quickly as a replacement for some DOS batch files which I used to drive the mp3_stream.exe with. I then soon realised that it would be useful to add a duration timer so that a recording can be ended whilst the computer is left unattended. I found this to be particularly useful when recording longer sessions, some of which can be over six hours long.

Using the Utility

The dialog shows the settings which represent the command line arguments for mp3_stream.exe, such as the volume (value 15 is recommended), bit rate (in kilo bits per second) e.g. 128. The Device and line names are shown in dropdown list boxes. The total duration of the recording can be optionally specified, and a file name which the recording is to be saved as can be browsed for using the standard Windows Save File As dialog. All configuration settings are saved on closing down the utility, and are automatically reloaded the next time it is launched.

Windows 7 Usability Notes

Since I first published this article, more and more people started using it with post-Windows XP operating systems, naturally. The issue encountered when using Windows 7 (and Windows Vista too) is that the operating system both disables and hides the Stereo Mix device by default, even if it is available through the soundcard's driver. Overcoming this issue is fairly straightforward, as follows:

Right-click on the speaker icon in the system tray and select Recording devices (you can also bring up this dialog through Windows control panel)
Right-click inside the dialog to bring up the context menu, and select Show Disabled Devices
Again, right-click inside the dialog to bring up the context menu, and this time select Show Disconnected Devices
The above two steps will make Stereo Mix visible, right-click on it and select Enable
Close the dialog by pressing the OK button

Now the next time you launch the utility, you will be able to select the Stereo Mix device and Master Volume line.

How the Code Works

mp3_stream.exe itself is a C++ application, which uses the LAME open source library to carry out the MP3 encoding. To communicate to LAME using a .NET application, one could go about this in several ways. For example, one could add a thin interface layer of managed C++ to the mp3_stream.exe source code and recompile it so that it can be accessed via .NET. Or, one could add a thin interface layer on the C# project side (using [DllImport]) to access the LAME DLL functionality directly.

However, mp3_stream.exe does in fact already provide an API which is perfectly accessible from .NET. This is perhaps not what one would normally think of as an API in a conventional sense, because it is simply the command line arguments supported by mp3_stream.exe. Nevertheless, it is a programmable interface which provides access to the desired functionality perfectly well. For example, to enumerate the sound cards supported by the system, mp3_stream.exe is invoked with a -device argument. To do this programmatically, System.Diagnostics.Process is used to spawn a mp3_stream.exe process providing it with the appropriate arguments. This is done by the Execute method, which in turn calls the InitiateMP3StreamProcess method:

private void InitiateMP3StreamProcess(Process proc, string arguments)
{
    proc.StartInfo.CreateNoWindow = true;
    proc.StartInfo.WorkingDirectory = Application.StartupPath;
    proc.StartInfo.FileName = "mp3_stream.exe";
    proc.StartInfo.Arguments = arguments;
    proc.StartInfo.UseShellExecute = false;
    proc.StartInfo.RedirectStandardOutput = true;
    proc.StartInfo.RedirectStandardError = true;
    proc.StartInfo.RedirectStandardInput = true;
    proc.Start();
}

private List<string> Execute(string command)
{
    Process devicesProc = new Process();
    InitiateMP3StreamProcess(devicesProc, command);
    devicesProc.WaitForExit();

    List<string> response = new List<string>();
    string line;
    while ((line = devicesProc.StandardOutput.ReadLine()) != null)
    {
        response.Add(line);
    }

    return response;
}

The method Execute is called with a string which specified the command line argument which needs to be passed to the mp3_stream.exe process:

Execute("-devices");

This is used, in conjunction with using the -device argument, to iteratively populate the DeviceLines dictionary with all the available devices and lines:

private void PopulateDevices()
{
    List<string> devices = Execute("-devices");
    foreach (string device in devices)
    {
        Devices.Items.Add(device);

        DeviceLines.Add(device, new List<string>());
        List<string> lines = Execute(string.Format("-device=\"{0}\"", device));
        foreach (string line in lines)
        {
            DeviceLines[device].Add(line);
        }
    }
}

Saving and Retrieving the Configuration

For added convenience, the tool automatically saves its current configuration on exit. This configuration is then reloaded the next time the tool is launched. This is achieved by handling the form's FormClosing and Load events:

private void Record_FormClosing(object sender, FormClosingEventArgs e)
{
    SaveCurrentConfiguration();
}

private void Record_Load(object sender, EventArgs e)
{
    RestorePreviousConfiguration();
}

The SaveCurrentConfiguration and RestorePreviousConfiguration methods in turn use the Settings class to access the application configuration parameters:

private void RestorePreviousConfiguration()
{
    Settings config = Settings.Default;
    Volume.Text = config.Volume;
    BitRate.Text = config.BitRate;
    if (Devices.Items.Contains(config.Device))
    {
        Devices.SelectedItem = config.Device;
    }
    if (Lines.Items.Contains(config.Line))
    {
        Lines.SelectedItem = config.Line;
    }
}

private void SaveCurrentConfiguration()
{
    Settings config = Settings.Default;
    config.Volume = Volume.Text;
    config.BitRate = BitRate.Text;
    if (Devices.SelectedItem != null)
    {
        config.Device = Devices.SelectedItem.ToString();
    }
    if (Lines.SelectedItem != null)
    {
        config.Line = Lines.SelectedItem.ToString();
    }

    config.Save();
}

Recording

Once configured and the Record button is pressed, the utility displays the time left for the recording to complete. This is done using a timer, which updates a progress bar and a textual display of time remaining:

private void UpdateTimeRemaining(TimeSpan timeSpan)
{
    TimeRemaining.Text = string.Format("Time remaining: {0}:{1}:{2}",
	timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds);
}

private void Timer_Tick(object sender, EventArgs e)
{
    DateTime timeNow = DateTime.Now;
    if (timeNow >= EndTime)
    {
        OnStopRecording();
    }
    else
    {
        TimeSpan timeRemaining = EndTime - timeNow;
        UpdateTimeRemaining(timeRemaining);
        TimeSpan timeElapsed = timeNow - StartTime;
        TimeSpan totalDuration = EndTime - StartTime;
        double percentageElapsed =
         (timeElapsed.TotalMilliseconds / totalDuration.TotalMilliseconds) * 100;
        if (percentageElapsed > 0)
        {
            Progress.Value = (int)percentageElapsed;
        }
        else
        {
            Progress.Value = 0;
        }
    }
}

The recording operation itself is invoked by the Click event handler of the Record button:

private void StartRecording_Click(object sender, EventArgs e)
{
    string args = 	string.Format
	("-device=\"{0}\" -line=\"{1}\" -v={2} -br={3} -sr=32000",
            Devices.SelectedItem.ToString(),
            Lines.SelectedItem.ToString(),
            Volume.Text,
            BitRate.Text);

    RecordingProc = new Process();
    InitiateMP3StreamProcess(RecordingProc, args);
    StartRecording.Enabled = false;
    StopRecording.Enabled = true;

    // Use timed recording if user has specified a duration,
    // otherwise do not initiate the timer and simply return.
    TimeSpan recordingDuration = new TimeSpan(Duration.Value.Hour,
                                              Duration.Value.Minute,
                                              Duration.Value.Second);
    if(recordingDuration.TotalSeconds == 0)
        return;

    StartTime = DateTime.Now;
    EndTime = StartTime.Add(recordingDuration).AddSeconds(TimerFudgeFactor);
    Timer.Start();
}

You may have noticed TimerFudgeFactor and wondered why it is needed. I found that the total time of recordings made using mp3_stream.exe is always shorter than expected by around 3 seconds. This could be an artefact of the encoding process throwing away a small chunk of data at the end of its buffer for some reason. TimerFudgeFactor has a value of 3 (seconds) and seems to work reasonably well for short and long recording alike.

And Finally...

I hope that you find this utility useful. I have certainly had made a lot of use out of the original mp3_stream.exe application, and thought it would be good to contribute back to CodeProject by posting these usability improvements.