static void ClassifyAndDump(short[] signal, SignalClassifier classifier, string folder, string fileName)
 {
     var result = classifier.Classify(signal).Select(ConvertClassMark).ToArray();
     var dump = new WavFileInfo(DefaultSampleRate, result);
     var filePath = string.Concat(folder, fileName, "_result", ".wav");
     dump.Write(filePath);
 }
        private static void ClassifyAll(string folder, string[] fileNames, SignalClassifier classifier)
        {
            foreach (var fileName in fileNames)
            {
                var wavFile = WavFileInfo.Read(string.Concat(folder, fileName, ".wav"));
                if (wavFile.SampleRate != DefaultSampleRate)
                {
                    throw new Exception(string.Format("File {0} has non-default sample rate", fileName));
                }
                ClassifyAndDump(wavFile.Data, classifier, folder, fileName);

                var markerFile = MarkerFileInfo.Read(string.Concat(folder, fileName, ".mrk"));
                var expectedWavFile = new WavFileInfo(wavFile.SampleRate,
                                                      markerFile.Decompress(wavFile.Data.Length)
                                                                .Select(ConvertClassMark)
                                                                .ToArray());
                expectedWavFile.Write(string.Concat(folder, fileName, "_expected", ".wav"));
            }
        }
        public static WavFileInfo Read(string filePath)
        {
            var ret = new WavFileInfo();
            using (var reader = new BinaryReader(new FileStream(filePath, FileMode.Open)))
            {
                // The "RIFF" chunk descriptor
                ret.ChunkDescriptor = ReadString(reader, 4);
                ret.ChunkSize = reader.ReadInt32();
                ret.Format = ReadString(reader, 4);

                if (ret.ChunkDescriptor != "RIFF" || ret.Format != "WAVE")
                {
                    throw new Exception("File must have WAVE format.");
                }

                // The "FMT" sub-chunk
                ret.Subchunk1Id = ReadString(reader, 4);
                ret.Subchunk1Size = reader.ReadInt32();
                ret.AudioFormat = reader.ReadInt16();
                ret.NumChannels = reader.ReadInt16();
                ret.SampleRate = reader.ReadInt32();
                ret.ByteRate = reader.ReadInt32();
                ret.BlockAlign = reader.ReadInt16();
                ret.BitsPerSample = reader.ReadInt16();

                if (ret.AudioFormat != 1)
                {
                    throw new Exception("File must have WAVE PCM audio format.");
                }
                if (ret.BitsPerSample != 16)
                {
                    throw new Exception("Must be 2 bytes per each sample in WAV file.");
                }
                if (ret.NumChannels != 1)
                {
                    throw new Exception("Must one channel in WAV file. Sorry, only mono!");
                }

                // The "data" sub-chunk
                ret.Subchunk2Id = ReadString(reader, 4);
                ret.Subchunk2Size = reader.ReadInt32();

                var dataLength = ret.Subchunk2Size / sizeof(short);
                ret.Data = new short[dataLength];
                for (var i = 0; i < dataLength; i++)
                    ret.Data[i] = reader.ReadInt16();
            }
            return ret;
        }
 static void ExtractAndDump(short[] signal, IFeatureExtractor featureExtractor, string folder, string fileName)
 {
     var feature = featureExtractor.Extract(signal);
     var dump = new WavFileInfo(DefaultSampleRate, feature);
     var filePath = string.Concat(folder, fileName, featureExtractor.FeatureName, ".wav");
     dump.Write(filePath);
 }