使用NAudio发送音频

Question

我已设法使用此处的代码从麦克风发送音频.

但是我无法使用NAudio做到这一点.

CodeProject的代码具有编码和解码的显式代码,例如:

G711.Encode_aLaw
G711.Decode_uLaw

转换并返回要通过网络发送的字节.

是否可以为上面的CodeProject应用程序获取NAudio的示例代码？

Answer 1

这是我使用 NAudio、麦克风输入、扬声器输出以及 u-Law 或 A-Law 编码编写的快速 C# 控制台应用程序。命名空间NAudio.Codecs包含 A-Law 和 u-Law 编码器和解码器。

这个程序不会通过网络发送数据（这并不难做到，我只是不想在这里这样做）。我会把它留给你。相反，它包含一个“发送者”线程和一个“接收者”线程。

麦克风DataAvailable事件处理程序只是将字节缓冲区放入队列中（它会复制缓冲区 - 您不想保留事件中的实际缓冲区）。“发送者”线程抓取排队的缓冲区，将 PCM 数据转换为 g.711 并将其放入第二个队列。这个“放入第二个队列”部分是您将数据发送到特定应用程序的远程 UDP 目标的位置。

“接收器”线程从第二个队列读取数据，将其转换回 PCM，并将其馈送到BufferedWaveProviderWaveOut（扬声器）设备正在使用的设备。您可以将此输入替换为网络应用程序的 UDP 套接字接收。

请注意，该程序保证 PCM 输入和输出（麦克风和扬声器）使用相同的WaveFormat. 对于联网端点，您也必须这样做。

无论如何，它有效。这是代码。我不会讲太多细节。有很多评论试图帮助理解正在发生的事情：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using NAudio.Wave;
using NAudio.Codecs;

namespace G711MicStream
{
    class Program
    {
        delegate byte EncoderMethod( short _raw );
        delegate short DecoderMethod( byte _encoded );

        // Change these to their ALaw equivalent if you want.
        static EncoderMethod Encoder = MuLawEncoder.LinearToMuLawSample;
        static DecoderMethod Decoder = MuLawDecoder.MuLawToLinearSample;



        static void Main(string[] args)
        {
            // Fire off our Sender thread.
            Thread sender = new Thread(new ThreadStart(Sender));
            sender.Start();

            // And receiver...
            Thread receiver = new Thread(new ThreadStart(Receiver));
            receiver.Start();

            // We're going to try for 16-bit PCM, 8KHz sampling, 1 channel.
            // This should align nicely with u-law
            CommonFormat = new WaveFormat(16000, 16, 1);

            // Prep the input.
            IWaveIn wavein = new WaveInEvent();
            wavein.WaveFormat = CommonFormat;
            wavein.DataAvailable += new EventHandler<WaveInEventArgs>(wavein_DataAvailable);
            wavein.StartRecording();

            // Prep the output.  The Provider gets the same formatting.
            WaveOut waveout = new WaveOut();
            OutProvider = new BufferedWaveProvider(CommonFormat);
            waveout.Init(OutProvider);
            waveout.Play();


            // Now we can just run until the user hits the <X> button.
            Console.WriteLine("Running g.711 audio test.  Hit <X> to quit.");
            for( ; ; )
            {
                Thread.Sleep(100);
                if( !Console.KeyAvailable ) continue;
                ConsoleKeyInfo info = Console.ReadKey(false);
                if( (info.Modifiers & ConsoleModifiers.Alt) != 0 ) continue;
                if( (info.Modifiers & ConsoleModifiers.Control) != 0 ) continue;

                // Quit looping on non-Alt, non-Ctrl X
                if( info.Key == ConsoleKey.X ) break;                
            }

            Console.WriteLine("Stopping...");

            // Shut down the mic and kick the thread semaphore (without putting
            // anything in the queue).  This will (eventually) stop the thread
            // (which also signals the receiver thread to stop).
            wavein.StopRecording();
            try{ wavein.Dispose(); } catch(Exception){}
            SenderKick.Release();

            // Wait for both threads to exit.
            sender.Join();
            receiver.Join();

            // And close down the output.
            waveout.Stop();
            try{ waveout.Dispose(); } catch(Exception) {}

            // Sleep a little.  This seems to be accepted practice when shutting
            // down these audio components.
            Thread.Sleep(500);
        }


