迁移基于Microsoft.DirectX的AudioRecoder类到SharpDX上

最近迁移项目到x64上，要处理的东西还是蛮多的，所以我要在说一次，不到万不得已不要用COM组件，要用COM组件也得首先考虑不需要我们关心平台的做法，或者得有64位版本。

比如Office的COM组件调用，excel可以用NPOI大家都知道了，如果你没用收费的aspose，那么你要操作其他office比如word，ppt等可以用NetOffice组件，虽然同样是调用COM，但是x86 x64都可以使用，而且任意完整本地Office版本即可（97~）

回到正题，这次是把基于 Microsoft.DirectX，Microsoft.DirectX.DirectSound这些32bit类库的AudioRecoder类迁移到SharpDX上来实现跨平台

引用

SharpDX

SharpDX.DirectSound

即可

///Record sound from MicroPhone and save to wav file

// 迁移到SharpDX   by bernard  2018.7.27
//参考：
//https://csharp.hotexamples.com/examples/SharpDX.DirectSound/NotificationPosition/-/php-notificationposition-class-examples.html
//http://daisy-trac.cvsdude.com/urakawa-sdk/browser/trunk/csharp/audio/AudioLib/AudioRecorder.cs?rev=2355


using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Threading;
using System.Windows.Forms;
using SharpDX.DirectSound;
using SharpDX.Multimedia;
using SharpDX;

namespace AudioLib
{
    class Recorder
    {
        private const int NOTIFYNUMBER = 16;       // 缓冲队列的数目
        private int mNextCaptureOffset = 0;      // 该次录音缓冲区的起始点
        private int nSampleCount = 0;            // 录制的样本数目
        private int nNotifySize = 0;             // 每次通知大小 
        private int nBufferSize = 0;             // 缓冲队列大小
        private string m_strFileName = string.Empty;     // 文件名 
        private FileStream fsWaveFile = null;         // 文件流 
        private BinaryWriter bwWriter = null;         // 写文件
        private DirectSoundCapture CapDev = null;              // 音频捕捉设备 
        private CaptureBuffer RecBuffer = null;     // 缓冲区对象 
        private NotificationPosition Notify = null;               // 消息通知对象
        private WaveFormat WavFormat;                       // 录音的格式 
        private Thread NotifyThread = null;                 // 处理缓冲区消息的线程 
        private AutoResetEvent NotificationEvent = null;    // 通知事件 

        public Recorder(string strFileName)
        {
            m_strFileName = strFileName;
            // 初始化音频捕捉设备 
            InitCaptureDevice();
            // 设定录音格式 
            WavFormat = CreateWaveFormat();
        }

        /// <summary> 

        /// 开始录音 

        /// </summary> 

