WaveFileWriter audio coming out all static

[mikepjean]

Using the following code I cannot get the AudioMediaBuffer audio to write to the WAVE file without it just becoming static. Please advise.

using NAudio.MediaFoundation;
using NAudio.Wave;
using Newtonsoft.Json;
using NLog;
using Skyview.CrossPortPluginLib.Interfaces;
using StreamCoders;
using StreamCoders.Encoder;
using StreamCoders.Helpers;
using StreamCoders.Wave;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.UI;

namespace FileHandler.FileRecorder
{
public class FileRecorder : IStreamServer
{
private static Logger _Logger = LogManager.GetCurrentClassLogger();
private WaveOutput _Output = null;
private WaveFileWriter _OutputFileWriter = null;
private WaveFileWriter _Writer;
private string _LogInfoName = "";
private int _desiredFileSize = 0;//file size in bytes
private int _currentFileSize = 0;
private string _FileName = null;

    public string FilePath { get; set; } = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "AudioClips");

    public string FileName { get; set; } = "Clip";
    public TimeSpan FileDuration { get; set; } = TimeSpan.FromMinutes(10);
    #region IStreamServer
    [JsonIgnore]
    public bool IsConnected { get; private set; }
    [JsonIgnore]
    public IAudioEncoder SourceAudioEncoder { get; set; }
    [JsonIgnore]
    public ICueEncoder SourceCueEncoder { get; set; }
    [JsonIgnore]
    public HealthStatus Status { get; private set; } = HealthStatus.Stopped;
    [JsonIgnore]
    public int WDInterval { get; set; } = 2000;//if you set a watch dog to see if there is an error see WatchDog Pattern
    [JsonIgnore]
    public string LogInfoName
    {
        get { return _LogInfoName; }
        set
        {
            _LogInfoName = value;
        }
    }

    public string GetDisplayTypeName()
    {
        return "File Recorder";
    }

    public void Start()
    {
        //Write Initial File
        if (SourceAudioEncoder != null)
        {
            //Status = HealthStatus.Nominal;

            SourceAudioEncoder.StreamDataReady += SourceAudioEncoder_StreamDataReady;
            SourceAudioEncoder.Start();
        }
        if (SourceCueEncoder != null)
        {
            SourceCueEncoder.CueReady += SourceCueEncoder_CueReady;
            SourceCueEncoder.Start();
        }

    }

    private void SourceCueEncoder_CueReady(ICueProvider sender, CueReadyEventArgs args)
    {
        while (args.CueData.Count > 0) args.CueData.Take();
    }

    public void Stop()
    {
        if (_OutputFileWriter != null)
        {
            _OutputFileWriter?.Dispose();
            _OutputFileWriter = null;
        }
        //Status = HealthStatus.Stopped;
        if (SourceAudioEncoder != null)
        {
            SourceAudioEncoder.StreamDataReady -= SourceAudioEncoder_StreamDataReady;
            SourceAudioEncoder.Stop();
        }
        if (SourceCueEncoder != null)
        {
            SourceCueEncoder.CueReady -= SourceCueEncoder_CueReady;
            SourceCueEncoder.Stop();
        }
        if (_Output != null)
        {
            _Output.ResetDevice(); //Clears buffers so may be the culprit
            _Output.CloseDevice();
            _Output.Dispose();
            _Output = null;
        }

    }
    #endregion
    private AudioMediaBuffer _TmpBuff = null;

    //Similar to Analog Feed but writing to a file not a buffer
    private void SourceAudioEncoder_StreamDataReady(object sender, EncodedDataArgs args)
    {
        try
        {
            while (args.EncodedBytes.Count > 0)
            {
                _TmpBuff = args.EncodedBytes.Take();

                _desiredFileSize = (int)(FileDuration.TotalSeconds * _TmpBuff.Samplerate * (_TmpBuff.BitsPerSample / 8) * _TmpBuff.Channels);
                if (_Writer == null)
                {
                    CreateWriter(_TmpBuff);
                }
                if ((_currentFileSize + _TmpBuff.Buffer.Count) >= _desiredFileSize)
                {
                    var needed = _desiredFileSize - _currentFileSize;
                    byte[] _EndBuffer = new byte[needed];
                    Array.Copy(_TmpBuff.Buffer.ExtractArray(), 0, _EndBuffer, 0, needed);
                    _Writer.Write(_EndBuffer, 0, needed);
                    CreateWriter(_TmpBuff);
                    if (needed < _TmpBuff.Buffer.Count)
                    {
                        byte[] _NextBuffer = new byte[_TmpBuff.Buffer.Count - needed];
                        Array.Copy(_TmpBuff.Buffer.ExtractArray(), needed, _NextBuffer, 0, _NextBuffer.Length);
                        _Writer.Write(_NextBuffer.ToArray(), 0, _NextBuffer.Length);
                        _currentFileSize += _NextBuffer.Length;
                    }
                }
                else
                {
                    _Writer.Write(_TmpBuff.Buffer.Array, _TmpBuff.Buffer.Offset, _TmpBuff.Buffer.Count);
                    _currentFileSize += _TmpBuff.Buffer.Count;
                }
                _TmpBuff = null;

            }
        }
        catch (Exception ex)
        {
            _Logger.Error(ex.Message + " " + ex.InnerException + " " + ex.StackTrace + " ");
        }
    }


    public String DeviceName { get; set; } = "File Recorder";

    public static String GetWebConfigFileName()
    {
        return "ConfigWebControls.FileRecorder.FileRecorder.html";
    }

    public void CreateWriter(AudioMediaBuffer _SettingsBuffer)
    {
        if (_Writer != null) CloseWriter();
        _FileName = Path.Combine(FilePath, FileName + DateTime.Now.ToString("yyyyMMddHHmmss") + ".wav");
        _Writer = new WaveFileWriter(_FileName, new WaveFormat(_SettingsBuffer.Samplerate, _SettingsBuffer.BitsPerSample, _SettingsBuffer.Channels));
        _currentFileSize = 0;
    }

    public void CloseWriter()
    {
        if (_Writer != null)
        {
            _Writer.Flush();
            _Writer.Close();
            _Writer = null;
        }
    }
}

}