StandardQueryWAVFile.cs

using MyCaffe.basecode;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.db.stream
{
    public class StandardQueryWAVFile : IXCustomQuery
    {
        string m_strPath;
        string[] m_rgstrFiles;
        int m_nFileIdx = 0;
        Dictionary<string, float> m_rgInfo = new Dictionary<string, float>();
 
        public StandardQueryWAVFile(string strParam = null)
        {
            if (strParam != null)
            {
                strParam = ParamPacker.UnPack(strParam);
                PropertySet ps = new PropertySet(strParam);
                m_strPath = ps.GetProperty("FilePath");
            }
        }
 
        public CUSTOM_QUERY_TYPE QueryType
        {
            get { return CUSTOM_QUERY_TYPE.REAL_DOUBLE; }
        }
 
        public string Name
        {
            get { return "StdWAVFileQuery"; }
        }
 
        public int FieldCount
        {
            get { return 1; }  // data
        }
 
        public IXCustomQuery Clone(string strParam)
        {
            return new StandardQueryWAVFile(strParam);
        }
 
        public void Close()
        {
            m_rgstrFiles = null;
            m_nFileIdx = 0;
        }
 
        public void Open()
        {
            string[] rgstrFiles = Directory.GetFiles(m_strPath);
            m_nFileIdx = 0;
 
            List<string> rgstr = new List<string>();
 
            for (int i = 0; i < rgstrFiles.Length; i++)
            {
                FileInfo fi = new FileInfo(rgstrFiles[i]);
 
                if (fi.Extension.ToLower() == ".wav")
                    rgstr.Add(rgstrFiles[i]);
            }
 
            m_rgstrFiles = rgstr.ToArray();
 
            if (m_rgstrFiles.Length == 0)
                throw new Exception("The CustomTextQuery could not find any audio WAV (*.wav) files to load.");
        }
 
        public double[] QueryByTime(DateTime dt, TimeSpan ts, int nCount)
        {
            throw new NotImplementedException();
        }
 
        public byte[] QueryBytes()
        {
            throw new NotImplementedException();
        }
 
        public List<double[]> QueryRealD()
        {
            if (m_nFileIdx == m_rgstrFiles.Length)
                return null;
 
            using (FileStream fs = File.OpenRead(m_rgstrFiles[m_nFileIdx]))
            using (WAVReader wav = new WAVReader(fs))
            {
                m_nFileIdx++;
                wav.ReadToEnd();
 
                m_rgInfo = new Dictionary<string, float>();
                m_rgInfo.Add("AveBytesPerSec", wav.Format.nAvgBytesPerSec);
                m_rgInfo.Add("BlockAlign", wav.Format.nBlockAlign);
                m_rgInfo.Add("Channels", wav.Format.nChannels);
                m_rgInfo.Add("SamplesPerSec", wav.Format.nSamplesPerSec);
                m_rgInfo.Add("BitsPerSample", wav.Format.wBitsPerSample);
                m_rgInfo.Add("FormatTag", wav.Format.wFormatTag);
 
                List<double[]> rgData = new List<double[]>();
 
                for (int i = 0; i < wav.Samples[0].Length; i++)
                {
                    rgData.Add(new double[] { wav.Samples[0][i], wav.Samples[1][i] });
                }
 
                return rgData;
            }
        }
 
        public List<float[]> QueryRealF()
        {
            throw new NotImplementedException();
        }
 
        public Dictionary<string, float> QueryInfo()
        {
            if (m_rgInfo != null && m_rgInfo.Count > 0)
                return m_rgInfo;
 
            if (m_nFileIdx == m_rgstrFiles.Length)
                throw new Exception("Invalid field index.");
 
            using (FileStream fs = File.OpenRead(m_rgstrFiles[m_nFileIdx]))
            using (WAVReader wav = new WAVReader(fs))
            {
                wav.ReadToEnd(true);
 
                m_rgInfo = new Dictionary<string, float>();
                m_rgInfo.Add("AveBytesPerSec", wav.Format.nAvgBytesPerSec);
                m_rgInfo.Add("BlockAlign", wav.Format.nBlockAlign);
                m_rgInfo.Add("Channels", wav.Format.nChannels);
                m_rgInfo.Add("SamplesPerSec", wav.Format.nSamplesPerSec);
                m_rgInfo.Add("BitsPerSample", wav.Format.wBitsPerSample);
                m_rgInfo.Add("FormatTag", wav.Format.wFormatTag);
 
                return m_rgInfo;
            }
        }
 
        public static byte[] PackBytes(WaveFormat fmt, List<float[]> rgSamples)
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                byte[] rgHeader = WAVWriter.StructureToByteArray<WaveFormat>(fmt);
                List<float[]> rgData = rgSamples;
 
                bw.Write(rgHeader.Length);
                bw.Write(rgHeader);
                bw.Write(rgData.Count);
                bw.Write(rgData[0].Length);
 
                for (int i = 0; i < rgData[0].Length; i++)
                {
                    for (int j = 0; j < rgData.Count; j++)
                    {
                        bw.Write(rgData[j][i]);
                    }
                }
 
                return ms.ToArray();
            }
        }
 
        public static List<double[]> UnPackBytes(byte[] rg, out WaveFormat fmt)
        {
            using (MemoryStream ms = new MemoryStream(rg))
            using (BinaryReader br = new BinaryReader(ms))
            {
                int nLen = br.ReadInt32();
                byte[] rgFmt = br.ReadBytes(nLen);
                fmt = WAVWriter.ByteArrayToStructure<WaveFormat>(rgFmt);
                int nCh = br.ReadInt32();
                int nS = br.ReadInt32();
 
                List<double[]> rgData = new List<double[]>();
                for (int i = 0; i < nCh; i++)
                {
                    rgData.Add(new double[nS]);
                }
 
                for (int i = 0; i < nS; i++)
                {
                    for (int j = 0; j < nCh; j++)
                    {
                        float fVal = br.ReadSingle();
                        rgData[j][i] = fVal;
                    }
                }
 
                return rgData;
            }
        }
 
        public List<int> GetQuerySize()
        {
            List<int> rgSize = new List<int>();
 
            using (FileStream fs = File.OpenRead(m_rgstrFiles[m_nFileIdx]))
            using (WAVReader wav = new WAVReader(fs))
            {
                wav.ReadToEnd(true);
                rgSize.Add(1);
                rgSize.Add((int)wav.Format.nChannels);
                rgSize.Add(wav.SampleCount);
 
                return rgSize;
            }
        }
 
        public void Reset()
        {
            m_nFileIdx = 0;
        }
 
        public byte[] ConvertOutput(float[] rg, out string strType)
        {
            strType = "WAV";
            Dictionary<string, float> rgInfo = QueryInfo();
            WaveFormat fmt = new WaveFormat();
 
            fmt.nAvgBytesPerSec = (uint)rgInfo["AveBytesPerSec"];
            fmt.nBlockAlign = (ushort)rgInfo["BlockAlign"];
            fmt.nChannels = (ushort)rgInfo["Channels"];
            fmt.nSamplesPerSec = (uint)rgInfo["SamplesPerSec"];
            fmt.wBitsPerSample = (ushort)rgInfo["BitsPerSample"];
            fmt.wFormatTag = (ushort)rgInfo["FormatTag"];
 
            List<float[]> rgrgSamples = new List<float[]>();
            for (int i = 0; i < fmt.nChannels; i++)
            {
                rgrgSamples.Add(rg);
            }
 
            return PackBytes(fmt, rgrgSamples);
        }
    }
}