样本中的 Naudio 单元

Question

I've been looking at loads of web pages but none have been able to give an indication of what unit values put in the value array in the ReadInts function in the below code are.

I'm using NAudio to get the samples from an audio interface and can't work out if the values are mv or something else.

I assume i could just dump the memory stream into a file and from that use it like a normal wave file but not 100 % on that.

The data contains multiple channels one for reference and then others which i need to compare to the reference channel for what i'm doing however this doesn't seem possible without know what the unit is.

    public List<byte> Data { get; protected set; }
    public void CreateWaveIn()
    {
        wvin = new NAudio.Wave.WaveInEvent();
        wvin.DeviceNumber = _port;
        wvin.WaveFormat = new NAudio.Wave.WaveFormat(ChosenSampleRate, BitRate, NumberOfChannels);
        wvin.DataAvailable += OnDataAvailable;
        wvin.BufferMilliseconds = 20;
    }

    private void OnDataAvailable(object sender, NAudio.Wave.WaveInEventArgs args)
    {
        int bytesPerSample = (wvin.WaveFormat.BitsPerSample / 8) * wvin.WaveFormat.Channels;
        for (int index = 0; index < args.BytesRecorded; index++)
        {
            if (ObtaingingData)
            {
                Data.Add((args.Buffer[index]));
            }
        }
    }

    public override bool StopObtaingData()
    {
        wvin.StopRecording();
        wvin.DataAvailable -= OnDataAvailable;
        wvin = null;
        ObtaingingData = false;
        WaveStuff();
        return true;
    }

    public WaveStuff()
    {
            using (MemoryStream wave = new MemoryStream())
            {
                wave.Write(Data.ToArray(), 0, Data.Count);
                wave.Position = 0;
                wave.Flush();

                wave.SetLength(wave.Length);

                int endIndex = Data.Count - 1;
                int startIndex = 0;
                int blockCount = (endIndex - startIndex) / fft.BlockSize;

                // endIndex = startIndex + blockCount * fft.BlockSize;

                // Accumulate the FFT of each block
                int blockID = 0;

                // Silently read the first unused samples
                if (wave.CanRead && startIndex > 0)
                {
                    ReadInts(startIndex, channel, wave);
                }

                while (wave.CanRead && blockID < blockCount)
                {
                    int[] data;

                    data = ReadInts(fft.BlockSize, channel, wave);

                    if (data.Length == 0)
                    {
                        break;
                    }

                    fft.Data = data;
                    double[] tmp = fft.GetMagnitudeSpectrum();

                    for (int j = 0; j < tmp.Length; j++)
                    {
                        result[j] += tmp[j];
                    }

                    blockID++;
                    fftCount++;
                }
                wave.Dispose();
            }
    }

    public int[] ReadInts(int count, int selectedChannel, MemoryStream wave)
    {
        int bytesPerSample = BitRate / 8;
        int offset = bytesPerSample * NumberOfChannels;
        int channelOffset = bytesPerSample * selectedChannel;

        byte[] bytes = new byte[count * offset];
        byte[] tempBytes = new byte[4];
        count = Read(bytes, 0, bytes.Length, wave) / offset;
        int[] values = new int[count];
        //   double[] values = new double[count];
        for (int i = 0; i < count; i++)
        {
            switch (BitRate)
            {
                case 8:
                    values[i] = bytes[(i * offset) + channelOffset];
                    break;
                case 16:
                    values[i] = BitConverter.ToInt16(bytes, (i * offset) + channelOffset);
                    break;
                case 24:
                    Array.Copy(bytes, (i * offset) + channelOffset, tempBytes, 1, 3);
                    values[i] = BitConverter.ToInt32(tempBytes, 0) >> 8;
                    break;
                case 32:
                    values[i] = BitConverter.ToInt32(bytes, (i * offset) + channelOffset);
                    break;
                default:
                    break;
            }
        }

        return values;
    }

Answer 1

I would presume the audio is using Pulse Code Modulation , ie each sample represents a pressure level at a given instance of time for a given channel. This would usually not be calibrated or linear, meaning that while a value of 100 would be a higher pressure than 10, there is no telling how much higher or what exact pressure it represents.

If the channels are recorded with the same equipment and settings you should simply be able to subtract samples from one channel from the other. Otherwise you might want to normalize the samples first, i..e find the largest and smallest value for each channel, and re-scale one or the other, or both, to use the same range.