Accediendo a los campos de bit mientras lee/escribe estructuras de datos binarios

Question

Estoy escribiendo un analizador para un formato binario. Este formato binario involucra diferentes tablas que están de nuevo en formato binario con tamaños de campo variables generalmente (en algún lugar entre 50 - 100 de ellos).

La mayoría de estas estructuras tendrán campos de bits y se verá algo como esto cuando se representa en C:

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

me encontré con el módulo de estructura pero se dio cuenta de que su resolución más baja fue de un byte y no un poco, de lo contrario el módulo fue el más adecuado para este trabajo.

Sé que los bitfields son compatibles con ctypes, pero no estoy seguro cómo interconectar las estructuras de ctypes que contienen bitfields aquí.

Mi otra opción es manipular los bits yo mismo y alimentarlo en bytes y usarlo con el módulo struct, pero dado que tengo cerca de 50-100 tipos diferentes de tales estructuras, escribir el código para eso se convierte en más error- propenso. También me preocupa la eficiencia, ya que esta herramienta podría usarse para analizar grandes gigabytes de datos binarios.

Gracias.

Answer 1

Usando bitstring (que usted menciona que usted está buscando en) que debería ser bastante fácil de implementar. En primer lugar para crear algunos datos para decodificar:

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

Y entonces la decodificación de nuevo es sólo

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

Su principal preocupación podría ser la velocidad. La biblioteca está bien optimizada Python, pero eso no es tan rápido como lo sería una biblioteca C.

Answer 2

No lo he probado rigurosamente, pero parece funcionar con tipos sin signo (editar: también funciona con tipos de bytes firmados/cortos).

Editar 2: Esto es realmente impredecible. Depende de la forma en que el compilador de la biblioteca empaquetó los bits en la estructura, que no está estandarizada. Por ejemplo, con gcc 4.5.3 funciona siempre que no use el atributo para empaquetar la estructura, es decir, __attribute__ ((__packed__)) (así que en lugar de 6 bytes se empaqueta en 4 bytes, que puede consultar con __alignof__ y sizeof). Puedo hacer que funcione casi añadiendo _pack_ = True a la definición de Estructura de ctypes, pero falla para fieldE. gcc notes: "El desplazamiento del campo de bits empaquetado 'fieldE' ha cambiado en 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]))) 

Salida:

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); 
}