        /// <summary>
        /// Grabs the mic data and just queues it up for the Sender.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        static void  wavein_DataAvailable(object sender, WaveInEventArgs e)
        {
            // Create a local copy buffer.
            byte [] buffer = new byte [e.BytesRecorded];
            System.Buffer.BlockCopy(e.Buffer, 0, buffer, 0, e.BytesRecorded);

            // Drop it into the queue.  We'll need to lock for this.
            Lock.WaitOne();
            SenderQueue.AddLast(buffer);
            Lock.ReleaseMutex();

            // and kick the thread.
            SenderKick.Release();
        }


        static
        void
        Sender()
        {
            // Holds the data from the DataAvailable event.
            byte [] qbuffer = null;

            for( ; ; )
            {
                // Wait for a 'kick'...
                SenderKick.WaitOne();

                // Lock...
                Lock.WaitOne();
                bool dataavailable = ( SenderQueue.Count != 0 );
                if( dataavailable )
                {
                    qbuffer = SenderQueue.First.Value;
                    SenderQueue.RemoveFirst();
                }
                Lock.ReleaseMutex();

                // If the queue was empty on a kick, then that's our signal to
                // exit.
                if( !dataavailable ) break;

                // Convert each 16-bit PCM sample to its 1-byte u-law equivalent.
                int numsamples = qbuffer.Length / sizeof(short);
                byte [] g711buff = new byte [numsamples];

                // I like unsafe for this kind of stuff!
                unsafe
                {
                    fixed( byte * inbytes = &qbuffer[0] )
                    fixed( byte * outbytes = &g711buff[0] )
                    {
                        // Recast input buffer to short[]
                        short * buff = (short *)inbytes;

                        // And loop over the samples.  Since both input and
                        // output are 16-bit, we can use the same index.
                        for( int index = 0; index < numsamples; ++index )
                        {
                            outbytes[index] = Encoder(buff[index]);
                        }
                    }
                }

                // This gets passed off to the reciver.  We'll queue it for now.
                Lock.WaitOne();
                ReceiverQueue.AddLast(g711buff);
                Lock.ReleaseMutex();
                ReceiverKick.Release();
            }

            // Log it.  We'll also kick the receiver (with no queue addition)
            // to force it to exit.
            Console.WriteLine("Sender: Exiting.");
            ReceiverKick.Release();
        }

        static
        void
        Receiver()
        {
            byte [] qbuffer = null;
            for( ; ; )
            {
                // Wait for a 'kick'...
                ReceiverKick.WaitOne();

                // Lock...
                Lock.WaitOne();
                bool dataavailable = ( ReceiverQueue.Count != 0 );
                if( dataavailable )
                {
                    qbuffer = ReceiverQueue.First.Value;
                    ReceiverQueue.RemoveFirst();
                }
                Lock.ReleaseMutex();

                // Exit on kick with no data.
                if( !dataavailable ) break;

                // As above, but we convert in reverse, from 1-byte u-law
                // samples to 2-byte PCM samples.
                int numsamples = qbuffer.Length;
                byte [] outbuff = new byte [qbuffer.Length * 2];
                unsafe
                {
                    fixed( byte * inbytes = &qbuffer[0] )
                    fixed( byte * outbytes = &outbuff[0] )
                    {
                        // Recast the output to short[]
                        short * outpcm = (short *)outbytes;

                        // And loop over the u-las samples.
                        for( int index = 0; index < numsamples; ++index )
                        {
                            outpcm[index] = Decoder(inbytes[index]);
                        }
                    }
                }

                // And write the output buffer to the Provider buffer for the
                // WaveOut devices.
                OutProvider.AddSamples(outbuff, 0, outbuff.Length);
            }

            Console.Write("Receiver: Exiting.");
        }


        /// <summary>Lock for the sender queue.</summary>
        static Mutex Lock = new Mutex();

        static WaveFormat CommonFormat;

        /// <summary>"Kick" semaphore for the sender queue.</summary>
        static Semaphore SenderKick = new Semaphore(0, int.MaxValue);
        /// <summary>Queue of byte buffers from the DataAvailable event.</summary>
        static LinkedList<byte []> SenderQueue = new LinkedList<byte[]>();

        static Semaphore ReceiverKick = new Semaphore(0, int.MaxValue);
        static LinkedList<byte []> ReceiverQueue = new LinkedList<byte[]>();
        
        /// <summary>WaveProvider for the output.</summary>
        static BufferedWaveProvider OutProvider;
    }
}