bits, bytes, bitstring, and ConstBitStream

bogotobogo.com site search:

bit manipulations

int

 int(x, base=10)

Convert a number or string x to an integer, or return 0 if no arguments are given.

>>> int('00100001', 2)
33

>>> int('0xff',16)
255

>>> int('ff', 16)
255

hex string

To convert to hex string:

>>> "0x%x" % (int('00100001', 2))
'0x21'

char

>>> chr(int('01011110',2))
'^'
>>> int('01000000',2)
64
>>> chr(int('01000000',2))
'@'

>>> int('01110100', 2)
116
>>> chr(int('01110100', 2))
't'
>>> ord('t')
116

bitstring

bitstring classes

The bitstring classes provides four classes:

BitStream and BitArray and their immutable versions ConstBitStream and Bits:

Bits (object): This is the most basic class. It is immutable and so its contents can't be changed after creation.
BitArray (Bits): This adds mutating methods to its base class.
ConstBitStream (Bits): This adds methods and properties to allow the bits to be treated as a stream of bits, with a bit position and reading/parsing methods.
BitStream (BitArray, ConstBitStream): This is the most versative class, having both the bitstream methods and the mutating methods.

hexstring

>>> from bitstring import BitStream, BitArray
>>> c = BitArray(hex='000001b3')
>>> c
BitArray('0x000001b3')
>>> c.hex
'000001b3'

binary string

>>> d = BitArray(bin='0011 00')
>>> d
BitArray('0b001100')
>>> d.bin
'001100'

from int

>>> a = BitArray(uint=45, length=12)
>>> b = BitArray(int=-1, length=7)
>>> a, b
(BitArray('0x02d'), BitArray('0b1111111'))
>>> a.bin
'000000101101'
>>> b.bin
'1111111'

from raw byte

>>> a = BitArray(bytes=b'\x00\x01\x02\xff', length=28, offset=1)
>>> a
BitArray('0x000205f')
>>> a.bin
'0000000000000010000001011111'
>>> a.hex
'000205f'

>>> b = BitArray(bytes=open('video.mp4', 'rb').read())
>>> b
BitArray('0x000000206674797069736f6d0000020069736f6d69736f32617663316d7034310000000866726565048e01fe6d64617400000000001d67640015acd941e08effc0220021c4000003000400000300ca3c58b6580000000668ebe2cb22c0000002d30605ffffcfdc45e9bde6d948b7962cd820d923eeef78323634202d20...') # length=614024968

ConstBitStream class

 class bitstring.ConstBitStream([auto, length, offset, **kwargs])

peek

>>> from bitstring import ConstBitStream
>>> s = ConstBitStream('0x123456')
>>> s
ConstBitStream('0x123456')
>>> s.peek(12)  # 12 bits 
ConstBitStream('0x123')
>>> s.peek('hex:12')
'123'

peek reads from the current bit position pos in the bitstring according to the fmt string or integer and returns the result. The bit position is unchanged.

read

read(fmt)

It reads from current bit position pos in the bitstring according the the format string and returns a single result.

int:n 	n bits as a signed integer.
uint:n 	n bits as an unsigned integer.
hex:n 	n bits as a hexadecimal string.
bin:n 	n bits as a binary string.
bits:n 	n bits as a new bitstring.
bytes:n n bytes as bytes object.

The sample run below shows it advances 4 bits each time we read a hex number:

>>> s = ConstBitStream('0x1234')
>>> s
ConstBitStream('0x1234')
>>> s.read('hex:4')
'1'
>>> s.read('hex:4')
'2'
>>> s.read('hex:4')
'3'
>>> s.read('hex:4')
'4'

If we read 4 bits and output it as a binary format:

>>> s = ConstBitStream('0x1234')
>>> s.read('bin:4')
'0001'
>>> s.read('bin:4')
'0010'
>>> s.read('bin:4')
'0011'
>>> s.read('bin:4')
'0100'

Output as an unsigned integer as we read in 4 bits each time and advance:

>>> s = ConstBitStream('0x1234')
>>> s.read('uint:4')
1
>>> s.read('uint:4')
2
>>> s.read('uint:4')
3
>>> s.read('uint:4')
4

pos and bitpos

pos/bitpos is a read and write property for setting and getting the current bit position in the bitstring. Can be set to any value from 0 to len.

>>> s = ConstBitStream('0x1234')
>>> s.read('uint:4')
1
>>> s.pos
4
>>> s.pos += 4
>>> s.read('uint:4')
3
>>> s.read('uint:4')
4

The following code reads in video.mp4 one byte at a time, convert it to character, and then puts it into a list. It reads only the first 180 bytes.

from bitstring import ConstBitStream

info = []
nbytes = 180
with open('video.mp4', 'rb)') as vfile:
    packet = ConstBitStream(bytes = vfile.read(nbytes), length = nbytes*8)
    while(packet.pos < nbytes*8):
        #byte = packet.read(8).hex
        #info.append(chr(int(byte, 16)))
        byte = packet.read(8).uint
        info.append(chr(byte))
    print info

The output looks like this:

['\x00', '\x00', '\x00', ' ', 'f', 't', 'y', 'p', 'i', 's', 'o', 'm', 
'\x00', '\x00', '\x02', '\x00', 'i', 's', 'o', 'm', 'i', 's', 'o', '2', 
'a', 'v', 'c', '1', 'm', 'p', '4', '1', '\x00', '\x00', '\x00', '\x08', 
'f', 'r', 'e', 'e', '\x04', '\x8e', '\x01', '\xfe', 'm', 'd', 'a', 't', 
'\x00', '\x00', '\x00', '\x00', '\x00', '\x1d', 'g', 'd', '\x00', 
'\x15', '\xac', '\xd9', 'A', '\xe0', '\x8e', '\xff', '\xc0', '"', 
'\x00', '!', '\xc4', '\x00', '\x00', '\x03', '\x00', '\x04', '\x00', 
'\x00', '\x03', '\x00', '\xca', '<', 'X', '\xb6', 'X', '\x00', '\x00', 
'\x00', '\x06', 'h', '\xeb', '\xe2', '\xcb', '"', '\xc0', '\x00', 
'\x00', '\x02', '\xd3', '\x06', '\x05', '\xff', '\xff', '\xcf', '\xdc', 
'E', '\xe9', '\xbd', '\xe6', '\xd9', 'H', '\xb7', '\x96', ',', '\xd8', 
' ', '\xd9', '#', '\xee', '\xef', 'x', '2', '6', '4', ' ', '-', ' ', 
'c', 'o', 'r', 'e', ' ', '1', '4', '0', ' ', 'r', '2', ' ', '1', 'c', 
'a', '7', 'b', 'b', '9', ' ', '-', ' ', 'H', '.', '2', '6', '4', '/', 
'M', 'P', 'E', 'G', '-', '4', ' ', 'A', 'V', 'C', ' ', 'c', 'o', 'd', 
'e', 'c', ' ', '-', ' ', 'C', 'o', 'p', 'y', 'l', 'e', 'f', 't']