//******************************************************************************************************//  WavInputAdapter.cs - Gbtc////  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  06/29/2011 - Stephen C. Wills//       Generated original version of source code.//  07/01/2011 - Stephen C. Wills//       Modified WaveData dependency to refer to GSF.Media and moved the library//       into TimeSeriesFramework.//  12/13/2012 - Starlynn Danyelle Gilliam//       Modified Header.//  05/21/2015 - J. Ritchie Carroll//       Added ability to cache WAV file into memory for tests with disk I/O limitations////****************************************************************************************************** using System;using System.Collections.Generic;using System.ComponentModel;using System.IO;using System.Linq;using System.Threading;using GSF;using GSF.Diagnostics;using GSF.IO;using GSF.Media;using GSF.TimeSeries;using GSF.TimeSeries.Adapters; namespace WavInputAdapter{    /// <summary>    /// Represents an input adapter that reads measurements from a WAV file.    /// </summary>    [Description("WAV: Reads measurements from a WAV file")]    [EditorBrowsable(EditorBrowsableState.Advanced)] // Normally defined as an input device protocol    public class WavInputAdapter : InputAdapterBase    {        #region [ Members ]         // Constants        private const double DefaultRecoveryDelay = 5.0D;        private const long GapThreshold = Ticks.PerSecond;         // Fields        private WaveDataReader m_dataReader;        private BlockAllocatedMemoryStream m_dataCache;        private long m_dataIndex;        private int m_channels;        private int m_sampleRate;        private TimeSpan m_audioLength;        private long m_startTime;        private bool m_disposed;         #endregion         #region [ Properties ]         /// <summary>        /// Gets or sets the name of the file from which to read measurements.        /// </summary>        [ConnectionStringParameter, Description("The name of the file from which to read measurements.")]        public string WavFileName        {            get;            set;        }         /// <summary>        /// Gets or sets the amount of time, in seconds, needed to recover from a back log.        /// </summary>        [ConnectionStringParameter,        Description("The amount of time, in seconds, needed to recover from a back log."),        DefaultValue(DefaultRecoveryDelay)]        public double RecoveryDelay        {            get;            set;        }         /// <summary>        /// Gets or sets flag that determines if WAV file should be cached in memory.        /// </summary>        /// <remarks>        /// Useful for situations where disk I/O can be a bottleneck.        /// </remarks>        [ConnectionStringParameter,        Description("Flag that determines if WAV file should be cached in memory. This can be useful for situations where disk I/O can be a bottleneck. Note that this will occupy RAM for entire file size - be cautious."),        DefaultValue(false)]        public bool MemoryCache        {            get;            set;        }         /// <summary>        /// Gets or sets the output measurements.        /// </summary>        /// <remarks>        /// The output measurements are like templates. New measurements generated        /// by this adapter will be copies of these output measurements, in which        /// only the values and timestamps will differ.        /// </remarks>        [ConnectionStringParameter,        DefaultValue(null),        Description("Defines primary keys of output measurements the adapter expects; can be one of a filter expression, measurement key, point tag or Guid."),        CustomConfigurationEditor("GSF.TimeSeries.UI.WPF.dll", "GSF.TimeSeries.UI.Editors.MeasurementEditor")]        public override IMeasurement[] OutputMeasurements        {            get            {                return base.OutputMeasurements;            }            set            {                base.OutputMeasurements = value.OrderBy(measurement => measurement.Key.ToString()).ToArray();            }        }         /// <summary>        /// Gets flag that determines if the data input connects asynchronously.        /// </summary>        /// <remarks>        /// This returns false because this adapter does not connect asynchronously.        /// </remarks>        protected override bool UseAsyncConnect => false;         /// <summary>        /// Gets the flag indicating if this adapter supports temporal processing.        /// </summary>        public override bool SupportsTemporalProcessing => true;         #endregion         #region [ Methods ]         /// <summary>        /// Initializes the connection string parameters of this <see cref="WavInputAdapter"/>.        /// </summary>        public override void Initialize()        {            base.Initialize();             Dictionary<string, string> settings = Settings;            string setting;             if (settings.TryGetValue("recoveryDelay", out setting))                RecoveryDelay = double.Parse(setting);            else                RecoveryDelay = DefaultRecoveryDelay;             if (!settings.TryGetValue("wavFileName", out setting))                throw new ArgumentException("wavFileName is missing from settings - Example: wavFileName=Bohemian Rhapsody.wav");             WavFileName = setting;             if (settings.TryGetValue("memoryCache", out setting))                MemoryCache = setting.ParseBoolean();             // Attempt to parse WAV file info during initialization, if this fails - no need to load adapter            WaveFile fileInfo = WaveFile.Load(WavFileName, false);             m_channels = fileInfo.Channels;            m_sampleRate = fileInfo.SampleRate;            m_audioLength = fileInfo.AudioLength;             if (m_channels > OutputMeasurements.Length)                throw new ArgumentException($"Not enough output measurements ({OutputMeasurements.Length}) defined for the number of channels in the WAV file ({m_channels})");             OnStatusMessage(MessageLevel.Info, $"Ready to play \"{Path.GetFileName(WavFileName)}\" with {m_channels} channels...");        }         /// <summary>        /// Attempts to open the file to start getting wave data.        /// </summary>        protected override void AttemptConnection()        {            m_dataReader = OpenWaveDataReader();            m_dataIndex = 0;             m_startTime = DateTime.UtcNow.Ticks;             new Thread(ProcessMeasurements) { IsBackground = true }.Start();        }         /// <summary>        /// Attempts to close the file and release resources held by the adapter.        /// </summary>        protected override void AttemptDisconnection()        {            if ((object)m_dataReader != null)            {                m_dataReader.Close();                m_dataReader.Dispose();                m_dataReader = null;            }        }         /// <summary>        /// Releases the unmanaged resources used by the <see cref="WavInputAdapter"/> object and optionally releases the managed resources.        /// </summary>        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>        protected override void Dispose(bool disposing)        {            if (!m_disposed)            {                try                {                    if (disposing)                    {                        if ((object)m_dataReader != null)                        {                            m_dataReader.Close();                            m_dataReader.Dispose();                            m_dataReader = null;                        }                         if ((object)m_dataCache != null)                            m_dataCache.Dispose();                    }                }                finally                {                    m_disposed = true;          // Prevent duplicate dispose.                    base.Dispose(disposing);    // Call base class Dispose().                }            }        }         /// <summary>        /// Gets a short one-line status of this <see cref="AdapterBase"/>.        /// </summary>        /// <param name="maxLength">Maximum number of available characters for display.</param>        /// <returns>A short one-line summary of the current status of this <see cref="AdapterBase"/>.</returns>        public override string GetShortStatus(int maxLength)        {            if (!Enabled || !IsConnected)                return $"Streaming for \"{Path.GetFileName(WavFileName)}\" is paused...".CenterText(maxLength);             TimeSpan time = Ticks.FromSeconds(m_dataIndex / (double)m_sampleRate);            return $"Streaming \"{Path.GetFileName(WavFileName)}\" at time {time.ToString(@"m\:ss")} / {m_audioLength.ToString(@"m\:ss")} - {time.TotalSeconds / m_audioLength.TotalSeconds:0.00%}.".CenterText(maxLength);        }         private void ProcessMeasurements()        {            List<IMeasurement> measurements = new List<IMeasurement>((int)(Ticks.ToSeconds(GapThreshold) * m_sampleRate * m_channels * 1.1D));            LittleBinaryValue[] sample;             while (Enabled)            {                try                {                    SpinWait spinner = new SpinWait();                     // Determine what time it is now                    long now = DateTime.UtcNow.Ticks;                     // Assign a timestamp to the next sample based on its location                    // in the file relative to the other samples in the file                    long timestamp = m_startTime + (m_dataIndex * Ticks.PerSecond / m_sampleRate);                     if (now - timestamp > GapThreshold)                    {                        // Reset the start time and delay next transmission in an attempt to catch up                        m_startTime = now - (m_dataIndex * Ticks.PerSecond / m_sampleRate) + Ticks.FromSeconds(RecoveryDelay);                        timestamp = now;                        OnStatusMessage(MessageLevel.Info, "Start time reset.");                    }                     // Keep generating measurements until                    // we catch up to the current time.                    while (timestamp < now)                    {                        sample = m_dataReader.GetNextSample();                         // If the sample is null, we've reached the end of the file - close and reopen,                        // resetting the data index and start time                        if (sample == null)                        {                            m_dataReader.Close();                            m_dataReader.Dispose();                             m_dataReader = OpenWaveDataReader();                            m_dataIndex = 0;                             m_startTime = timestamp;                            sample = m_dataReader.GetNextSample();                        }                         // Create new measurements, one for each channel, and add them to the measurements list                        for (int i = 0; i < m_channels; i++)                            measurements.Add(Measurement.Clone(OutputMeasurements[i], sample[i].ConvertToType(TypeCode.Double), timestamp));                         // Update the data index and recalculate the assigned timestamp for the next sample                        m_dataIndex++;                        timestamp = m_startTime + (m_dataIndex * Ticks.PerSecond / m_sampleRate);                    }                     OnNewMeasurements(measurements);                    measurements.Clear();                     while (DateTime.UtcNow.Ticks - timestamp <= GapThreshold / 100)                    {                        // Ahead of schedule -- pause for a moment                        spinner.SpinOnce();                    }                }                catch (Exception ex)                {                    OnProcessException(MessageLevel.Warning, ex);                }            }        }         // Open wave reader - either from memory loaded WAV or directly from disk        private WaveDataReader OpenWaveDataReader()        {            if (MemoryCache)            {                if ((object)m_dataCache == null)                {                    m_dataCache = new BlockAllocatedMemoryStream();                     using (FileStream stream = File.OpenRead(WavFileName))                        stream.CopyTo(m_dataCache);                }                 m_dataCache.Position = 0;                 return WaveDataReader.FromStream(m_dataCache);            }             return WaveDataReader.FromFile(WavFileName);        }         #endregion    }}