def create_data(version, error_correction, data_list):
buffer = BitBuffer()
for data in data_list:
buffer.put(data.mode, 4)
buffer.put(len(data), length_in_bits(data.mode, version))
data.write(buffer)
# Calculate the maximum number of bits for the given version.
rs_blocks = base.rs_blocks(version, error_correction)
bit_limit = 0
for block in rs_blocks:
bit_limit += block.data_count * 8
if len(buffer) > bit_limit:
raise exceptions.DataOverflowError(
"Code length overflow. Data size (%s) > size available (%s)" %
(len(buffer), bit_limit))
# Terminate the bits (add up to four 0s).
for i in range(min(bit_limit - len(buffer), 4)):
buffer.put_bit(False)
# Delimit the string into 8-bit words, padding with 0s if necessary.
delimit = len(buffer) % 8
if delimit:
for i in range(8 - delimit):
buffer.put_bit(False)
# Add special alternating padding bitstrings until buffer if full.
bytes_to_fill = (bit_limit - len(buffer)) // 8
for i in range(bytes_to_fill):
buffer.put(PAD0 if i % 2 == 0 else PAD1, 8)
return create_bytes(buffer, rs_blocks)
def data_and_version(self, start=None):
if not start:
start = 1
version = bisect(self, 0, start, 41)
if version == 41:
raise exceptions.DataOverflowError()
return self.data_cache, version
def best_fit(self, start=None):
"""
Find the minimum size required to fit in the data.
"""
if start is None:
start = 1
_check_version(start)
# Corresponds to the code in util.create_data, except we don't yet know
# version, so optimistically assume start and check later
mode_sizes = util.mode_sizes_for_version(start)
buffer = util.BitBuffer()
for data in self.data_list:
buffer.put(data.mode, 4)
buffer.put(len(data), mode_sizes[data.mode])
data.write(buffer)
needed_bits = len(buffer)
self.version = bisect_left(util.BIT_LIMIT_TABLE[self.error_correction],
needed_bits, start)
if self.version == 41:
raise exceptions.DataOverflowError()
# Now check whether we need more bits for the mode sizes, recursing if
# our guess was too low
if mode_sizes is not util.mode_sizes_for_version(self.version):
self.best_fit(start=self.version)
return self.version
def create_data(version, error_correction, data_list):
rs_blocks = base.rs_blocks(version, error_correction)
buffer = BitBuffer()
for data in data_list:
buffer.put(data.mode, 4)
buffer.put(len(data), length_in_bits(data.mode, version))
data.write(buffer)
# calc num max data.
total_data_count = 0
for block in rs_blocks:
total_data_count += block.data_count
if len(buffer) > total_data_count * 8:
raise exceptions.DataOverflowError("Code length overflow. Data size "
"(%s) > size available (%s)" %
(len(buffer), total_data_count * 8))
# end code
if len(buffer) + 4 <= total_data_count * 8:
buffer.put(0, 4)
# padding
while len(buffer) % 8:
buffer.put_bit(False)
# padding
while True:
if len(buffer) >= total_data_count * 8:
break
buffer.put(PAD0, 8)
if len(buffer) >= total_data_count * 8:
break
buffer.put(PAD1, 8)
return create_bytes(buffer, rs_blocks)