        public void RecStart()
        {
            try
            {
                // 创建录音文件 

                CreateSoundFile();
                // 创建一个录音缓冲区，并开始录音 

                CreateCaptureBuffer();

                // 建立通知消息,当缓冲区满的时候处理方法 
                InitNotifications();

                RecBuffer.Start(true);



            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

        }
        /// <summary> 

        /// 停止录音 

        /// </summary>

        public void RecStop()
        {
            try
            {
                // 关闭通知消息 

                if (null != NotificationEvent)
                {
                    NotificationEvent.Set();

                }
                // 停止录音 

                RecBuffer.Stop();
                // 写入缓冲区最后的数据 

                RecordCapturedData();

                // 回写长度信息 

                bwWriter.Seek(4, SeekOrigin.Begin);

                bwWriter.Write((int)(nSampleCount + 36));   // 写文件长度 

                bwWriter.Seek(40, SeekOrigin.Begin);

                bwWriter.Write(nSampleCount);                // 写数据长度 

                bwWriter.Close();

                fsWaveFile.Close();

                bwWriter = null;

                fsWaveFile = null;
                nSampleCount = 0;
                // 3. To Dispose the capture
                CapDev.Dispose();

                // 4. Null the capture
                CapDev = null;

                // 5. To dispose the buffer
                RecBuffer.Dispose();

                // 6. To Null the buffer
                RecBuffer = null;


            }
            catch (Exception ex)
            {
                //throw new Exception(ex.Message);
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }
        }



        /// <summary> 
        /// 继续录音 
        /// </summary>

        public void RecContinue()
        {
            try
            {
                // 建立通知消息,当缓冲区满的时候处理方法                 
                RecBuffer.Start(true);

            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

        }
        /// <summary> 
        /// 暂停录音 
        /// </summary>

        public void RecPause()
        {
            try
            {
                // 关闭通知消息 

                if (null != NotificationEvent)
                {
                    NotificationEvent.Set();

                }
                // 停止录音 
                RecBuffer.Stop();

            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        /// <summary> 
        /// 初始化录音设备,此处使用主录音设备. 
        /// </summary>         
        public void InitCaptureDevice()
        {
            try
            {
                //// 获取默认音频捕捉设备 

                var devices = SharpDX.DirectSound.DirectSoundCapture.GetDevices();  // 枚举音频捕捉设备 

                Guid deviceGuid = Guid.Empty;                                       // 音频捕捉设备的ID
                if (devices.Count > 0)
                {
                    deviceGuid = devices[0].DriverGuid;
                }
                else
                {
                    throw new Exception("Not any sound capture device");

                }
                //// 用指定的捕捉设备创建Capture对象 

                try
                {
                    CapDev = new DirectSoundCapture();
                }

                catch (SharpDXException e)
                {

                    throw new Exception(e.ToString());

                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

        }

        /// <summary> 
        /// 创建录音格式,此处使用16bit,16KHz,Mono的录音格式
        /// </summary> 
        /// <returns>WaveFormat结构体</returns> 

        private WaveFormat CreateWaveFormat()
        {


            try
            {
                WaveFormat format = new WaveFormat(16000, 16, 1);
                return format;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

        }


        /// <summary> 
        /// 创建录音使用的缓冲区
        /// </summary> 

        private void CreateCaptureBuffer()
        {

            try
            {
                // 缓冲区的描述对象 

                CaptureBufferDescription bufferdescription = new CaptureBufferDescription();
                if (null != Notify)
                {

                    Notify = null;

                }

                if (null != RecBuffer)
                {

                    RecBuffer.Dispose();

                    RecBuffer = null;

                }

                // 设定通知的大小,默认为1s钟 
                nNotifySize = (1024 > WavFormat.AverageBytesPerSecond / 8) ? 1024 : (WavFormat.AverageBytesPerSecond / 8);

                nNotifySize -= nNotifySize % WavFormat.BlockAlign;
                // 设定缓冲区大小 

                nBufferSize = nNotifySize * NOTIFYNUMBER;
                // 创建缓冲区描述 

                bufferdescription.BufferBytes = nBufferSize;

                bufferdescription.Format = WavFormat;           // 录音格式
                                                                // 创建缓冲区 


                RecBuffer = new CaptureBuffer(CapDev, bufferdescription);

                mNextCaptureOffset = 0;
            }
            catch (Exception ex)
            {
                throw new Exception("Create recorder object failure, check sound driver or contact with administrator");
            }

        }

        /// <summary>

        /// 初始化通知事件,将原缓冲区分成16个缓冲队列,在每个缓冲队列的结束点设定通知点.

        /// </summary> 

        /// <returns>是否成功</returns> 

        private void InitNotifications()
        {
            try
            {
                if (null == RecBuffer)
                {
                    throw new Exception("Not create sound record buffer");

                }
                // 创建一个通知事件,当缓冲队列满了就激发该事件. 

                NotificationEvent = new AutoResetEvent(false);
                // 创建一个线程管理缓冲区事件 

                if (null == NotifyThread)
                {

                    NotifyThread = new Thread(new ThreadStart(WaitThread));

                    NotifyThread.Start();

                }
                // 设定通知的位置 

                NotificationPosition[] PositionNotify = new NotificationPosition[NOTIFYNUMBER];

                for (int i = 0; i < NOTIFYNUMBER; i++)
                {
                    PositionNotify[i] = new NotificationPosition();
                    PositionNotify[i].Offset = (nNotifySize * i) + nNotifySize - 1;

                    PositionNotify[i].WaitHandle = NotificationEvent;

                }
                //Notify = new NotificationPosition(RecBuffer);

                RecBuffer.SetNotificationPositions(PositionNotify);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

        }
        /// <summary> 

        /// 将录制的数据写入wav文件 

        /// </summary> 

        private void RecordCapturedData()
        {// 这里瞎改的，需要Review
            try
            {
                byte[] CaptureData = null;

                int ReadPos;

                int CapturePos = RecBuffer.CurrentCapturePosition;

                ReadPos = RecBuffer.CurrentRealPosition;
                int sizeBytes = RecBuffer.Capabilities.BufferBytes;

                int circularBufferBytesAvailableForReading = (CapturePos == mNextCaptureOffset ? 0
                                  : (CapturePos < mNextCaptureOffset
                            ? CapturePos + (sizeBytes - mNextCaptureOffset)
                            : CapturePos - mNextCaptureOffset));

                circularBufferBytesAvailableForReading -= (circularBufferBytesAvailableForReading % (sizeBytes / NOTIFYNUMBER));

                if (circularBufferBytesAvailableForReading == 0)
                {
                    return;
                }
                // 读取缓冲区内的数据 
                CaptureData = new byte[circularBufferBytesAvailableForReading];
                RecBuffer.Read(CaptureData, 0, circularBufferBytesAvailableForReading, mNextCaptureOffset, LockFlags.None);
                // 写入Wav文件

                bwWriter.Write(CaptureData, 0, CaptureData.Length);
                // 更新已经录制的数据长度. 
                bwWriter.Flush();
                nSampleCount += CaptureData.Length;
                // 移动录制数据的起始点,通知消息只负责指示产生消息的位置,并不记录上次录制的位置 

                mNextCaptureOffset += CaptureData.Length;

                mNextCaptureOffset %= nBufferSize; // Circular buffer
            }
            catch (Exception ex)
            {
                //throw new Exception(ex.Message);
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }

        }

        /// <summary> 

        /// 接收缓冲区满消息的处理线程 

        /// </summary> 

        private void WaitThread()
        {

            while (true)
            {

                // 等待缓冲区的通知消息 
                NotificationEvent.WaitOne(Timeout.Infinite, true);
                // 录制数据 

                RecordCapturedData();

            }

        }

        /// <summary> 

        /// 创建保存的波形文件,并写入必要的文件头. 

        /// </summary> 

        private void CreateSoundFile()
        {
            try
            {
                /************************************************************************** 
                Here is where the file will be created. A wave file is a RIFF file, which has chunks 
                of data that describe what the file contains. A wave RIFF file is put together like this:
                The 12 byte RIFF chunk is constructed like this: 
                Bytes 0 - 3 :  'R' 'I' 'F' 'F'
                Bytes 4 - 7 :  Length of file, minus the first 8 bytes of the RIFF description. 
                               (4 bytes for "WAVE" + 24 bytes for format chunk length + 
                               8 bytes for data chunk description + actual sample data size.) 
                Bytes 8 - 11: 'W' 'A' 'V' 'E'
                The 24 byte FORMAT chunk is constructed like this: 
                Bytes 0 - 3 : 'f' 'm' 't' ' ' 
                Bytes 4 - 7 : The format chunk length. This is always 16.
                Bytes 8 - 9 : File padding. Always 1.
                Bytes 10- 11: Number of channels. Either 1 for mono,  or 2 for stereo. 
                Bytes 12- 15: Sample rate. 
                Bytes 16- 19: Number of bytes per second. 
                Bytes 20- 21: Bytes per sample. 1 for 8 bit mono, 2 for 8 bit stereo or 16 bit mono, 4 for 16 bit stereo. 
                Bytes 22- 23: Number of bits per sample.
                The DATA chunk is constructed like this: 
                Bytes 0 - 3 : 'd' 'a' 't' 'a' 
                Bytes 4 - 7 : Length of data, in bytes. 
                Bytes 8 -...: Actual sample data. 
                ***************************************************************************/
                // Open up the wave file for writing. 

                fsWaveFile = new FileStream(m_strFileName, FileMode.Create);

                bwWriter = new BinaryWriter(fsWaveFile);
                // Set up file with RIFF chunk info. 
                char[] ChunkRiff = { 'R', 'I', 'F', 'F' };
                char[] ChunkType = { 'W', 'A', 'V', 'E' };
                char[] ChunkFmt = { 'f', 'm', 't', ' ' };
                char[] ChunkData = { 'd', 'a', 't', 'a' };
                short shPad = 1;                // File padding 
                int nFormatChunkLength = 0x10;  // Format chunk length. 
                int nLength = 0;                // File length, minus first 8 bytes of RIFF description. This will be filled in later. 
                short shBytesPerSample = 0;     // Bytes per sample.
                // 一个样本点的字节数目 
                if (8 == WavFormat.BitsPerSample && 1 == WavFormat.Channels)
                {
                    shBytesPerSample = 1;
                }

                else if ((8 == WavFormat.BitsPerSample && 2 == WavFormat.Channels) || (16 == WavFormat.BitsPerSample && 1 == WavFormat.Channels))
                {
                    shBytesPerSample = 2;
                }

                else if (16 == WavFormat.BitsPerSample && 2 == WavFormat.Channels)
                {
                    shBytesPerSample = 4;
                }

                // RIFF 块 

                bwWriter.Write(ChunkRiff);

                bwWriter.Write(nLength);

                bwWriter.Write(ChunkType);
                // WAVE块 

                bwWriter.Write(ChunkFmt);

                bwWriter.Write(nFormatChunkLength);

                bwWriter.Write(shPad);

                bwWriter.Write((short)WavFormat.Channels);

                bwWriter.Write(WavFormat.SampleRate);

                bwWriter.Write(WavFormat.AverageBytesPerSecond);

                bwWriter.Write(shBytesPerSample);

                bwWriter.Write((short)WavFormat.BitsPerSample);

                // 数据块 

                bwWriter.Write(ChunkData);

                bwWriter.Write((int)0);   // The sample length will be written in later. 
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }




    }
}