`bitpacked` records on the little-endian machine issue - delphi

Question

I'm trying to use FreePascal on little-endian machine to read and interpret data from integrated circuit. The data essentially consists tightly bitpacked (mostly) big-endian integer numbers, some of them (a lot, actually) are not aligned to byte boundary. So, I've tried to employ FPC's bitpacked records for that and found myself in the deep deep trouble.
The first structure I'm trying to read has the following format:
{$BITPACKING ON}
type
THeader = bitpacked record
Magic: Byte; // format id, 8 bits
_Type: $000..$FFF; // type specifier, 12 bits
Version: Word; // data revision, 16 bits
Flags: $0..$F // attributes, 4 bits
end;
And here is a reading code:
procedure TForm1.FormCreate(Sender: TObject);
var
F: File;
Header: THeader;
begin
Writeln(SizeOf(Header), #9, BitSizeOf(Header)); // reports correctly
Writeln('SizeOf(Header._Type) = ', SizeOf(Header._Type)); // correctly reports 2 bytes
Writeln('BitSizeOf(Header._Type) = ', BitSizeOf(Header._Type)); // correctly reports 12 bits
AssignFile(F, 'D:\3fd8.dat');
FileMode := fmOpenRead;
Reset(F, SizeOf(Byte));
BlockRead(F, Header, SizeOf(Header));
{ data is incorrect beyond this point already }
//Header._Type := BEtoN(Header._Type);
Writeln(IntToHex(Header.Magic, SizeOf(Header.Magic) * 2));
Writeln(IntToHex(BEtoN(Header._Type), SizeOf(Header._Type) * 2));
Writeln(BEtoN(Header.Version));
end;
But the code is printing totally wrong data.
Here is the data and the interpretation done manually:
0000000000: F1 55 BE 3F 0A ...
Magic = F1
_Type = 55B
Version = E3F0
Flags = A
But FPC sees the data in severely different and incorrect way. Looks like a nibbles (and bits) belonging to field are not contiguous due to little-endianess of host machine (eg: nibble B normally should belong to _Type field and nibble E - to Version). Here is a Watches window from Lazarus:
Please advice what I should do with such behaviour. Is this non-contiguous bitfield issue a bug of FPC? Any workarounds possible?

Answer 1

The bytes
F1 55 BE 3F 0A
have the following consecutive nibbles (lower nibble before higher nibble):
1 F 5 5 E B F 3 A 0
If you group these into 2, 3, 4 and 1 nibbles respectively, you get:
1 F --> $F1
5 5 E --> $E55 // highest nibble last, so E is highest.
B F 3 A --> $A3FB // same again: A is highest nibble
0 --> $0
which corresponds to the result you see in the Watch window, and not what you decoded manually.
Now, if the data is big-endian, then you'll have to decode manually using shifts and masking:
X.Magic := bytes[0];
X._Type := (bytes[1] shl 4) or (bytes[2] shr 4);
X.Version := ((bytes[2] and $0F) shl 12) or
(bytes[3] shl 4) or
(bytes[4] shr 4);
X.Flags := bytes[4] and $0F;

Answer 2

I use this function to convert from IEEE format to FPC single:
Type MyReal = Array [1..4] of Byte;
function IeeeToSingle (src:MyReal):Single;
var x:MyReal;
s:single absolute x;
man:word;
exp:word;
ca:single;
cb:cardinal absolute ca; // 4 byte unsigned long int
begin
x:=src;
ca:=s;
if cb>0 then begin // not zero
man := cb shr 16;
exp := (man and $ff00) - $0200;
if ((exp and $8000) <> (man and $8000)) then
MsToIeee := -1; // exponent overflow
man := (man and $7f) or ((man shl 8) and $8000);// move sign
man := man or (exp shr 1);
cb := (cb and $ffff) or (Cardinal(man) shl 16);
end;
IeeeToSingle := ca;
end;