Accesso ai bitfield durante la lettura/scrittura di strutture di dati binari

Question

Sto scrivendo un parser per un formato binario. Questo formato binario coinvolge diverse tabelle che sono di nuovo in formato binario che contengono in genere campi di dimensioni variabili (da qualche parte tra 50 e 100).

La maggior parte di queste strutture avranno campi di bit e sarà simile a questi quando rappresentato in C:

struct myHeader 
{ 
    unsigned char fieldA : 3 
    unsigned char fieldB : 2; 
    unsigned char fieldC : 3; 
    unsigned short fieldD : 14; 
    unsigned char fieldE : 4 
} 

mi sono imbattuto il modulo struct, ma sono reso conto che la sua risoluzione più bassa era un byte e non un po ', altrimenti il modulo praticamente era adatto per questo lavoro.

So che i bitfield sono supportati usando i ctypes, ma non sono sicuro di come interfacciare le strutture di tipo ctypes che contengono bitfield qui.

La mia altra opzione è quella di manipolare i bit personalmente e inserirli in byte e utilizzarli con il modulo struct - ma poiché ho vicino a 50-100 tipi diversi di tali strutture, scrivere il codice per questo diventa più un errore- prona. Sono anche preoccupato per l'efficienza poiché questo strumento potrebbe essere utilizzato per analizzare grandi gigabyte di dati binari.

Grazie.

Answer 1

Utilizzando bitstring (che si parla si sta guardando) dovrebbe essere abbastanza facile da implementare. Prima di creare alcuni dati da decodificare:

>>> myheader = "3, 2, 3, 14, 4" 
>>> a = bitstring.pack(myheader, 1, 0, 5, 1000, 2) 
>>> a.bin 
'00100101000011111010000010' 
>>> a.tobytes() 
'%\x0f\xa0\x80' 

E poi la decodifica di nuovo è solo

>>> a.readlist(myheader) 
[1, 0, 5, 1000, 2] 

vostra preoccupazione principale potrebbe essere la velocità. La libreria è ben ottimizzata per Python, ma non è così veloce come una libreria C.

Answer 2

Non l'ho testato rigorosamente, ma sembra funzionare con tipi senza segno (modifica: funziona anche con byte/tipi con segno).

Modifica 2: Questo è davvero un errore. Dipende dal modo in cui il compilatore della libreria ha inserito i bit nella struttura, che non è standardizzata. Ad esempio, con gcc 4.5.3 funziona fintanto che non utilizzo l'attributo per impacchettare la struct, ovvero __attribute__ ((__packed__)) (quindi anziché 6 byte viene compresso in 4 byte, che è possibile verificare con __alignof__ e sizeof). Posso farlo funzionare quasi aggiungendo _pack_ = True alla definizione Struttura ctypes, ma non riesce per fieldE. Note gcc: "Offset di campo di bit compresso" fieldE "è cambiato in GCC 4.4".

import ctypes 

class MyHeader(ctypes.Structure): 
    _fields_ = [ 
     ('fieldA', ctypes.c_ubyte, 3), 
     ('fieldB', ctypes.c_ubyte, 2), 
     ('fieldC', ctypes.c_ubyte, 3), 
     ('fieldD', ctypes.c_ushort, 14), 
     ('fieldE', ctypes.c_ubyte, 4), 
    ] 

lib = ctypes.cdll.LoadLibrary('C/bitfield.dll') 

hdr = MyHeader() 
lib.set_header(ctypes.byref(hdr)) 

for x in hdr._fields_: 
    print("%s: %d" % (x[0], getattr(hdr, x[0]))) 

uscita:

fieldA: 3 
fieldB: 1 
fieldC: 5 
fieldD: 12345 
fieldE: 9 

C:

typedef struct _MyHeader { 
    unsigned char fieldA : 3; 
    unsigned char fieldB : 2; 
    unsigned char fieldC : 3; 
    unsigned short fieldD : 14; 
    unsigned char fieldE : 4; 
} MyHeader, *pMyHeader; 

int set_header(pMyHeader hdr) { 

    hdr->fieldA = 3; 
    hdr->fieldB = 1; 
    hdr->fieldC = 5; 
    hdr->fieldD = 12345; 
    hdr->fieldE = 9; 

    return(0); 
}