How to save the audio conversation of the call? about botbuilder-realtimemediacalling HOT 6 CLOSED

private async void OnAudioMediaReceived(object sender, AudioMediaReceivedEventArgs e)
{
    var buffer = e.Buffer;
    try
    {
        if (m_wavFileWriter != null)
        {
            long length = buffer.Length;
            var retrievedBuffer = new byte[length];
            Marshal.Copy(buffer.Data, retrievedBuffer, 0, (int) length);
            await m_wavFileWriter.EnqueueAsync(retrievedBuffer);
        }
    }
    catch (Exception ex)
    {
        //log exception
    }
    finally
    {
        buffer.Dispose();
    }
}        

m_wavFileWriter = new WavFileWriter("WavOut" + DateTime.UtcNow.Ticks + ".wav",
                    new WavFileSettings());
               await m_wavFileWriter.InitializeAsync();

await m_wavFileWriter.ShutdownAsync();

 /// <summary>
    ///  wav file writer, this class will create a wav file
    ///  from the received buffers in the smart agents.
    /// </summary>
    internal class WavFileWriter
    {
        private BufferBlock<byte[]> m_queueBlock;
        private FileStream m_fileStream;
        private readonly CancellationTokenSource m_queueCancellationTokenSource;
        private readonly SemaphoreSlim m_syncLock = new SemaphoreSlim(1);
        private readonly WavFileSettings m_wavFileSettings;
        private long m_riffChunkSizePosition;
        private long m_dataChunkSizePosition;

        public bool IsInitialized { get; private set; }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="wavFileSettings"></param>
        public WavFileWriter(string fileName, WavFileSettings wavFileSettings)
        {
           m_fileStream = new FileStream(fileName, FileMode.OpenOrCreate,
                    FileAccess.ReadWrite,
                    FileShare.None);
            m_queueCancellationTokenSource = new CancellationTokenSource();
            m_queueBlock = new BufferBlock<byte[]>(new DataflowBlockOptions { CancellationToken = m_queueCancellationTokenSource.Token});
            m_wavFileSettings = wavFileSettings;
        }

        private void WriteRiffChunk(BinaryWriter bw)
        {
            bw.Write(0x46464952);	//'RIFF'
            //We remember the riffChunkSizePoistion that we have to update later on stream close
            m_riffChunkSizePosition = bw.BaseStream.Position;	//Filelength - 8 bytes
            bw.Write((int)50);	//a 0sec wav file is atleast 58 bytes
            bw.Write(0x45564157);	//'WAVE'
        }

        private void WriteFmtChunk(BinaryWriter bw)
        {
            bw.Write((int)0x20746D66);	//'fmt '
            bw.Write(16);		//16 bytes of format. We produce no 'extra format info'
            bw.Write(m_wavFileSettings.CompressionCode);		//2bytes
            bw.Write(m_wavFileSettings.NumberOfChannels);	//2bytes
            bw.Write(m_wavFileSettings.SampleRate);			//4bytes
            bw.Write(m_wavFileSettings.AvgBytesPerSecond);	//4bytes
            bw.Write((short)2);					//alignment
            bw.Write((short)16);				//significant bits per sample
        }

        private void WriteFactChunk(BinaryWriter bw)
        {
            bw.Write((int)0x74636166);		//'fact' chunk ID
            bw.Write((int)4);			//4 byte Fact Chunk size
            bw.Write((int)0);			//4 byte chunk data. 
        }

        private void WriteDataChunk(BinaryWriter bw)
        {
            bw.Write(0x61746164);		//'data' chunk ID
            //We remember the dataChunkPosition that we have to update later on stream close
            m_dataChunkSizePosition = bw.BaseStream.Position;
            bw.Write((int)0);				//initially, we have no data, so we set the chunk size to 0
        }

        /// <summary>
        /// Initializes the consumer of the queue to wait for new items and process them if available
        /// </summary>
        /// <returns></returns>
        public async Task InitializeAsync()
        {
            if (!IsInitialized)
            {
                await m_syncLock.WaitAsync();
                if (!IsInitialized)
                {
                    IsInitialized = true;
                   
                    //Initialize the headers
                    Debug.Assert(m_fileStream != null, "m_fileStream != null");
                    BinaryWriter bw = new BinaryWriter(m_fileStream);
                    WriteRiffChunk(bw);
                    WriteFmtChunk(bw);
                    WriteFactChunk(bw);
                    WriteDataChunk(bw);

                    await Task.Factory.StartNew( () =>  DequeueAndProcessAsync());
                }

                m_syncLock.Release();
            }
        }

        /// <summary>
        /// Dequeue and process async workitems
        /// </summary>
        /// <returns></returns>
        internal async Task DequeueAndProcessAsync()
        {
            try
            {
                while (await m_queueBlock.OutputAvailableAsync(m_queueCancellationTokenSource.Token))
                {
                     var buffer = await m_queueBlock.ReceiveAsync(m_queueCancellationTokenSource.Token);

                    if (buffer != null)
                    {
                        await m_fileStream.WriteAsync(buffer, 0, buffer.Length);
                    }

                    this.m_queueCancellationTokenSource.Token.ThrowIfCancellationRequested();
                }
            }
            catch (TaskCanceledException ex)
            {
                Debug.Write(string.Format("The queue processing task has been cancelled. Exception: {0}", ex));
            }
            catch (ObjectDisposedException ex)
            {
                Debug.Write(string.Format("The queue processing task object has been disposed. Exception: {0}", ex));
            }
            catch (Exception ex)
            {
                // Catch all other exceptions and log
                Debug.Write(string.Format("Caught Exception: {0}", ex));

                // Continue processing elements in the queue
                await DequeueAndProcessAsync();
            }
        }

        /// <summary>
        /// Enqueue a waitable work item
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public async Task EnqueueAsync(byte[] buffer)
        {
            try
            {
                await m_queueBlock.SendAsync(buffer, m_queueCancellationTokenSource.Token);
            }
            catch (TaskCanceledException e)
            {
                if (m_queueBlock != null)
                {
                    m_queueBlock.Complete();
                }

                Debug.Write(string.Format("Cannot enqueue because queuing operation has been cancelled. Exception: {0}", e));
            }
            catch (Exception e)
            {
                Debug.Write(string.Format("Failed to enqueue: {0}", e));
            }
        }

        /// <summary>
        /// ShutDown the queue, this will also cancel current operations
        /// </summary>
        /// <returns></returns>
        public async Task ShutdownAsync()
        {
            if (IsInitialized)
            {
                await m_syncLock.WaitAsync();
                if (IsInitialized)
                {
                    Debug.Assert(m_queueBlock != null);
                    // Allow no more processing on the queue
                    m_queueBlock.Complete();

                    // Cancel the queue task
                    m_queueCancellationTokenSource.Cancel();
                    m_queueCancellationTokenSource.Dispose();
                    IsInitialized = false;
                    CloseFileStream();
                }

                m_syncLock.Release();
            }
        }

        private void CloseFileStream()
        {
            if (m_fileStream != null)
            {
                
                try
                {
                    using(BinaryWriter bw = new BinaryWriter(m_fileStream))
                    {
                       //Lets update the riffChunkSize header value
                       m_fileStream.Seek(m_riffChunkSizePosition, SeekOrigin.Begin);
                       bw.Write((int)(m_fileStream.Length - 8));

                       //... and the dataChunksize header value;
                       m_fileStream.Seek(m_dataChunkSizePosition, SeekOrigin.Begin);
                       bw.Write((int)(m_fileStream.Length - (m_dataChunkSizePosition + 4)));
                    }
                }
                finally
                {
                    m_fileStream.Close();
                }
            }
        }
    }

    internal class WavFileSettings
    {
        public short CompressionCode { get; set; }
        public short NumberOfChannels { get; set; }
        public int SampleRate { get; set; }
        public int AvgBytesPerSecond { get; set; }

        /// <summary>
        /// Default constructor with default PCM 16 mono
        /// </summary>
        public WavFileSettings()
        {
            CompressionCode = 1;			//PCM
            NumberOfChannels = 1;			//No Stereo
            SampleRate = 16000;				//16khz only
            AvgBytesPerSecond = 32000;
        }
    }