Question

I’ve a fallowing code which receives byte and probably has to perform convert to float and represent its converted values :

 public float DecodeFloat(byte[] data)
    {
        float x = data[3]|data[2]<<8|data[1]<<16|data[0]<<24;
        return x;
    }

     // receive thread 
  private  void ReceiveData() 
    {
        int count=0;

       IPEndPoint remoteIP = new IPEndPoint(IPAddress.Parse("10.0.2.213"), port);
       client = new UdpClient(remoteIP);
        while (true) 
        {
           try 
            {
                IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
                byte[] data = client.Receive(ref anyIP);

                Vector3 vec,rot;
                float x= DecodeFloat (data);
                float y= DecodeFloat (data + 4);
                float z= DecodeFloat (data + 8);
                float alpha= DecodeFloat (data + 12);
                float theta= DecodeFloat (data +16);
                float phi= DecodeFloat (data+20);

                vec.Set(x,y,z);
                rot.Set (alpha,theta,phi);


                print(">> " + x.ToString() + ", "+ y.ToString() + ", "+ z.ToString() + ", "
                    + alpha.ToString() + ", "+ theta.ToString() + ", "+ phi.ToString());

                // latest UDPpacket
                lastReceivedUDPPacket=x.ToString()+" Packet#: "+count.ToString();
                count = count+1;



            }

Is there anyone to put me in the right way, please?

Answer 1

Given 4 bytes, you would normally only “shift” (<<) if it is integer data. The code in the question basically reads the data as an int (via “shift”), then casts the int to a float. Which is almost certainly not what was intended.

Since you want to interpret it as float, you should probably use:

float val = BitConverter.ToSingle(data, offset);

where offset is the 0, 4, 8, 12 etc shown in your data + 4, data + 8, etc. This treats the 4 bytes (relative to offset) as raw IEEE 754 floating point data. For example:

float x= BitConverter.ToSingle(data, 0);
float y= BitConverter.ToSingle(data, 4);
float z= BitConverter.ToSingle(data, 8);
float alpha= BitConverter.ToSingle(data, 12);
float theta= BitConverter.ToSingle(data, 16);
float phi= BitConverter.ToSingle(data, 20);

Note that this makes assumptions about “endianness” – see BitConverter.IsLittleEndian.

---

Edit: from comments, it sounds like the data is other-endian; try:

public static float ReadSingleBigEndian(byte[] data, int offset)
{
    if (BitConverter.IsLittleEndian)
    {
        byte tmp = data[offset];
        data[offset] = data[offset + 3];
        data[offset + 3] = tmp;
        tmp = data[offset + 1];
        data[offset + 1] = data[offset + 2];
        data[offset + 2] = tmp;
    }
    return BitConverter.ToSingle(data, offset);
}
public static float ReadSingleLittleEndian(byte[] data, int offset)
{
    if (!BitConverter.IsLittleEndian)
    {
        byte tmp = data[offset];
        data[offset] = data[offset + 3];
        data[offset + 3] = tmp;
        tmp = data[offset + 1];
        data[offset + 1] = data[offset + 2];
        data[offset + 2] = tmp;
    }
    return BitConverter.ToSingle(data, offset);
}
...
float x= ReadSingleBigEndian(data, 0);
float y= ReadSingleBigEndian(data, 4);
float z= ReadSingleBigEndian(data, 8);
float alpha= ReadSingleBigEndian(data, 12);
float theta= ReadSingleBigEndian(data, 16);
float phi= ReadSingleBigEndian(data, 20);

If you need to optimize this massively, there are also things you can do with unsafe code to build an int from shifting (picking the endianness when shifting), then do an unsafe coerce to get the int as a float; for example (noting that I haven’t checked endianness here – it might misbehave on a big-endian machine, but most people don’t have those):

public static unsafe float ReadSingleBigEndian(byte[] data, int offset)
{
    int i = (data[offset++] << 24) | (data[offset++] << 16) |
            (data[offset++] << 8) | data[offset];
    return *(float*)&i;
}
public static unsafe float ReadSingleBigEndian(byte[] data, int offset)
{
    int i = (data[offset++]) | (data[offset++] << 8) |
            (data[offset++] << 16) | (data[offset] << 24);
    return *(float*)&i;
}

Or crazier, and CPU-safer:

public static float ReadSingleBigEndian(byte[] data, int offset)
{
    return ReadSingle(data, offset, false);
}
public static float ReadSingleLittleEndian(byte[] data, int offset)
{
    return ReadSingle(data, offset, true);
}
private static unsafe float ReadSingle(byte[] data, int offset,
    bool littleEndian)
{
    fixed (byte* ptr = &data[offset])
    {
        if (littleEndian != BitConverter.IsLittleEndian)
        {   // other-endian; swap
            byte b = ptr[0];
            ptr[0] = ptr[3];
            ptr[3] = b;
            b = ptr[1];
            ptr[1] = ptr[2];
            ptr[2] = b;
        }
        return *(float*)ptr;
    }
}