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

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