Saving each WAV channel as a mono-channel WAV file using Naudio

Question

I'm trying to convert a WAV file(PCM,48kHz, 4-Channel, 16 bit) into mono-channel WAV files.

I tried splittiing the WAV file into 4 byte-arrays like this answer and created a WaveMemoryStream like shown below but does not work.

byte[] chan1ByteArray = new byte[channel1Buffer.Length];
Buffer.BlockCopy(channel1Buffer, 0, chan1ByteArray, 0, chan1ByteArray.Length);
WaveMemoryStream chan1 = new WaveMemoryStream(chan1ByteArray, sampleRate, (ushort)bitsPerSample, 1);

Am I missing something in creating the WAVE headers ? Or is there more to splitting a WAV into mono channel WAV files ?

Answer 1

The basic idea is that the source wave file contains the samples interleaved. One for the first channel, one for the second, and so on. Here's some untested example code to give you an idea of how to do this.

var reader = new WaveFileReader("fourchannel.wav");
var buffer = new byte[2 * reader.WaveFormat.SampleRate * reader.WaveFormat.Channels];
var writers = new WaveFileWriter[reader.WaveFormat.Channels];
for (int n = 0; n < writers.Length; n++) 
{
    var format = new WaveFormat(reader.WaveFormat.SampleRate,16,1);
    writers[n] = new WaveFileWriter(String.Format("channel{0}.wav",n+1), format);
}
int bytesRead;
while((bytesRead = reader.Read(buffer,0, buffer.Length)) > 0) 
{
    int offset=  0;
    while (offset < bytesRead) 
    {
        for (int n = 0; n < writers.Length; n++) 
        {
            // write one sample
            writers[n].Write(buffer,offset,2);
            offset += 2;
        }           
    }
}
for (int n = 0; n < writers.Length; n++) 
{
    writers[n].Dispose();
}
reader.Dispose();

Answer 2

Based on Mark Heath's answer, I struggled with a 32 bit floating WAV containing 32 channels and managed to get it working by simplifying his proposal. I would guess this peace code also works for a four-channel audio WAV file.

    var reader = new WaveFileReader("thirtytwochannels.wav");
    var writers = new WaveFileWriter[reader.WaveFormat.Channels];
    for (int n = 0; n < writers.Length; n++)
    {
        var format = new WaveFormat(reader.WaveFormat.SampleRate, 16, 1);
        writers[n] = new WaveFileWriter(string.Format($"channel{n + 1}.wav"), format);
    }

    float[] buffer;
    while ((buffer = reader.ReadNextSampleFrame())?.Length > 0)
    {
        for(int i = 0; i < buffer.Length; i++)
        {
            // write one sample for each channel (i is the channelNumber)
            writers[i].WriteSample(buffer[i]);
        }
    }

    for (int n = 0; n < writers.Length; n++)
    {
        writers[n].Dispose();
    }
    reader.Dispose();

Answer 3

Here is a method I used, you can set the output mono format, e.g BitsPerSample, SampleRate

using NAudio.Wave;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace DataScraper.TranscriptionCenter
{
    public class MP3ToWave
    {
        /// <summary>
        /// Converts an MP3 file to distinct wav files, using NAudio
        /// They are saved in the same directory as the MP3 file
        /// </summary>
        /// <param name="MP3FileIn">The MP3 file</param>
        /// <returns>Returns the WAV files</returns>
        public static string[] MP3FilesToTranscriptionWaveFiles(string MP3FileIn)
        {
            FileInfo MP3FileInfo = new FileInfo(MP3FileIn);
            if (MP3FileInfo.Exists == false)
                throw new Exception("File does not exist? " + MP3FileIn);
            Mp3FileReader readerMP3 = null;
            WaveStream PCMStream = null;
            WaveFileReader readerWAV = null;
            List<string> ListFilesOut = null;
            WaveFileWriter[] FileWriters = null;
            MemoryStream TempStream = null;
            WaveFormatConversionStream WaveFormatConversionStream_ = null;
            WaveFormat SaveWaveFormatMono = new WaveFormat((16 * 1000), 
                    16, 
                    1);
            try
            {
                readerMP3 = new Mp3FileReader(MP3FileInfo.FullName);
                PCMStream = WaveFormatConversionStream.CreatePcmStream(readerMP3);
                WaveFormatConversionStream_ = new WaveFormatConversionStream(new     WaveFormat(SaveWaveFormatMono.SampleRate, 
                    SaveWaveFormatMono.BitsPerSample, 
                    PCMStream.WaveFormat.Channels),
                    PCMStream);
            
                //Each filepath, each channel
                ListFilesOut = new List<string>    (WaveFormatConversionStream_.WaveFormat.Channels);
            

                //Each is a wav file out
                for (int index = 0; index <     WaveFormatConversionStream_.WaveFormat.Channels; index++)
            {
                ListFilesOut.Add(MP3FileInfo.Directory.FullName + "\\" + Path.GetFileNameWithoutExtension(MP3FileInfo.Name) + "_" + index.ToString() + ".wav");
            }

            //Initialize the writers
            FileWriters = new WaveFileWriter[WaveFormatConversionStream_.WaveFormat.Channels];
            for (int index = 0; index < WaveFormatConversionStream_.WaveFormat.Channels; index++)
            {
                FileWriters[index] = new WaveFileWriter(ListFilesOut[index], SaveWaveFormatMono);
            }


            TempStream = new MemoryStream(int.Parse("" + WaveFormatConversionStream_.Length));
            WaveFileWriter NewWriter = new WaveFileWriter(TempStream, WaveFormatConversionStream_.WaveFormat);
            byte[] BUFFER = new byte[1024];
            int ReadLength = WaveFormatConversionStream_.Read(BUFFER, 0, BUFFER.Length);
            while (ReadLength != -1 && ReadLength > 0)
            {
                NewWriter.Write(BUFFER, 0, ReadLength);
                ReadLength = WaveFormatConversionStream_.Read(BUFFER, 0, BUFFER.Length);
            }
            NewWriter.Flush();
            
            

            TempStream.Position = 0;
            readerWAV = new WaveFileReader(TempStream);
            
            float[] buffer = readerWAV.ReadNextSampleFrame();
            
            while(buffer != null && buffer.Length > 0)
            {
                for(int i = 0; i < buffer.Length; i++)
                {
                    FileWriters[i].WriteSample(buffer[i]);
                }
                buffer = readerWAV.ReadNextSampleFrame();
            }
        }
        catch (Exception em1)
        {
            throw em1;
        }
        finally
        {

            
            try
            {
                //Flush each writer and close
                for (int writercount = 0; writercount < FileWriters.Length; writercount++)
                {
                    FileWriters[writercount].Flush();
                    FileWriters[writercount].Close();
                    FileWriters[writercount].Dispose();
                }
            }
            catch
            {

            }

            try { readerWAV.Dispose(); readerWAV = null; }
            catch { }

            try { WaveFormatConversionStream_.Dispose(); WaveFormatConversionStream_ = null; }
            catch { }

            try { PCMStream.Dispose(); PCMStream = null; }
            catch { }

            try { readerMP3.Dispose(); readerMP3 = null; }
            catch { }

            try
            {
                TempStream.Close(); TempStream.Dispose();
            }
            catch
            {

            }
        }
            return ListFilesOut.ToArray();
        }
    }
}