Python f.read（）和Octave fread（）。 =>读取显示相同值的二进制文件

Question

I'm reading a binary file with signal samples both in Octave and Python.

The thing is, I want to obtain the same values for both codes, which is not the case.

The binary file is basically a signal in complex format I,Q recorded as a 16bits Int.

So, based on the Octave code:

[data, cnt_data] = fread(fid, 2 * secondOfData * fs, 'int16');

and then:

data = data(1:2:end) + 1i * data(2:2:end);

It seems simple, just reading the binary data as 16 bits ints. And then creating the final array of complex numbers.

Threfore I assume that in Python I need to do as follows:

rel=int(f.read(2).encode("hex"),16)
img=int(f.read(2).encode("hex"),16)
in_clean.append(complex(rel,img))

Ok, the main problem I have is that both real and imaginary parts values are not the same.

For instance, in Octave, the first value is: -20390 - 10053i

While in Python (applying the code above), the value is: (23216+48088j)

As signs are different, the first thing I thought was that maybe the endianness of the computer that recorded the file and the one I'm using for reading the file are different. So I turned to unpack function, as it allows you to force the endian type.

I was not able to find an "int16" in the unpack documentation: https://docs.python.org/2/library/struct.html

Therefore I went for the "i" option adding "x" (padding bytes) in order to meet the requirement of 32 bits from the table in the "struct" documentation.

So with:

struct.unpack("i","xx"+f.read(2))[0]

the result is (-1336248200-658802568j) Using struct.unpack("<i","xx"+f.read(2))[0] provides the same result.

With:

struct.unpack(">i","xx"+f.read(2))[0]

The value is: (2021153456+2021178328j)

With:

struct.unpack(">i",f.read(2)+"xx")[0]

The value is: (1521514616-1143441288j)

With:

struct.unpack("<i",f.read(2)+"xx")[0]

The value is: (2021175386+2021185723j)

I also tried with numpy and "frombuffer":

np.frombuffer(f.read(1).encode("hex"),dtype=np.int16)

With provides: (24885+12386j)

So, any idea about what I'm doing wrong? I'd like to obtain the same value as in Octave.

What is the proper way of reading and interpreting the values in Python so I can obtain the same value as in Octave by applying fread with an'int16'?

I've been searching on the Internet for an answer for this but I was not able to find a method that provides the same value

Thanks a lot Best regards

Answer 1

It looks like the binary data in your question is 5ab0bbd8 . To unpack signed 16 bit integers with struct.unpack , you use the 'h' format character. From that (23216+48088j) output, it appears that the data is encoded as little-endian, so we need to use < as the first item in the format string.

from struct import unpack

data = b'\x5a\xb0\xbb\xd8'

# The wrong way
rel=int(data[:2].encode("hex"),16)
img=int(data[2:].encode("hex"),16)
c = complex(rel, img)
print c

# The right way
rel, img = unpack('<hh', data)
c = complex(rel, img)
print c 

output

(23216+48088j)
(-20390-10053j)

Note that rel, img = unpack('<hh', data) will also work correctly on Python 3.

---

FWIW, in Python 3, you could also decode 2 bytes to a signed integer like this:

def int16_bytes_to_int(b):
    n = int.from_bytes(b, 'little')
    if n > 0x7fff:
        n -= 0x10000
    return n

The rough equivalent in Python 2 is:

def int16_bytes_to_int(b):
    lo, hi = b
    n = (ord(hi) << 8) + ord(lo)
    if n > 0x7fff:
        n -= 0x10000
    return n

But having to do that subtraction to handle signed numbers is annoying, and using struct.unpack is bound to be much more efficient.