sherpa-ncnn/dotnet-examples/decode-file/WaveReader.cs

// Copyright (c)  2023  Xiaomi Corporation (authors: Fangjun Kuang)
using System;
using System.IO;

using System.Runtime.InteropServices;

namespace SherpaNcnn
{

    [StructLayout(LayoutKind.Sequential)]
    public struct WaveHeader
    {
        public Int32 ChunkID;
        public Int32 ChunkSize;
        public Int32 Format;
        public Int32 SubChunk1ID;
        public Int32 SubChunk1Size;
        public Int16 AudioFormat;
        public Int16 NumChannels;
        public Int32 SampleRate;
        public Int32 ByteRate;
        public Int16 BlockAlign;
        public Int16 BitsPerSample;
        public Int32 SubChunk2ID;
        public Int32 SubChunk2Size;

        public bool Validate()
        {
            if (ChunkID != 0x46464952)
            {
                Console.WriteLine($"Invalid chunk ID: 0x{ChunkID:X}. Expect 0x46464952");
                return false;
            }

            //               E V A W
            if (Format != 0x45564157)
            {
                Console.WriteLine($"Invalid format: 0x{Format:X}. Expect 0x45564157");
                return false;
            }

            //                      t m f
            if (SubChunk1ID != 0x20746d66)
            {
                Console.WriteLine($"Invalid SubChunk1ID: 0x{SubChunk1ID:X}. Expect 0x20746d66");
                return false;
            }

            if (SubChunk1Size != 16)
            {
                Console.WriteLine($"Invalid SubChunk1Size: {SubChunk1Size}. Expect 16");
                return false;
            }

            if (AudioFormat != 1)
            {
                Console.WriteLine($"Invalid AudioFormat: {AudioFormat}. Expect 1");
                return false;
            }

            if (NumChannels != 1)
            {
                Console.WriteLine($"Invalid NumChannels: {NumChannels}. Expect 1");
                return false;
            }

            if (ByteRate != (SampleRate * NumChannels * BitsPerSample / 8))
            {
                Console.WriteLine($"Invalid byte rate: {ByteRate}.");
                return false;
            }

            if (BlockAlign != (NumChannels * BitsPerSample / 8))
            {
                Console.WriteLine($"Invalid block align: {ByteRate}.");
                return false;
            }

            if (BitsPerSample != 16)
            {  // we support only 16 bits per sample
                Console.WriteLine($"Invalid bits per sample: {BitsPerSample}. Expect 16");
                return false;
            }

            return true;
        }
    }

    // It supports only 16-bit, single channel WAVE format.
    // The sample rate can be any value.
    public class WaveReader
    {
        public WaveReader(String fileName)
        {
            if (!File.Exists(fileName))
            {
                throw new ApplicationException($"{fileName} does not exist!");
            }

            using (var stream = File.Open(fileName, FileMode.Open))
            {
                using (var reader = new BinaryReader(stream))
                {
                    _header = ReadHeader(reader);

                    if (!_header.Validate())
                    {
                        throw new ApplicationException($"Invalid wave file ${fileName}");
                    }

                    SkipMetaData(reader);

                    // now read samples
                    // _header.SubChunk2Size contains number of bytes in total.
                    // we assume each sample is of type int16
                    byte[] buffer = reader.ReadBytes(_header.SubChunk2Size);
                    short[] samples_int16 = new short[_header.SubChunk2Size / 2];
                    Buffer.BlockCopy(buffer, 0, samples_int16, 0, buffer.Length);

                    _samples = new float[samples_int16.Length];

                    for (var i = 0; i < samples_int16.Length; ++i)
                    {
                        _samples[i] = samples_int16[i] / 32768.0F;
                    }
                }
            }
        }

        private static WaveHeader ReadHeader(BinaryReader reader)
        {
            byte[] bytes = reader.ReadBytes(Marshal.SizeOf(typeof(WaveHeader)));

            GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
            WaveHeader header = (WaveHeader)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(WaveHeader));
            handle.Free();

            return header;
        }

        private void SkipMetaData(BinaryReader reader)
        {
            var bs = reader.BaseStream;

            Int32 subChunk2ID = _header.SubChunk2ID;
            Int32 subChunk2Size = _header.SubChunk2Size;

            while (bs.Position != bs.Length && subChunk2ID != 0x61746164)
            {
                bs.Seek(subChunk2Size, SeekOrigin.Current);
                subChunk2ID = reader.ReadInt32();
                subChunk2Size = reader.ReadInt32();
            }
            _header.SubChunk2ID = subChunk2ID;
            _header.SubChunk2Size = subChunk2Size;
        }

        private WaveHeader _header;

        // Samples are normalized to the range [-1, 1]
        private float[] _samples;

        public int SampleRate => _header.SampleRate;
        public float[] Samples => _samples;

        public static void Test(String fileName)
        {
            WaveReader reader = new WaveReader(fileName);
            Console.WriteLine($"samples length: {reader.Samples.Length}");
            Console.WriteLine($"samples rate: {reader.SampleRate}");
        }
    }

}