Швец Игорь Станиславович 411 Казахстанский филиал BmpParser 18768			Исанбеков Дамир 414 КФ BmpParser 16258
f	1	import sys	f	1	import sys
	2			2
n	3	def extract_bmp_header(content):	n	3	def parse_file_header(data):
	4	if len(content) < 14:		4	if len(data) < 14:
	5	return (None, 'Invalid BMP file')		5	return (None, 'Invalid BMP file')
n	6	if content[:2] != b'BM':	n	6	if data[:2] != b'BM':
	7	return (None, 'Not a Windows BMP')		7	return (None, 'Not a Windows BMP')
n	8	bmp_size = int.from_bytes(content[2:6], 'little')	n	8	file_size = int.from_bytes(data[2:6], 'little')
	9	pixel_offset = int.from_bytes(content[10:14], 'little')		9	offset_to_pixels = int.from_bytes(data[10:14], 'little')
	10	return ((bmp_size, pixel_offset), None)		10	return ((file_size, offset_to_pixels), None)
	11			11
n	12	def validate_bmp_size(content, expected_size):	n	12	def check_file_size(data, declared_size):
	13	return (True, None) if len(content) == expected_size else (False, 'I		13	if declared_size != len(data):
	>	ncorrect size')
				14	return (False, 'Incorrect size')
				15	return (True, None)
	14			16
n	15	def extract_dib_info(content):	n	17	def parse_dib_header(data):
	16	if len(content) < 18:		18	if len(data) < 18:
	17	return (None, 'Incomplete DIB header')		19	return (None, 'Incomplete DIB header')
n	18	header_length = int.from_bytes(content[14:18], 'little')	n	20	dib_size = int.from_bytes(data[14:18], 'little')
	19	if header_length not in {12, 40, 56, 108, 124}:		21	if dib_size not in {12, 40, 56, 108, 124}:
	20	return (None, 'Incorrect header size')		22	return (None, 'Incorrect header size')
n	21	return (header_length, None)	n	23	return (dib_size, None)
	22			24
n	23	def get_image_metadata(content, header_length):	n	25	def retrieve_image_info(data, dib_size):
	24	if header_length == 12:		26	if dib_size == 12:
	25	if len(content) < 26:		27	if len(data) < 26:
	26	return (None, 'DIB header too short')		28	return (None, 'DIB header too short')
n	27	w = int.from_bytes(content[18:20], 'little')	n	29	width = int.from_bytes(data[18:20], 'little')
	28	h = int.from_bytes(content[20:22], 'little', signed=True)		30	height = int.from_bytes(data[20:22], 'little', signed=True)
	29	color_planes = int.from_bytes(content[22:24], 'little')		31	planes = int.from_bytes(data[22:24], 'little')
	30	bit_depth = int.from_bytes(content[24:26], 'little')		32	bit_depth = int.from_bytes(data[24:26], 'little')
	31	compression = 0		33	compression_method = 0
	32	else:		34	else:
n	33	if len(content) < 34:	n	35	if len(data) < 34:
	34	return (None, 'Incomplete DIB header')		36	return (None, 'Incomplete DIB header')
n	35	w = int.from_bytes(content[18:22], 'little', signed=True)	n	37	width = int.from_bytes(data[18:22], 'little', signed=True)
	36	h = int.from_bytes(content[22:26], 'little', signed=True)		38	height = int.from_bytes(data[22:26], 'little', signed=True)
	37	color_planes = int.from_bytes(content[26:28], 'little')		39	planes = int.from_bytes(data[26:28], 'little')
	38	bit_depth = int.from_bytes(content[28:30], 'little')		40	bit_depth = int.from_bytes(data[28:30], 'little')
	39	compression = int.from_bytes(content[30:34], 'little')		41	compression_method = int.from_bytes(data[30:34], 'little')
	40	return ((w, h, bit_depth, compression), None)		42	return ((width, height, bit_depth, compression_method), None)
	41			43
n	42	def compute_pixel_storage(w, h, bit_depth):	n	44	def calculate_pixel_data_size(width, height, bit_depth):
	43	h = abs(h)		45	height = abs(height)
	44	row_size = (w * bit_depth + 31) // 32 * 4		46	row_width = (width * bit_depth + 31) // 32 * 4
	45	return row_size * h		47	return row_width * height
	46			48
n	47	def validate_image_size(content, header_length, computed_size):	n	49	def verify_image_size(data, dib_size, expected_pixel_data_size):
	48	if header_length >= 40 and len(content) >= 38:		50	if dib_size >= 40 and len(data) >= 38:
	49	stated_size = int.from_bytes(content[34:38], 'little')		51	declared_image_size = int.from_bytes(data[34:38], 'little')
	50	else:		52	else:
n	51	stated_size = 0	n	53	declared_image_size = 0
	52	if stated_size == 0:		54	if declared_image_size == 0:
	53	stated_size = computed_size		55	declared_image_size = expected_pixel_data_size
	54	elif stated_size not in {computed_size, computed_size + 2}:		56	elif declared_image_size not in {expected_pixel_data_size, expected_
				>	pixel_data_size + 2}:
	55	return (False, 'Incorrect image size')		57	return (False, 'Incorrect image size')
n	56	pad = 2 if stated_size > computed_size else 0	n	58	extra_bytes = 2 if declared_image_size > expected_pixel_data_size el
				>	se 0
	57	return (pad, None)		59	return (extra_bytes, None)
	58			60
n	59	def parse_bmp(content):	n	61	def analyze_bmp(data):
	60	try:		62	try:
n	61	header, err = extract_bmp_header(content)	n	63	header, error = parse_file_header(data)
	62	if err:		64	if error:
	63	return err		65	return error
	64	bmp_size, pixel_offset = header		66	file_size, pixel_data_offset = header
	65	is_valid, err = validate_bmp_size(content, bmp_size)		67	valid, error = check_file_size(data, file_size)
	66	if not is_valid:		68	if not valid:
	67	return err		69	return error
	68	dib_length, err = extract_dib_info(content)		70	dib_size, error = parse_dib_header(data)
	69	if err:		71	if error:
	70	return err		72	return error
	71	metadata, err = get_image_metadata(content, dib_length)		73	image_data, error = retrieve_image_info(data, dib_size)
	72	if err:		74	if error:
	73	return err		75	return error
	74	w, h, bit_depth, compression = metadata		76	width, height, bit_depth, compression = image_data
	75	required_size = compute_pixel_storage(w, h, bit_depth)		77	expected_pixel_data_size = calculate_pixel_data_size(width, heig
				>	ht, bit_depth)
	76	pad_size, err = validate_image_size(content, dib_length, require		78	padding_bytes, error = verify_image_size(data, dib_size, expecte
	>	d_size)		>	d_pixel_data_size)
	77	if err:		79	if error:
	78	return err		80	return error
	79	return f'{w} {abs(h)} {bit_depth} {compression} {pad_size}'		81	return f'{width} {abs(height)} {bit_depth} {compression} {paddin
				>	g_bytes}'
	80	except Exception as ex:		82	except Exception as exc:
	81	return f'Unhandled error: {ex}'		83	return f'Unhandled error: {exc}'
	82	if __name__ == '__main__':		84	if __name__ == '__main__':
t	83	bmp_data = sys.stdin.buffer.read()	t	85	bmp_content = sys.stdin.buffer.read()
	84	print(parse_bmp(bmp_data))		86	analysis_result = analyze_bmp(bmp_content)
				87	print(analysis_result)

Legends
Colors  Added  Changed Deleted	Links (f)irst change (n)ext change (t)op