Converting Raw byte data to float[] and values needs to be between -1 and 1

Question

I don't if I am doing it right, but I am using this method to convert a byte array to float array as shown in this link :

public static float[] ConvertByteToFloat(byte[] array) {   
        float[] floatArr = new float[array.Length / 4];   
        for (int i = 0; i < floatArr.Length; i++) {
              if (BitConverter.IsLittleEndian) {
                 Array.Reverse(array, i * 4, 4);
              }
              floatArr[i] = BitConverter.ToSingle(array, i * 4);   
        }   
        return floatArr; 
}

the input array is an array containing wave raw data (with no header)

The problem is that i am getting (after conversion) values like :

-9.66012E+24, 1963.15576, -5.11384777E-36, -1.19718621E-07

How can I convert this array to a float array and its values should be between -1.0 and 1.0?

Edit:

my input array starts like this :

Try removing the `BitConverter.IsLittleEndian` and let's see what happens... — xanatos, May 22 '17 at 10:59
The code seems to be correct (if we ignore the possible `IsLittleEndian` problem)... You could for example tell us some bytes of the sequence (around 16 bytes should be enough)... Are you sure they are 4 bytes floating point values and not 8 bytes doubles? — xanatos, May 22 '17 at 11:02
The `BitConverter.IsLittleEndian` check makes only sense if the array of bytes was created on a big endian machine. If the bytes were created on the same machine reversing them is incorrect. — Krzysztof Bracha, May 22 '17 at 11:11
These bytes do not represent floats between -1 and +1. You need to know what they *do* represent. — Matthew Watson, May 22 '17 at 11:11

Matthew Watson · Accepted Answer · 2017-05-22T11:33:25.637

You can look at the implementation of WriteSample():

    public void WriteSample(float sample)
    {
        if (WaveFormat.BitsPerSample == 16)
        {
            writer.Write((Int16)(Int16.MaxValue * sample));
            dataChunkSize += 2;
        }
        ...

Note how that it converts a float to a 16-bit signed integer by multiplying it by Int16.MaxValue. That's because the internal data format is signed 16-bit integers between -Int16.MaxValue and +Int16.MaxValue.

This means that the values you're working with are Int16 (aka short), and you need to convert them back to floats by dividing them by Int16.MaxValue.

For example, given your sample input:

byte[] bytes = { 232, 255, 235, 255, 232, 255, 235, 255, 232, 255, 235, 255, 232, 255, 235, 255 };

for (int i = 0; i < bytes.Length - 4; i += 4)
{
    float f = BitConverter.ToInt16(bytes, i) / (float)Int16.MaxValue; 
    Console.WriteLine(f);
}

I think this is the right answer, it worked for me, I draw a spectrum and the values are between -1 and 1 and the spectrum is fine. You only need to change float f = BitConverter.ToInt16(bytes, i) / (float)Int16.MaxValue; with float f = BitConverter.ToInt16(bytes, i/4) / (float)Int16.MaxValue; — Mehdi Souregi, May 22 '17 at 11:56

Converting Raw byte data to float[] and values needs to be between -1 and 1

1 Answers1