# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild from pkg_resources import parse_version from .kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO import collections from enum import Enum if parse_version(ks_version) < parse_version('0.7'): raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version)) class Icc4(KaitaiStruct): SEQ_FIELDS = ["header", "tag_table"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['header']['start'] = self._io.pos() self.header = self._root.ProfileHeader(self._io, self, self._root) self.header._read() self._debug['header']['end'] = self._io.pos() self._debug['tag_table']['start'] = self._io.pos() self.tag_table = self._root.TagTable(self._io, self, self._root) self.tag_table._read() self._debug['tag_table']['end'] = self._io.pos() class U8Fixed8Number(KaitaiStruct): SEQ_FIELDS = ["number"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['number']['start'] = self._io.pos() self.number = self._io.read_bytes(2) self._debug['number']['end'] = self._io.pos() class U16Fixed16Number(KaitaiStruct): SEQ_FIELDS = ["number"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['number']['start'] = self._io.pos() self.number = self._io.read_bytes(4) self._debug['number']['end'] = self._io.pos() class StandardIlluminantEncoding(KaitaiStruct): class StandardIlluminantEncodings(Enum): unknown = 0 d50 = 1 d65 = 2 d93 = 3 f2 = 4 d55 = 5 a = 6 equi_power = 7 f8 = 8 SEQ_FIELDS = ["standard_illuminant_encoding"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['standard_illuminant_encoding']['start'] = self._io.pos() self.standard_illuminant_encoding = KaitaiStream.resolve_enum(self._root.StandardIlluminantEncoding.StandardIlluminantEncodings, self._io.read_u4be()) self._debug['standard_illuminant_encoding']['end'] = self._io.pos() class ProfileHeader(KaitaiStruct): class CmmSignatures(Enum): the_imaging_factory_cmm = 858931796 agfa_cmm = 1094929747 adobe_cmm = 1094992453 color_gear_cmm = 1128484179 logosync_cmm = 1147629395 efi_cmm = 1162234144 exact_scan_cmm = 1163411779 fuji_film_cmm = 1179000864 harlequin_rip_cmm = 1212370253 heidelberg_cmm = 1212435744 kodak_cmm = 1262701907 konica_minolta_cmm = 1296256324 device_link_cmm = 1380404563 sample_icc_cmm = 1397310275 mutoh_cmm = 1397311310 toshiba_cmm = 1413696845 color_gear_cmm_lite = 1430471501 color_gear_cmm_c = 1430474067 windows_color_system_cmm = 1464029984 ware_to_go_cmm = 1465141024 apple_cmm = 1634758764 argyll_cms_cmm = 1634887532 little_cms_cmm = 1818455411 zoran_cmm = 2053320752 class PrimaryPlatforms(Enum): apple_computer_inc = 1095782476 microsoft_corporation = 1297303124 silicon_graphics_inc = 1397180704 sun_microsystems = 1398099543 class ProfileClasses(Enum): abstract_profile = 1633842036 device_link_profile = 1818848875 display_device_profile = 1835955314 named_color_profile = 1852662636 output_device_profile = 1886549106 input_device_profile = 1935896178 color_space_profile = 1936744803 class RenderingIntents(Enum): perceptual = 0 media_relative_colorimetric = 1 saturation = 2 icc_absolute_colorimetric = 3 class DataColourSpaces(Enum): two_colour = 843271250 three_colour = 860048466 four_colour = 876825682 five_colour = 893602898 six_colour = 910380114 seven_colour = 927157330 eight_colour = 943934546 nine_colour = 960711762 ten_colour = 1094929490 eleven_colour = 1111706706 twelve_colour = 1128483922 cmy = 1129142560 cmyk = 1129142603 thirteen_colour = 1145261138 fourteen_colour = 1162038354 fifteen_colour = 1178815570 gray = 1196573017 hls = 1212961568 hsv = 1213421088 cielab_or_pcslab = 1281450528 cieluv = 1282766368 rgb = 1380401696 nciexyz_or_pcsxyz = 1482250784 ycbcr = 1497588338 cieyxy = 1501067552 SEQ_FIELDS = ["size", "preferred_cmm_type", "version", "device_class", "color_space", "pcs", "creation_date_time", "file_signature", "primary_platform", "profile_flags", "device_manufacturer", "device_model", "device_attributes", "rendering_intent", "nciexyz_values_of_illuminant_of_pcs", "creator", "identifier", "reserved_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['size']['start'] = self._io.pos() self.size = self._io.read_u4be() self._debug['size']['end'] = self._io.pos() self._debug['preferred_cmm_type']['start'] = self._io.pos() self.preferred_cmm_type = KaitaiStream.resolve_enum(self._root.ProfileHeader.CmmSignatures, self._io.read_u4be()) self._debug['preferred_cmm_type']['end'] = self._io.pos() self._debug['version']['start'] = self._io.pos() self.version = self._root.ProfileHeader.VersionField(self._io, self, self._root) self.version._read() self._debug['version']['end'] = self._io.pos() self._debug['device_class']['start'] = self._io.pos() self.device_class = KaitaiStream.resolve_enum(self._root.ProfileHeader.ProfileClasses, self._io.read_u4be()) self._debug['device_class']['end'] = self._io.pos() self._debug['color_space']['start'] = self._io.pos() self.color_space = KaitaiStream.resolve_enum(self._root.ProfileHeader.DataColourSpaces, self._io.read_u4be()) self._debug['color_space']['end'] = self._io.pos() self._debug['pcs']['start'] = self._io.pos() self.pcs = (self._io.read_bytes(4)).decode(u"ASCII") self._debug['pcs']['end'] = self._io.pos() self._debug['creation_date_time']['start'] = self._io.pos() self.creation_date_time = self._root.DateTimeNumber(self._io, self, self._root) self.creation_date_time._read() self._debug['creation_date_time']['end'] = self._io.pos() self._debug['file_signature']['start'] = self._io.pos() self.file_signature = self._io.ensure_fixed_contents(b"\x61\x63\x73\x70") self._debug['file_signature']['end'] = self._io.pos() self._debug['primary_platform']['start'] = self._io.pos() self.primary_platform = KaitaiStream.resolve_enum(self._root.ProfileHeader.PrimaryPlatforms, self._io.read_u4be()) self._debug['primary_platform']['end'] = self._io.pos() self._debug['profile_flags']['start'] = self._io.pos() self.profile_flags = self._root.ProfileHeader.ProfileFlags(self._io, self, self._root) self.profile_flags._read() self._debug['profile_flags']['end'] = self._io.pos() self._debug['device_manufacturer']['start'] = self._io.pos() self.device_manufacturer = self._root.DeviceManufacturer(self._io, self, self._root) self.device_manufacturer._read() self._debug['device_manufacturer']['end'] = self._io.pos() self._debug['device_model']['start'] = self._io.pos() self.device_model = (self._io.read_bytes(4)).decode(u"ASCII") self._debug['device_model']['end'] = self._io.pos() self._debug['device_attributes']['start'] = self._io.pos() self.device_attributes = self._root.DeviceAttributes(self._io, self, self._root) self.device_attributes._read() self._debug['device_attributes']['end'] = self._io.pos() self._debug['rendering_intent']['start'] = self._io.pos() self.rendering_intent = KaitaiStream.resolve_enum(self._root.ProfileHeader.RenderingIntents, self._io.read_u4be()) self._debug['rendering_intent']['end'] = self._io.pos() self._debug['nciexyz_values_of_illuminant_of_pcs']['start'] = self._io.pos() self.nciexyz_values_of_illuminant_of_pcs = self._root.XyzNumber(self._io, self, self._root) self.nciexyz_values_of_illuminant_of_pcs._read() self._debug['nciexyz_values_of_illuminant_of_pcs']['end'] = self._io.pos() self._debug['creator']['start'] = self._io.pos() self.creator = self._root.DeviceManufacturer(self._io, self, self._root) self.creator._read() self._debug['creator']['end'] = self._io.pos() self._debug['identifier']['start'] = self._io.pos() self.identifier = self._io.read_bytes(16) self._debug['identifier']['end'] = self._io.pos() self._debug['reserved_data']['start'] = self._io.pos() self.reserved_data = self._io.read_bytes(28) self._debug['reserved_data']['end'] = self._io.pos() class VersionField(KaitaiStruct): SEQ_FIELDS = ["major", "minor", "bug_fix_level", "reserved"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['major']['start'] = self._io.pos() self.major = self._io.ensure_fixed_contents(b"\x04") self._debug['major']['end'] = self._io.pos() self._debug['minor']['start'] = self._io.pos() self.minor = self._io.read_bits_int(4) self._debug['minor']['end'] = self._io.pos() self._debug['bug_fix_level']['start'] = self._io.pos() self.bug_fix_level = self._io.read_bits_int(4) self._debug['bug_fix_level']['end'] = self._io.pos() self._io.align_to_byte() self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00") self._debug['reserved']['end'] = self._io.pos() class ProfileFlags(KaitaiStruct): SEQ_FIELDS = ["embedded_profile", "profile_can_be_used_independently_of_embedded_colour_data", "other_flags"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['embedded_profile']['start'] = self._io.pos() self.embedded_profile = self._io.read_bits_int(1) != 0 self._debug['embedded_profile']['end'] = self._io.pos() self._debug['profile_can_be_used_independently_of_embedded_colour_data']['start'] = self._io.pos() self.profile_can_be_used_independently_of_embedded_colour_data = self._io.read_bits_int(1) != 0 self._debug['profile_can_be_used_independently_of_embedded_colour_data']['end'] = self._io.pos() self._debug['other_flags']['start'] = self._io.pos() self.other_flags = self._io.read_bits_int(30) self._debug['other_flags']['end'] = self._io.pos() class XyzNumber(KaitaiStruct): SEQ_FIELDS = ["x", "y", "z"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['x']['start'] = self._io.pos() self.x = self._io.read_bytes(4) self._debug['x']['end'] = self._io.pos() self._debug['y']['start'] = self._io.pos() self.y = self._io.read_bytes(4) self._debug['y']['end'] = self._io.pos() self._debug['z']['start'] = self._io.pos() self.z = self._io.read_bytes(4) self._debug['z']['end'] = self._io.pos() class DateTimeNumber(KaitaiStruct): SEQ_FIELDS = ["year", "month", "day", "hour", "minute", "second"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['year']['start'] = self._io.pos() self.year = self._io.read_u2be() self._debug['year']['end'] = self._io.pos() self._debug['month']['start'] = self._io.pos() self.month = self._io.read_u2be() self._debug['month']['end'] = self._io.pos() self._debug['day']['start'] = self._io.pos() self.day = self._io.read_u2be() self._debug['day']['end'] = self._io.pos() self._debug['hour']['start'] = self._io.pos() self.hour = self._io.read_u2be() self._debug['hour']['end'] = self._io.pos() self._debug['minute']['start'] = self._io.pos() self.minute = self._io.read_u2be() self._debug['minute']['end'] = self._io.pos() self._debug['second']['start'] = self._io.pos() self.second = self._io.read_u2be() self._debug['second']['end'] = self._io.pos() class Response16Number(KaitaiStruct): SEQ_FIELDS = ["number", "reserved", "measurement_value"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['number']['start'] = self._io.pos() self.number = self._io.read_u4be() self._debug['number']['end'] = self._io.pos() self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['measurement_value']['start'] = self._io.pos() self.measurement_value = self._root.S15Fixed16Number(self._io, self, self._root) self.measurement_value._read() self._debug['measurement_value']['end'] = self._io.pos() class U1Fixed15Number(KaitaiStruct): SEQ_FIELDS = ["number"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['number']['start'] = self._io.pos() self.number = self._io.read_bytes(2) self._debug['number']['end'] = self._io.pos() class TagTable(KaitaiStruct): SEQ_FIELDS = ["tag_count", "tags"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_count']['start'] = self._io.pos() self.tag_count = self._io.read_u4be() self._debug['tag_count']['end'] = self._io.pos() self._debug['tags']['start'] = self._io.pos() self.tags = [None] * (self.tag_count) for i in range(self.tag_count): if not 'arr' in self._debug['tags']: self._debug['tags']['arr'] = [] self._debug['tags']['arr'].append({'start': self._io.pos()}) _t_tags = self._root.TagTable.TagDefinition(self._io, self, self._root) _t_tags._read() self.tags[i] = _t_tags self._debug['tags']['arr'][i]['end'] = self._io.pos() self._debug['tags']['end'] = self._io.pos() class TagDefinition(KaitaiStruct): class TagSignatures(Enum): a_to_b_0 = 1093812784 a_to_b_1 = 1093812785 a_to_b_2 = 1093812786 b_to_a_0 = 1110589744 b_to_a_1 = 1110589745 b_to_a_2 = 1110589746 b_to_d_0 = 1110590512 b_to_d_1 = 1110590513 b_to_d_2 = 1110590514 b_to_d_3 = 1110590515 d_to_b_0 = 1144144432 d_to_b_1 = 1144144433 d_to_b_2 = 1144144434 d_to_b_3 = 1144144435 blue_trc = 1649693251 blue_matrix_column = 1649957210 calibration_date_time = 1667329140 chromatic_adaptation = 1667785060 chromaticity = 1667789421 colorimetric_intent_image_state = 1667852659 colorant_table_out = 1668050804 colorant_order = 1668051567 colorant_table = 1668051572 copyright = 1668313716 profile_description = 1684370275 device_model_desc = 1684890724 device_mfg_desc = 1684893284 green_trc = 1733579331 green_matrix_column = 1733843290 gamut = 1734438260 gray_trc = 1800688195 luminance = 1819635049 measurement = 1835360627 named_color_2 = 1852009522 preview_0 = 1886545200 preview_1 = 1886545201 preview_2 = 1886545202 profile_sequence = 1886610801 profile_sequence_identifier = 1886611812 red_trc = 1918128707 red_matrix_column = 1918392666 output_response = 1919251312 perceptual_rendering_intent_gamut = 1919510320 saturation_rendering_intent_gamut = 1919510322 char_target = 1952543335 technology = 1952801640 viewing_conditions = 1986618743 viewing_cond_desc = 1987405156 media_white_point = 2004119668 class TagTypeSignatures(Enum): xyz_type = 1482250784 colorant_table_type = 1668051572 curve_type = 1668641398 data_type = 1684108385 date_time_type = 1685350765 multi_function_a_to_b_table_type = 1832993312 multi_function_b_to_a_table_type = 1833058592 measurement_type = 1835360627 multi_function_table_with_one_byte_precision_type = 1835430961 multi_function_table_with_two_byte_precision_type = 1835430962 multi_localized_unicode_type = 1835824483 multi_process_elements_type = 1836082548 named_color_2_type = 1852009522 parametric_curve_type = 1885434465 profile_sequence_desc_type = 1886610801 profile_sequence_identifier_type = 1886611812 response_curve_set_16_type = 1919120178 s_15_fixed_16_array_type = 1936077618 signature_type = 1936287520 text_type = 1952807028 u_16_fixed_16_array_type = 1969632050 u_int_8_array_type = 1969827896 u_int_16_array_type = 1969828150 u_int_32_array_type = 1969828658 u_int_64_array_type = 1969829428 viewing_conditions_type = 1986618743 class MultiProcessElementsTypes(Enum): bacs_element_type = 1648444243 clut_element_type = 1668052340 one_dimensional_curves_type = 1668641382 eacs_element_type = 1698775891 matrix_element_type = 1835103334 curve_set_element_table_type = 1835428980 formula_curve_segments_type = 1885434470 sampled_curve_segment_type = 1935764838 SEQ_FIELDS = ["tag_signature", "offset_to_data_element", "size_of_data_element"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_signature']['start'] = self._io.pos() self.tag_signature = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagSignatures, self._io.read_u4be()) self._debug['tag_signature']['end'] = self._io.pos() self._debug['offset_to_data_element']['start'] = self._io.pos() self.offset_to_data_element = self._io.read_u4be() self._debug['offset_to_data_element']['end'] = self._io.pos() self._debug['size_of_data_element']['start'] = self._io.pos() self.size_of_data_element = self._io.read_u4be() self._debug['size_of_data_element']['end'] = self._io.pos() class BlueMatrixColumnTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.xyz_type: self.tag_data = self._root.TagTable.TagDefinition.XyzType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class DeviceMfgDescTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_localized_unicode_type: self.tag_data = self._root.TagTable.TagDefinition.MultiLocalizedUnicodeType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class NamedColor2Type(KaitaiStruct): SEQ_FIELDS = ["reserved", "vendor_specific_flag", "count_of_named_colours", "number_of_device_coordinates_for_each_named_colour", "prefix_for_each_colour_name", "prefix_for_each_colour_name_padding", "suffix_for_each_colour_name", "suffix_for_each_colour_name_padding", "named_colour_definitions"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['vendor_specific_flag']['start'] = self._io.pos() self.vendor_specific_flag = self._io.read_u4be() self._debug['vendor_specific_flag']['end'] = self._io.pos() self._debug['count_of_named_colours']['start'] = self._io.pos() self.count_of_named_colours = self._io.read_u4be() self._debug['count_of_named_colours']['end'] = self._io.pos() self._debug['number_of_device_coordinates_for_each_named_colour']['start'] = self._io.pos() self.number_of_device_coordinates_for_each_named_colour = self._io.read_u4be() self._debug['number_of_device_coordinates_for_each_named_colour']['end'] = self._io.pos() self._debug['prefix_for_each_colour_name']['start'] = self._io.pos() self.prefix_for_each_colour_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII") self._debug['prefix_for_each_colour_name']['end'] = self._io.pos() self._debug['prefix_for_each_colour_name_padding']['start'] = self._io.pos() self.prefix_for_each_colour_name_padding = [None] * ((32 - len(self.prefix_for_each_colour_name))) for i in range((32 - len(self.prefix_for_each_colour_name))): if not 'arr' in self._debug['prefix_for_each_colour_name_padding']: self._debug['prefix_for_each_colour_name_padding']['arr'] = [] self._debug['prefix_for_each_colour_name_padding']['arr'].append({'start': self._io.pos()}) self.prefix_for_each_colour_name_padding = self._io.ensure_fixed_contents(b"\x00") self._debug['prefix_for_each_colour_name_padding']['arr'][i]['end'] = self._io.pos() self._debug['prefix_for_each_colour_name_padding']['end'] = self._io.pos() self._debug['suffix_for_each_colour_name']['start'] = self._io.pos() self.suffix_for_each_colour_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII") self._debug['suffix_for_each_colour_name']['end'] = self._io.pos() self._debug['suffix_for_each_colour_name_padding']['start'] = self._io.pos() self.suffix_for_each_colour_name_padding = [None] * ((32 - len(self.suffix_for_each_colour_name))) for i in range((32 - len(self.suffix_for_each_colour_name))): if not 'arr' in self._debug['suffix_for_each_colour_name_padding']: self._debug['suffix_for_each_colour_name_padding']['arr'] = [] self._debug['suffix_for_each_colour_name_padding']['arr'].append({'start': self._io.pos()}) self.suffix_for_each_colour_name_padding = self._io.ensure_fixed_contents(b"\x00") self._debug['suffix_for_each_colour_name_padding']['arr'][i]['end'] = self._io.pos() self._debug['suffix_for_each_colour_name_padding']['end'] = self._io.pos() self._debug['named_colour_definitions']['start'] = self._io.pos() self.named_colour_definitions = [None] * (self.count_of_named_colours) for i in range(self.count_of_named_colours): if not 'arr' in self._debug['named_colour_definitions']: self._debug['named_colour_definitions']['arr'] = [] self._debug['named_colour_definitions']['arr'].append({'start': self._io.pos()}) _t_named_colour_definitions = self._root.TagTable.TagDefinition.NamedColor2Type.NamedColourDefinition(self._io, self, self._root) _t_named_colour_definitions._read() self.named_colour_definitions[i] = _t_named_colour_definitions self._debug['named_colour_definitions']['arr'][i]['end'] = self._io.pos() self._debug['named_colour_definitions']['end'] = self._io.pos() class NamedColourDefinition(KaitaiStruct): SEQ_FIELDS = ["root_name", "root_name_padding", "pcs_coordinates", "device_coordinates"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['root_name']['start'] = self._io.pos() self.root_name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII") self._debug['root_name']['end'] = self._io.pos() self._debug['root_name_padding']['start'] = self._io.pos() self.root_name_padding = [None] * ((32 - len(self.root_name))) for i in range((32 - len(self.root_name))): if not 'arr' in self._debug['root_name_padding']: self._debug['root_name_padding']['arr'] = [] self._debug['root_name_padding']['arr'].append({'start': self._io.pos()}) self.root_name_padding = self._io.ensure_fixed_contents(b"\x00") self._debug['root_name_padding']['arr'][i]['end'] = self._io.pos() self._debug['root_name_padding']['end'] = self._io.pos() self._debug['pcs_coordinates']['start'] = self._io.pos() self.pcs_coordinates = self._io.read_bytes(6) self._debug['pcs_coordinates']['end'] = self._io.pos() if self._parent.number_of_device_coordinates_for_each_named_colour > 0: self._debug['device_coordinates']['start'] = self._io.pos() self.device_coordinates = [None] * (self._parent.count_of_named_colours) for i in range(self._parent.count_of_named_colours): if not 'arr' in self._debug['device_coordinates']: self._debug['device_coordinates']['arr'] = [] self._debug['device_coordinates']['arr'].append({'start': self._io.pos()}) self.device_coordinates[i] = self._io.read_u2be() self._debug['device_coordinates']['arr'][i]['end'] = self._io.pos() self._debug['device_coordinates']['end'] = self._io.pos() class ViewingConditionsTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.viewing_conditions_type: self.tag_data = self._root.TagTable.TagDefinition.ViewingConditionsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class BlueTrcTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.curve_type: self.tag_data = self._root.TagTable.TagDefinition.CurveType(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.parametric_curve_type: self.tag_data = self._root.TagTable.TagDefinition.ParametricCurveType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ResponseCurveSet16Type(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_channels", "count_of_measurement_types", "response_curve_structure_offsets", "response_curve_structures"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_channels']['start'] = self._io.pos() self.number_of_channels = self._io.read_u2be() self._debug['number_of_channels']['end'] = self._io.pos() self._debug['count_of_measurement_types']['start'] = self._io.pos() self.count_of_measurement_types = self._io.read_u2be() self._debug['count_of_measurement_types']['end'] = self._io.pos() self._debug['response_curve_structure_offsets']['start'] = self._io.pos() self.response_curve_structure_offsets = [None] * (self.count_of_measurement_types) for i in range(self.count_of_measurement_types): if not 'arr' in self._debug['response_curve_structure_offsets']: self._debug['response_curve_structure_offsets']['arr'] = [] self._debug['response_curve_structure_offsets']['arr'].append({'start': self._io.pos()}) self.response_curve_structure_offsets[i] = self._io.read_u4be() self._debug['response_curve_structure_offsets']['arr'][i]['end'] = self._io.pos() self._debug['response_curve_structure_offsets']['end'] = self._io.pos() self._debug['response_curve_structures']['start'] = self._io.pos() self.response_curve_structures = self._io.read_bytes_full() self._debug['response_curve_structures']['end'] = self._io.pos() class CurveType(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_entries", "curve_values", "curve_value"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_entries']['start'] = self._io.pos() self.number_of_entries = self._io.read_u4be() self._debug['number_of_entries']['end'] = self._io.pos() if self.number_of_entries > 1: self._debug['curve_values']['start'] = self._io.pos() self.curve_values = [None] * (self.number_of_entries) for i in range(self.number_of_entries): if not 'arr' in self._debug['curve_values']: self._debug['curve_values']['arr'] = [] self._debug['curve_values']['arr'].append({'start': self._io.pos()}) self.curve_values[i] = self._io.read_u4be() self._debug['curve_values']['arr'][i]['end'] = self._io.pos() self._debug['curve_values']['end'] = self._io.pos() if self.number_of_entries == 1: self._debug['curve_value']['start'] = self._io.pos() self.curve_value = self._io.read_u1() self._debug['curve_value']['end'] = self._io.pos() class SaturationRenderingIntentGamutTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.signature_type: self.tag_data = self._root.TagTable.TagDefinition.SignatureType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class XyzType(KaitaiStruct): SEQ_FIELDS = ["reserved", "values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['values']['start'] = self._io.pos() self.values = [] i = 0 while not self._io.is_eof(): if not 'arr' in self._debug['values']: self._debug['values']['arr'] = [] self._debug['values']['arr'].append({'start': self._io.pos()}) _t_values = self._root.XyzNumber(self._io, self, self._root) _t_values._read() self.values.append(_t_values) self._debug['values']['arr'][len(self.values) - 1]['end'] = self._io.pos() i += 1 self._debug['values']['end'] = self._io.pos() class Lut8Type(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_input_channels", "number_of_output_channels", "number_of_clut_grid_points", "padding", "encoded_e_parameters", "number_of_input_table_entries", "number_of_output_table_entries", "input_tables", "clut_values", "output_tables"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_input_channels']['start'] = self._io.pos() self.number_of_input_channels = self._io.read_u1() self._debug['number_of_input_channels']['end'] = self._io.pos() self._debug['number_of_output_channels']['start'] = self._io.pos() self.number_of_output_channels = self._io.read_u1() self._debug['number_of_output_channels']['end'] = self._io.pos() self._debug['number_of_clut_grid_points']['start'] = self._io.pos() self.number_of_clut_grid_points = self._io.read_u1() self._debug['number_of_clut_grid_points']['end'] = self._io.pos() self._debug['padding']['start'] = self._io.pos() self.padding = self._io.ensure_fixed_contents(b"\x00") self._debug['padding']['end'] = self._io.pos() self._debug['encoded_e_parameters']['start'] = self._io.pos() self.encoded_e_parameters = [None] * (9) for i in range(9): if not 'arr' in self._debug['encoded_e_parameters']: self._debug['encoded_e_parameters']['arr'] = [] self._debug['encoded_e_parameters']['arr'].append({'start': self._io.pos()}) self.encoded_e_parameters[i] = self._io.read_s4be() self._debug['encoded_e_parameters']['arr'][i]['end'] = self._io.pos() self._debug['encoded_e_parameters']['end'] = self._io.pos() self._debug['number_of_input_table_entries']['start'] = self._io.pos() self.number_of_input_table_entries = self._io.read_u4be() self._debug['number_of_input_table_entries']['end'] = self._io.pos() self._debug['number_of_output_table_entries']['start'] = self._io.pos() self.number_of_output_table_entries = self._io.read_u4be() self._debug['number_of_output_table_entries']['end'] = self._io.pos() self._debug['input_tables']['start'] = self._io.pos() self.input_tables = self._io.read_bytes((256 * self.number_of_input_channels)) self._debug['input_tables']['end'] = self._io.pos() self._debug['clut_values']['start'] = self._io.pos() self.clut_values = self._io.read_bytes(((self.number_of_clut_grid_points ^ self.number_of_input_channels) * self.number_of_output_channels)) self._debug['clut_values']['end'] = self._io.pos() self._debug['output_tables']['start'] = self._io.pos() self.output_tables = self._io.read_bytes((256 * self.number_of_output_channels)) self._debug['output_tables']['end'] = self._io.pos() class BToA2Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_b_to_a_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutBToAType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class LutAToBType(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_input_channels", "number_of_output_channels", "padding", "offset_to_first_b_curve", "offset_to_matrix", "offset_to_first_m_curve", "offset_to_clut", "offset_to_first_a_curve", "data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_input_channels']['start'] = self._io.pos() self.number_of_input_channels = self._io.read_u1() self._debug['number_of_input_channels']['end'] = self._io.pos() self._debug['number_of_output_channels']['start'] = self._io.pos() self.number_of_output_channels = self._io.read_u1() self._debug['number_of_output_channels']['end'] = self._io.pos() self._debug['padding']['start'] = self._io.pos() self.padding = self._io.ensure_fixed_contents(b"\x00\x00") self._debug['padding']['end'] = self._io.pos() self._debug['offset_to_first_b_curve']['start'] = self._io.pos() self.offset_to_first_b_curve = self._io.read_u4be() self._debug['offset_to_first_b_curve']['end'] = self._io.pos() self._debug['offset_to_matrix']['start'] = self._io.pos() self.offset_to_matrix = self._io.read_u4be() self._debug['offset_to_matrix']['end'] = self._io.pos() self._debug['offset_to_first_m_curve']['start'] = self._io.pos() self.offset_to_first_m_curve = self._io.read_u4be() self._debug['offset_to_first_m_curve']['end'] = self._io.pos() self._debug['offset_to_clut']['start'] = self._io.pos() self.offset_to_clut = self._io.read_u4be() self._debug['offset_to_clut']['end'] = self._io.pos() self._debug['offset_to_first_a_curve']['start'] = self._io.pos() self.offset_to_first_a_curve = self._io.read_u4be() self._debug['offset_to_first_a_curve']['end'] = self._io.pos() self._debug['data']['start'] = self._io.pos() self.data = self._io.read_bytes_full() self._debug['data']['end'] = self._io.pos() class BToA0Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_b_to_a_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutBToAType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class MediaWhitePointTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.xyz_type: self.tag_data = self._root.TagTable.TagDefinition.XyzType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class Lut16Type(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_input_channels", "number_of_output_channels", "number_of_clut_grid_points", "padding", "encoded_e_parameters", "number_of_input_table_entries", "number_of_output_table_entries", "input_tables", "clut_values", "output_tables"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_input_channels']['start'] = self._io.pos() self.number_of_input_channels = self._io.read_u1() self._debug['number_of_input_channels']['end'] = self._io.pos() self._debug['number_of_output_channels']['start'] = self._io.pos() self.number_of_output_channels = self._io.read_u1() self._debug['number_of_output_channels']['end'] = self._io.pos() self._debug['number_of_clut_grid_points']['start'] = self._io.pos() self.number_of_clut_grid_points = self._io.read_u1() self._debug['number_of_clut_grid_points']['end'] = self._io.pos() self._debug['padding']['start'] = self._io.pos() self.padding = self._io.ensure_fixed_contents(b"\x00") self._debug['padding']['end'] = self._io.pos() self._debug['encoded_e_parameters']['start'] = self._io.pos() self.encoded_e_parameters = [None] * (9) for i in range(9): if not 'arr' in self._debug['encoded_e_parameters']: self._debug['encoded_e_parameters']['arr'] = [] self._debug['encoded_e_parameters']['arr'].append({'start': self._io.pos()}) self.encoded_e_parameters[i] = self._io.read_s4be() self._debug['encoded_e_parameters']['arr'][i]['end'] = self._io.pos() self._debug['encoded_e_parameters']['end'] = self._io.pos() self._debug['number_of_input_table_entries']['start'] = self._io.pos() self.number_of_input_table_entries = self._io.read_u4be() self._debug['number_of_input_table_entries']['end'] = self._io.pos() self._debug['number_of_output_table_entries']['start'] = self._io.pos() self.number_of_output_table_entries = self._io.read_u4be() self._debug['number_of_output_table_entries']['end'] = self._io.pos() self._debug['input_tables']['start'] = self._io.pos() self.input_tables = self._io.read_bytes(((2 * self.number_of_input_channels) * self.number_of_input_table_entries)) self._debug['input_tables']['end'] = self._io.pos() self._debug['clut_values']['start'] = self._io.pos() self.clut_values = self._io.read_bytes(((2 * (self.number_of_clut_grid_points ^ self.number_of_input_channels)) * self.number_of_output_channels)) self._debug['clut_values']['end'] = self._io.pos() self._debug['output_tables']['start'] = self._io.pos() self.output_tables = self._io.read_bytes(((2 * self.number_of_output_channels) * self.number_of_output_table_entries)) self._debug['output_tables']['end'] = self._io.pos() class PerceptualRenderingIntentGamutTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.signature_type: self.tag_data = self._root.TagTable.TagDefinition.SignatureType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class U16Fixed16ArrayType(KaitaiStruct): SEQ_FIELDS = ["reserved", "values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['values']['start'] = self._io.pos() self.values = [] i = 0 while not self._io.is_eof(): if not 'arr' in self._debug['values']: self._debug['values']['arr'] = [] self._debug['values']['arr'].append({'start': self._io.pos()}) _t_values = self._root.U16Fixed16Number(self._io, self, self._root) _t_values._read() self.values.append(_t_values) self._debug['values']['arr'][len(self.values) - 1]['end'] = self._io.pos() i += 1 self._debug['values']['end'] = self._io.pos() class ColorantTableOutTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.colorant_table_type: self.tag_data = self._root.TagTable.TagDefinition.ColorantTableType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class MeasurementTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.measurement_type: self.tag_data = self._root.TagTable.TagDefinition.MeasurementType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ProfileSequenceTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.profile_sequence_desc_type: self.tag_data = self._root.TagTable.TagDefinition.ProfileSequenceDescType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class TechnologyTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.signature_type: self.tag_data = self._root.TagTable.TagDefinition.SignatureType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class AToB0Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_a_to_b_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutAToBType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class DToB0Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class OutputResponseTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.response_curve_set_16_type: self.tag_data = self._root.TagTable.TagDefinition.ResponseCurveSet16Type(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class GreenMatrixColumnTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.xyz_type: self.tag_data = self._root.TagTable.TagDefinition.XyzType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ProfileDescriptionTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_localized_unicode_type: self.tag_data = self._root.TagTable.TagDefinition.MultiLocalizedUnicodeType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class Preview1Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_b_to_a_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutBToAType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class RedTrcTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.curve_type: self.tag_data = self._root.TagTable.TagDefinition.CurveType(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.parametric_curve_type: self.tag_data = self._root.TagTable.TagDefinition.ParametricCurveType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class BToD0Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class DToB1Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class BToA1Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_b_to_a_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutBToAType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ParametricCurveType(KaitaiStruct): class ParametricCurveTypeFunctions(Enum): y_equals_x_to_power_of_g = 0 cie_122_1996 = 1 iec_61966_3 = 2 iec_61966_2_1 = 3 y_equals_ob_ax_plus_b_cb_to_power_of_g_plus_c = 4 SEQ_FIELDS = ["reserved", "function_type", "reserved_2", "parameters"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['function_type']['start'] = self._io.pos() self.function_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.ParametricCurveType.ParametricCurveTypeFunctions, self._io.read_u2be()) self._debug['function_type']['end'] = self._io.pos() self._debug['reserved_2']['start'] = self._io.pos() self.reserved_2 = self._io.ensure_fixed_contents(b"\x00\x00") self._debug['reserved_2']['end'] = self._io.pos() self._debug['parameters']['start'] = self._io.pos() _on = self.function_type if _on == self._root.TagTable.TagDefinition.ParametricCurveType.ParametricCurveTypeFunctions.cie_122_1996: self.parameters = self._root.TagTable.TagDefinition.ParametricCurveType.ParamsCie1221996(self._io, self, self._root) self.parameters._read() elif _on == self._root.TagTable.TagDefinition.ParametricCurveType.ParametricCurveTypeFunctions.iec_61966_3: self.parameters = self._root.TagTable.TagDefinition.ParametricCurveType.ParamsIec619663(self._io, self, self._root) self.parameters._read() elif _on == self._root.TagTable.TagDefinition.ParametricCurveType.ParametricCurveTypeFunctions.iec_61966_2_1: self.parameters = self._root.TagTable.TagDefinition.ParametricCurveType.ParamsIec6196621(self._io, self, self._root) self.parameters._read() elif _on == self._root.TagTable.TagDefinition.ParametricCurveType.ParametricCurveTypeFunctions.y_equals_ob_ax_plus_b_cb_to_power_of_g_plus_c: self.parameters = self._root.TagTable.TagDefinition.ParametricCurveType.ParamsYEqualsObAxPlusBCbToPowerOfGPlusC(self._io, self, self._root) self.parameters._read() elif _on == self._root.TagTable.TagDefinition.ParametricCurveType.ParametricCurveTypeFunctions.y_equals_x_to_power_of_g: self.parameters = self._root.TagTable.TagDefinition.ParametricCurveType.ParamsYEqualsXToPowerOfG(self._io, self, self._root) self.parameters._read() self._debug['parameters']['end'] = self._io.pos() class ParamsIec619663(KaitaiStruct): SEQ_FIELDS = ["g", "a", "b", "c"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['g']['start'] = self._io.pos() self.g = self._io.read_s4be() self._debug['g']['end'] = self._io.pos() self._debug['a']['start'] = self._io.pos() self.a = self._io.read_s4be() self._debug['a']['end'] = self._io.pos() self._debug['b']['start'] = self._io.pos() self.b = self._io.read_s4be() self._debug['b']['end'] = self._io.pos() self._debug['c']['start'] = self._io.pos() self.c = self._io.read_s4be() self._debug['c']['end'] = self._io.pos() class ParamsIec6196621(KaitaiStruct): SEQ_FIELDS = ["g", "a", "b", "c", "d"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['g']['start'] = self._io.pos() self.g = self._io.read_s4be() self._debug['g']['end'] = self._io.pos() self._debug['a']['start'] = self._io.pos() self.a = self._io.read_s4be() self._debug['a']['end'] = self._io.pos() self._debug['b']['start'] = self._io.pos() self.b = self._io.read_s4be() self._debug['b']['end'] = self._io.pos() self._debug['c']['start'] = self._io.pos() self.c = self._io.read_s4be() self._debug['c']['end'] = self._io.pos() self._debug['d']['start'] = self._io.pos() self.d = self._io.read_s4be() self._debug['d']['end'] = self._io.pos() class ParamsYEqualsXToPowerOfG(KaitaiStruct): SEQ_FIELDS = ["g"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['g']['start'] = self._io.pos() self.g = self._io.read_s4be() self._debug['g']['end'] = self._io.pos() class ParamsYEqualsObAxPlusBCbToPowerOfGPlusC(KaitaiStruct): SEQ_FIELDS = ["g", "a", "b", "c", "d", "e", "f"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['g']['start'] = self._io.pos() self.g = self._io.read_s4be() self._debug['g']['end'] = self._io.pos() self._debug['a']['start'] = self._io.pos() self.a = self._io.read_s4be() self._debug['a']['end'] = self._io.pos() self._debug['b']['start'] = self._io.pos() self.b = self._io.read_s4be() self._debug['b']['end'] = self._io.pos() self._debug['c']['start'] = self._io.pos() self.c = self._io.read_s4be() self._debug['c']['end'] = self._io.pos() self._debug['d']['start'] = self._io.pos() self.d = self._io.read_s4be() self._debug['d']['end'] = self._io.pos() self._debug['e']['start'] = self._io.pos() self.e = self._io.read_s4be() self._debug['e']['end'] = self._io.pos() self._debug['f']['start'] = self._io.pos() self.f = self._io.read_s4be() self._debug['f']['end'] = self._io.pos() class ParamsCie1221996(KaitaiStruct): SEQ_FIELDS = ["g", "a", "b"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['g']['start'] = self._io.pos() self.g = self._io.read_s4be() self._debug['g']['end'] = self._io.pos() self._debug['a']['start'] = self._io.pos() self.a = self._io.read_s4be() self._debug['a']['end'] = self._io.pos() self._debug['b']['start'] = self._io.pos() self.b = self._io.read_s4be() self._debug['b']['end'] = self._io.pos() class ChromaticityTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.chromaticity_type: self.tag_data = self._root.TagTable.TagDefinition.ChromaticityType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ChromaticAdaptationTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.s_15_fixed_16_array_type: self.tag_data = self._root.TagTable.TagDefinition.S15Fixed16ArrayType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class MeasurementType(KaitaiStruct): class StandardObserverEncodings(Enum): unknown = 0 cie_1931_standard_colorimetric_observer = 1 cie_1964_standard_colorimetric_observer = 2 class MeasurementGeometryEncodings(Enum): unknown = 0 zero_degrees_to_45_degrees_or_45_degrees_to_zero_degrees = 1 zero_degrees_to_d_degrees_or_d_degrees_to_zero_degrees = 2 class MeasurementFlareEncodings(Enum): zero_percent = 0 one_hundred_percent = 65536 SEQ_FIELDS = ["reserved", "standard_observer_encoding", "nciexyz_tristimulus_values_for_measurement_backing", "measurement_geometry_encoding", "measurement_flare_encoding", "standard_illuminant_encoding"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['standard_observer_encoding']['start'] = self._io.pos() self.standard_observer_encoding = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.MeasurementType.StandardObserverEncodings, self._io.read_u4be()) self._debug['standard_observer_encoding']['end'] = self._io.pos() self._debug['nciexyz_tristimulus_values_for_measurement_backing']['start'] = self._io.pos() self.nciexyz_tristimulus_values_for_measurement_backing = self._root.XyzNumber(self._io, self, self._root) self.nciexyz_tristimulus_values_for_measurement_backing._read() self._debug['nciexyz_tristimulus_values_for_measurement_backing']['end'] = self._io.pos() self._debug['measurement_geometry_encoding']['start'] = self._io.pos() self.measurement_geometry_encoding = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.MeasurementType.MeasurementGeometryEncodings, self._io.read_u4be()) self._debug['measurement_geometry_encoding']['end'] = self._io.pos() self._debug['measurement_flare_encoding']['start'] = self._io.pos() self.measurement_flare_encoding = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.MeasurementType.MeasurementFlareEncodings, self._io.read_u4be()) self._debug['measurement_flare_encoding']['end'] = self._io.pos() self._debug['standard_illuminant_encoding']['start'] = self._io.pos() self.standard_illuminant_encoding = self._root.StandardIlluminantEncoding(self._io, self, self._root) self.standard_illuminant_encoding._read() self._debug['standard_illuminant_encoding']['end'] = self._io.pos() class TextType(KaitaiStruct): SEQ_FIELDS = ["reserved", "value"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['value']['start'] = self._io.pos() self.value = (KaitaiStream.bytes_terminate(self._io.read_bytes_full(), 0, False)).decode(u"ASCII") self._debug['value']['end'] = self._io.pos() class ProfileSequenceIdentifierType(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_structures", "positions_table", "profile_identifiers"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_structures']['start'] = self._io.pos() self.number_of_structures = self._io.read_u4be() self._debug['number_of_structures']['end'] = self._io.pos() self._debug['positions_table']['start'] = self._io.pos() self.positions_table = [None] * (self.number_of_structures) for i in range(self.number_of_structures): if not 'arr' in self._debug['positions_table']: self._debug['positions_table']['arr'] = [] self._debug['positions_table']['arr'].append({'start': self._io.pos()}) _t_positions_table = self._root.PositionNumber(self._io, self, self._root) _t_positions_table._read() self.positions_table[i] = _t_positions_table self._debug['positions_table']['arr'][i]['end'] = self._io.pos() self._debug['positions_table']['end'] = self._io.pos() self._debug['profile_identifiers']['start'] = self._io.pos() self.profile_identifiers = [None] * (self.number_of_structures) for i in range(self.number_of_structures): if not 'arr' in self._debug['profile_identifiers']: self._debug['profile_identifiers']['arr'] = [] self._debug['profile_identifiers']['arr'].append({'start': self._io.pos()}) _t_profile_identifiers = self._root.TagTable.TagDefinition.ProfileSequenceIdentifierType.ProfileIdentifier(self._io, self, self._root) _t_profile_identifiers._read() self.profile_identifiers[i] = _t_profile_identifiers self._debug['profile_identifiers']['arr'][i]['end'] = self._io.pos() self._debug['profile_identifiers']['end'] = self._io.pos() class ProfileIdentifier(KaitaiStruct): SEQ_FIELDS = ["profile_id", "profile_description"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['profile_id']['start'] = self._io.pos() self.profile_id = self._io.read_bytes(16) self._debug['profile_id']['end'] = self._io.pos() self._debug['profile_description']['start'] = self._io.pos() self.profile_description = self._root.TagTable.TagDefinition.MultiLocalizedUnicodeType(self._io, self, self._root) self.profile_description._read() self._debug['profile_description']['end'] = self._io.pos() class ColorantTableType(KaitaiStruct): SEQ_FIELDS = ["reserved", "count_of_colorants", "colorants"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['count_of_colorants']['start'] = self._io.pos() self.count_of_colorants = self._io.read_u4be() self._debug['count_of_colorants']['end'] = self._io.pos() self._debug['colorants']['start'] = self._io.pos() self.colorants = [None] * (self.count_of_colorants) for i in range(self.count_of_colorants): if not 'arr' in self._debug['colorants']: self._debug['colorants']['arr'] = [] self._debug['colorants']['arr'].append({'start': self._io.pos()}) _t_colorants = self._root.TagTable.TagDefinition.ColorantTableType.Colorant(self._io, self, self._root) _t_colorants._read() self.colorants[i] = _t_colorants self._debug['colorants']['arr'][i]['end'] = self._io.pos() self._debug['colorants']['end'] = self._io.pos() class Colorant(KaitaiStruct): SEQ_FIELDS = ["name", "padding", "pcs_values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['name']['start'] = self._io.pos() self.name = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII") self._debug['name']['end'] = self._io.pos() self._debug['padding']['start'] = self._io.pos() self.padding = [None] * ((32 - len(self.name))) for i in range((32 - len(self.name))): if not 'arr' in self._debug['padding']: self._debug['padding']['arr'] = [] self._debug['padding']['arr'].append({'start': self._io.pos()}) self.padding = self._io.ensure_fixed_contents(b"\x00") self._debug['padding']['arr'][i]['end'] = self._io.pos() self._debug['padding']['end'] = self._io.pos() self._debug['pcs_values']['start'] = self._io.pos() self.pcs_values = self._io.read_bytes(6) self._debug['pcs_values']['end'] = self._io.pos() class SignatureType(KaitaiStruct): SEQ_FIELDS = ["reserved", "signature"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['signature']['start'] = self._io.pos() self.signature = (self._io.read_bytes(4)).decode(u"ASCII") self._debug['signature']['end'] = self._io.pos() class CopyrightTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_localized_unicode_type: self.tag_data = self._root.TagTable.TagDefinition.MultiLocalizedUnicodeType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class Preview0Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_a_to_b_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutAToBType(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_b_to_a_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutBToAType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class DateTimeType(KaitaiStruct): SEQ_FIELDS = ["reserved", "date_and_time"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['date_and_time']['start'] = self._io.pos() self.date_and_time = self._root.DateTimeNumber(self._io, self, self._root) self.date_and_time._read() self._debug['date_and_time']['end'] = self._io.pos() class DToB3Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class Preview2Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_b_to_a_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutBToAType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class DeviceModelDescTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_localized_unicode_type: self.tag_data = self._root.TagTable.TagDefinition.MultiLocalizedUnicodeType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class MultiProcessElementsType(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_input_channels", "number_of_output_channels", "number_of_processing_elements", "process_element_positions_table", "data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_input_channels']['start'] = self._io.pos() self.number_of_input_channels = self._io.read_u2be() self._debug['number_of_input_channels']['end'] = self._io.pos() self._debug['number_of_output_channels']['start'] = self._io.pos() self.number_of_output_channels = self._io.read_u2be() self._debug['number_of_output_channels']['end'] = self._io.pos() self._debug['number_of_processing_elements']['start'] = self._io.pos() self.number_of_processing_elements = self._io.read_u4be() self._debug['number_of_processing_elements']['end'] = self._io.pos() self._debug['process_element_positions_table']['start'] = self._io.pos() self.process_element_positions_table = [None] * (self.number_of_processing_elements) for i in range(self.number_of_processing_elements): if not 'arr' in self._debug['process_element_positions_table']: self._debug['process_element_positions_table']['arr'] = [] self._debug['process_element_positions_table']['arr'].append({'start': self._io.pos()}) _t_process_element_positions_table = self._root.PositionNumber(self._io, self, self._root) _t_process_element_positions_table._read() self.process_element_positions_table[i] = _t_process_element_positions_table self._debug['process_element_positions_table']['arr'][i]['end'] = self._io.pos() self._debug['process_element_positions_table']['end'] = self._io.pos() self._debug['data']['start'] = self._io.pos() self.data = self._io.read_bytes_full() self._debug['data']['end'] = self._io.pos() class UInt16ArrayType(KaitaiStruct): SEQ_FIELDS = ["reserved", "values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['values']['start'] = self._io.pos() self.values = [] i = 0 while not self._io.is_eof(): if not 'arr' in self._debug['values']: self._debug['values']['arr'] = [] self._debug['values']['arr'].append({'start': self._io.pos()}) self.values.append(self._io.read_u2be()) self._debug['values']['arr'][len(self.values) - 1]['end'] = self._io.pos() i += 1 self._debug['values']['end'] = self._io.pos() class ColorantOrderTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.colorant_order_type: self.tag_data = self._root.TagTable.TagDefinition.ColorantOrderType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class DataType(KaitaiStruct): class DataTypes(Enum): ascii_data = 0 binary_data = 1 SEQ_FIELDS = ["data_flag"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['data_flag']['start'] = self._io.pos() self.data_flag = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.DataType.DataTypes, self._io.read_u4be()) self._debug['data_flag']['end'] = self._io.pos() class ChromaticityType(KaitaiStruct): class ColorantAndPhosphorEncodings(Enum): unknown = 0 itu_r_bt_709_2 = 1 smpte_rp145 = 2 ebu_tech_3213_e = 3 p22 = 4 SEQ_FIELDS = ["reserved", "number_of_device_channels", "colorant_and_phosphor_encoding", "ciexy_coordinates_per_channel"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_device_channels']['start'] = self._io.pos() self.number_of_device_channels = self._io.read_u2be() self._debug['number_of_device_channels']['end'] = self._io.pos() self._debug['colorant_and_phosphor_encoding']['start'] = self._io.pos() self.colorant_and_phosphor_encoding = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.ChromaticityType.ColorantAndPhosphorEncodings, self._io.read_u2be()) self._debug['colorant_and_phosphor_encoding']['end'] = self._io.pos() self._debug['ciexy_coordinates_per_channel']['start'] = self._io.pos() self.ciexy_coordinates_per_channel = [None] * (self.number_of_device_channels) for i in range(self.number_of_device_channels): if not 'arr' in self._debug['ciexy_coordinates_per_channel']: self._debug['ciexy_coordinates_per_channel']['arr'] = [] self._debug['ciexy_coordinates_per_channel']['arr'].append({'start': self._io.pos()}) _t_ciexy_coordinates_per_channel = self._root.TagTable.TagDefinition.ChromaticityType.CiexyCoordinateValues(self._io, self, self._root) _t_ciexy_coordinates_per_channel._read() self.ciexy_coordinates_per_channel[i] = _t_ciexy_coordinates_per_channel self._debug['ciexy_coordinates_per_channel']['arr'][i]['end'] = self._io.pos() self._debug['ciexy_coordinates_per_channel']['end'] = self._io.pos() class CiexyCoordinateValues(KaitaiStruct): SEQ_FIELDS = ["x_coordinate", "y_coordinate"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['x_coordinate']['start'] = self._io.pos() self.x_coordinate = self._io.read_u2be() self._debug['x_coordinate']['end'] = self._io.pos() self._debug['y_coordinate']['start'] = self._io.pos() self.y_coordinate = self._io.read_u2be() self._debug['y_coordinate']['end'] = self._io.pos() class LuminanceTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.xyz_type: self.tag_data = self._root.TagTable.TagDefinition.XyzType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class S15Fixed16ArrayType(KaitaiStruct): SEQ_FIELDS = ["reserved", "values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['values']['start'] = self._io.pos() self.values = [] i = 0 while not self._io.is_eof(): if not 'arr' in self._debug['values']: self._debug['values']['arr'] = [] self._debug['values']['arr'].append({'start': self._io.pos()}) _t_values = self._root.S15Fixed16Number(self._io, self, self._root) _t_values._read() self.values.append(_t_values) self._debug['values']['arr'][len(self.values) - 1]['end'] = self._io.pos() i += 1 self._debug['values']['end'] = self._io.pos() class MultiLocalizedUnicodeType(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_records", "record_size", "records"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_records']['start'] = self._io.pos() self.number_of_records = self._io.read_u4be() self._debug['number_of_records']['end'] = self._io.pos() self._debug['record_size']['start'] = self._io.pos() self.record_size = self._io.read_u4be() self._debug['record_size']['end'] = self._io.pos() self._debug['records']['start'] = self._io.pos() self.records = [None] * (self.number_of_records) for i in range(self.number_of_records): if not 'arr' in self._debug['records']: self._debug['records']['arr'] = [] self._debug['records']['arr'].append({'start': self._io.pos()}) _t_records = self._root.TagTable.TagDefinition.MultiLocalizedUnicodeType.Record(self._io, self, self._root) _t_records._read() self.records[i] = _t_records self._debug['records']['arr'][i]['end'] = self._io.pos() self._debug['records']['end'] = self._io.pos() class Record(KaitaiStruct): SEQ_FIELDS = ["language_code", "country_code", "string_length", "string_offset"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['language_code']['start'] = self._io.pos() self.language_code = self._io.read_u2be() self._debug['language_code']['end'] = self._io.pos() self._debug['country_code']['start'] = self._io.pos() self.country_code = self._io.read_u2be() self._debug['country_code']['end'] = self._io.pos() self._debug['string_length']['start'] = self._io.pos() self.string_length = self._io.read_u4be() self._debug['string_length']['end'] = self._io.pos() self._debug['string_offset']['start'] = self._io.pos() self.string_offset = self._io.read_u4be() self._debug['string_offset']['end'] = self._io.pos() @property def string_data(self): if hasattr(self, '_m_string_data'): return self._m_string_data if hasattr(self, '_m_string_data') else None _pos = self._io.pos() self._io.seek(self.string_offset) self._debug['_m_string_data']['start'] = self._io.pos() self._m_string_data = (self._io.read_bytes(self.string_length)).decode(u"UTF-16BE") self._debug['_m_string_data']['end'] = self._io.pos() self._io.seek(_pos) return self._m_string_data if hasattr(self, '_m_string_data') else None class AToB2Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_a_to_b_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutAToBType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class AToB1Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_a_to_b_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutAToBType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ColorimetricIntentImageStateTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.signature_type: self.tag_data = self._root.TagTable.TagDefinition.SignatureType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class CharTargetTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.text_type: self.tag_data = self._root.TagTable.TagDefinition.TextType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ColorantTableTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.colorant_table_type: self.tag_data = self._root.TagTable.TagDefinition.ColorantTableType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class CalibrationDateTimeTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.date_time_type: self.tag_data = self._root.TagTable.TagDefinition.DateTimeType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class NamedColor2Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.named_color_2_type: self.tag_data = self._root.TagTable.TagDefinition.NamedColor2Type(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ViewingCondDescTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_localized_unicode_type: self.tag_data = self._root.TagTable.TagDefinition.MultiLocalizedUnicodeType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class BToD3Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ProfileSequenceDescType(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_description_structures", "profile_descriptions"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_description_structures']['start'] = self._io.pos() self.number_of_description_structures = self._io.read_u4be() self._debug['number_of_description_structures']['end'] = self._io.pos() self._debug['profile_descriptions']['start'] = self._io.pos() self.profile_descriptions = [None] * (self.number_of_description_structures) for i in range(self.number_of_description_structures): if not 'arr' in self._debug['profile_descriptions']: self._debug['profile_descriptions']['arr'] = [] self._debug['profile_descriptions']['arr'].append({'start': self._io.pos()}) _t_profile_descriptions = self._root.TagTable.TagDefinition.ProfileSequenceDescType.ProfileDescription(self._io, self, self._root) _t_profile_descriptions._read() self.profile_descriptions[i] = _t_profile_descriptions self._debug['profile_descriptions']['arr'][i]['end'] = self._io.pos() self._debug['profile_descriptions']['end'] = self._io.pos() class ProfileDescription(KaitaiStruct): SEQ_FIELDS = ["device_manufacturer", "device_model", "device_attributes", "device_technology", "description_of_device_manufacturer", "description_of_device_model"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['device_manufacturer']['start'] = self._io.pos() self.device_manufacturer = self._root.DeviceManufacturer(self._io, self, self._root) self.device_manufacturer._read() self._debug['device_manufacturer']['end'] = self._io.pos() self._debug['device_model']['start'] = self._io.pos() self.device_model = (self._io.read_bytes(4)).decode(u"ASCII") self._debug['device_model']['end'] = self._io.pos() self._debug['device_attributes']['start'] = self._io.pos() self.device_attributes = self._root.DeviceAttributes(self._io, self, self._root) self.device_attributes._read() self._debug['device_attributes']['end'] = self._io.pos() self._debug['device_technology']['start'] = self._io.pos() self.device_technology = self._root.TagTable.TagDefinition.TechnologyTag(self._io, self, self._root) self.device_technology._read() self._debug['device_technology']['end'] = self._io.pos() self._debug['description_of_device_manufacturer']['start'] = self._io.pos() self.description_of_device_manufacturer = self._root.TagTable.TagDefinition.DeviceMfgDescTag(self._io, self, self._root) self.description_of_device_manufacturer._read() self._debug['description_of_device_manufacturer']['end'] = self._io.pos() self._debug['description_of_device_model']['start'] = self._io.pos() self.description_of_device_model = self._root.TagTable.TagDefinition.DeviceModelDescTag(self._io, self, self._root) self.description_of_device_model._read() self._debug['description_of_device_model']['end'] = self._io.pos() class ProfileSequenceIdentifierTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.profile_sequence_identifier_type: self.tag_data = self._root.TagTable.TagDefinition.ProfileSequenceIdentifierType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class BToD1Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ColorantOrderType(KaitaiStruct): SEQ_FIELDS = ["reserved", "count_of_colorants", "numbers_of_colorants_in_order_of_printing"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['count_of_colorants']['start'] = self._io.pos() self.count_of_colorants = self._io.read_u4be() self._debug['count_of_colorants']['end'] = self._io.pos() self._debug['numbers_of_colorants_in_order_of_printing']['start'] = self._io.pos() self.numbers_of_colorants_in_order_of_printing = [None] * (self.count_of_colorants) for i in range(self.count_of_colorants): if not 'arr' in self._debug['numbers_of_colorants_in_order_of_printing']: self._debug['numbers_of_colorants_in_order_of_printing']['arr'] = [] self._debug['numbers_of_colorants_in_order_of_printing']['arr'].append({'start': self._io.pos()}) self.numbers_of_colorants_in_order_of_printing[i] = self._io.read_u1() self._debug['numbers_of_colorants_in_order_of_printing']['arr'][i]['end'] = self._io.pos() self._debug['numbers_of_colorants_in_order_of_printing']['end'] = self._io.pos() class DToB2Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class GrayTrcTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.curve_type: self.tag_data = self._root.TagTable.TagDefinition.CurveType(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.parametric_curve_type: self.tag_data = self._root.TagTable.TagDefinition.ParametricCurveType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class ViewingConditionsType(KaitaiStruct): SEQ_FIELDS = ["reserved", "un_normalized_ciexyz_values_for_illuminant", "un_normalized_ciexyz_values_for_surround", "illuminant_type"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['un_normalized_ciexyz_values_for_illuminant']['start'] = self._io.pos() self.un_normalized_ciexyz_values_for_illuminant = self._root.XyzNumber(self._io, self, self._root) self.un_normalized_ciexyz_values_for_illuminant._read() self._debug['un_normalized_ciexyz_values_for_illuminant']['end'] = self._io.pos() self._debug['un_normalized_ciexyz_values_for_surround']['start'] = self._io.pos() self.un_normalized_ciexyz_values_for_surround = self._root.XyzNumber(self._io, self, self._root) self.un_normalized_ciexyz_values_for_surround._read() self._debug['un_normalized_ciexyz_values_for_surround']['end'] = self._io.pos() self._debug['illuminant_type']['start'] = self._io.pos() self.illuminant_type = self._root.StandardIlluminantEncoding(self._io, self, self._root) self.illuminant_type._read() self._debug['illuminant_type']['end'] = self._io.pos() class LutBToAType(KaitaiStruct): SEQ_FIELDS = ["reserved", "number_of_input_channels", "number_of_output_channels", "padding", "offset_to_first_b_curve", "offset_to_matrix", "offset_to_first_m_curve", "offset_to_clut", "offset_to_first_a_curve", "data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['number_of_input_channels']['start'] = self._io.pos() self.number_of_input_channels = self._io.read_u1() self._debug['number_of_input_channels']['end'] = self._io.pos() self._debug['number_of_output_channels']['start'] = self._io.pos() self.number_of_output_channels = self._io.read_u1() self._debug['number_of_output_channels']['end'] = self._io.pos() self._debug['padding']['start'] = self._io.pos() self.padding = self._io.ensure_fixed_contents(b"\x00\x00") self._debug['padding']['end'] = self._io.pos() self._debug['offset_to_first_b_curve']['start'] = self._io.pos() self.offset_to_first_b_curve = self._io.read_u4be() self._debug['offset_to_first_b_curve']['end'] = self._io.pos() self._debug['offset_to_matrix']['start'] = self._io.pos() self.offset_to_matrix = self._io.read_u4be() self._debug['offset_to_matrix']['end'] = self._io.pos() self._debug['offset_to_first_m_curve']['start'] = self._io.pos() self.offset_to_first_m_curve = self._io.read_u4be() self._debug['offset_to_first_m_curve']['end'] = self._io.pos() self._debug['offset_to_clut']['start'] = self._io.pos() self.offset_to_clut = self._io.read_u4be() self._debug['offset_to_clut']['end'] = self._io.pos() self._debug['offset_to_first_a_curve']['start'] = self._io.pos() self.offset_to_first_a_curve = self._io.read_u4be() self._debug['offset_to_first_a_curve']['end'] = self._io.pos() self._debug['data']['start'] = self._io.pos() self.data = self._io.read_bytes_full() self._debug['data']['end'] = self._io.pos() class GreenTrcTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.curve_type: self.tag_data = self._root.TagTable.TagDefinition.CurveType(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.parametric_curve_type: self.tag_data = self._root.TagTable.TagDefinition.ParametricCurveType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class UInt32ArrayType(KaitaiStruct): SEQ_FIELDS = ["reserved", "values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['values']['start'] = self._io.pos() self.values = [] i = 0 while not self._io.is_eof(): if not 'arr' in self._debug['values']: self._debug['values']['arr'] = [] self._debug['values']['arr'].append({'start': self._io.pos()}) self.values.append(self._io.read_u4be()) self._debug['values']['arr'][len(self.values) - 1]['end'] = self._io.pos() i += 1 self._debug['values']['end'] = self._io.pos() class GamutTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_one_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut8Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_table_with_two_byte_precision_type: self.tag_data = self._root.TagTable.TagDefinition.Lut16Type(self._io, self, self._root) self.tag_data._read() elif _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_function_b_to_a_table_type: self.tag_data = self._root.TagTable.TagDefinition.LutBToAType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class UInt8ArrayType(KaitaiStruct): SEQ_FIELDS = ["reserved", "values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['values']['start'] = self._io.pos() self.values = [] i = 0 while not self._io.is_eof(): if not 'arr' in self._debug['values']: self._debug['values']['arr'] = [] self._debug['values']['arr'].append({'start': self._io.pos()}) self.values.append(self._io.read_u1()) self._debug['values']['arr'][len(self.values) - 1]['end'] = self._io.pos() i += 1 self._debug['values']['end'] = self._io.pos() class RedMatrixColumnTag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.xyz_type: self.tag_data = self._root.TagTable.TagDefinition.XyzType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() class UInt64ArrayType(KaitaiStruct): SEQ_FIELDS = ["reserved", "values"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.ensure_fixed_contents(b"\x00\x00\x00\x00") self._debug['reserved']['end'] = self._io.pos() self._debug['values']['start'] = self._io.pos() self.values = [] i = 0 while not self._io.is_eof(): if not 'arr' in self._debug['values']: self._debug['values']['arr'] = [] self._debug['values']['arr'].append({'start': self._io.pos()}) self.values.append(self._io.read_u8be()) self._debug['values']['arr'][len(self.values) - 1]['end'] = self._io.pos() i += 1 self._debug['values']['end'] = self._io.pos() class BToD2Tag(KaitaiStruct): SEQ_FIELDS = ["tag_type", "tag_data"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['tag_type']['start'] = self._io.pos() self.tag_type = KaitaiStream.resolve_enum(self._root.TagTable.TagDefinition.TagTypeSignatures, self._io.read_u4be()) self._debug['tag_type']['end'] = self._io.pos() self._debug['tag_data']['start'] = self._io.pos() _on = self.tag_type if _on == self._root.TagTable.TagDefinition.TagTypeSignatures.multi_process_elements_type: self.tag_data = self._root.TagTable.TagDefinition.MultiProcessElementsType(self._io, self, self._root) self.tag_data._read() self._debug['tag_data']['end'] = self._io.pos() @property def tag_data_element(self): if hasattr(self, '_m_tag_data_element'): return self._m_tag_data_element if hasattr(self, '_m_tag_data_element') else None _pos = self._io.pos() self._io.seek(self.offset_to_data_element) self._debug['_m_tag_data_element']['start'] = self._io.pos() _on = self.tag_signature if _on == self._root.TagTable.TagDefinition.TagSignatures.colorant_order: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ColorantOrderTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.b_to_a_2: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BToA2Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.media_white_point: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.MediaWhitePointTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.b_to_d_3: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BToD3Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.colorimetric_intent_image_state: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ColorimetricIntentImageStateTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.viewing_cond_desc: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ViewingCondDescTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.preview_1: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.Preview1Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.device_model_desc: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.DeviceModelDescTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.chromaticity: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ChromaticityTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.preview_0: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.Preview0Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.d_to_b_1: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.DToB1Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.saturation_rendering_intent_gamut: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.SaturationRenderingIntentGamutTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.b_to_a_0: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BToA0Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.green_matrix_column: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.GreenMatrixColumnTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.copyright: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.CopyrightTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.blue_matrix_column: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BlueMatrixColumnTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.chromatic_adaptation: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ChromaticAdaptationTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.a_to_b_1: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.AToB1Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.output_response: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.OutputResponseTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.profile_sequence: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ProfileSequenceTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.char_target: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.CharTargetTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.red_trc: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.RedTrcTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.gamut: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.GamutTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.device_mfg_desc: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.DeviceMfgDescTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.measurement: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.MeasurementTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.green_trc: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.GreenTrcTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.d_to_b_3: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.DToB3Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.colorant_table: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ColorantTableTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.d_to_b_2: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.DToB2Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.profile_description: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ProfileDescriptionTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.profile_sequence_identifier: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ProfileSequenceIdentifierTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.gray_trc: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.GrayTrcTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.perceptual_rendering_intent_gamut: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.PerceptualRenderingIntentGamutTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.blue_trc: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BlueTrcTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.d_to_b_0: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.DToB0Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.a_to_b_2: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.AToB2Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.calibration_date_time: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.CalibrationDateTimeTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.colorant_table_out: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ColorantTableOutTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.red_matrix_column: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.RedMatrixColumnTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.preview_2: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.Preview2Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.a_to_b_0: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.AToB0Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.luminance: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.LuminanceTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.named_color_2: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.NamedColor2Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.b_to_d_2: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BToD2Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.b_to_d_0: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BToD0Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.b_to_a_1: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BToA1Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.b_to_d_1: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.BToD1Tag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.viewing_conditions: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.ViewingConditionsTag(io, self, self._root) self._m_tag_data_element._read() elif _on == self._root.TagTable.TagDefinition.TagSignatures.technology: self._raw__m_tag_data_element = self._io.read_bytes(self.size_of_data_element) io = KaitaiStream(BytesIO(self._raw__m_tag_data_element)) self._m_tag_data_element = self._root.TagTable.TagDefinition.TechnologyTag(io, self, self._root) self._m_tag_data_element._read() else: self._m_tag_data_element = self._io.read_bytes(self.size_of_data_element) self._debug['_m_tag_data_element']['end'] = self._io.pos() self._io.seek(_pos) return self._m_tag_data_element if hasattr(self, '_m_tag_data_element') else None class DeviceAttributes(KaitaiStruct): class DeviceAttributesReflectiveOrTransparency(Enum): reflective = 0 transparency = 1 class DeviceAttributesGlossyOrMatte(Enum): glossy = 0 matte = 1 class DeviceAttributesPositiveOrNegativeMediaPolarity(Enum): positive_media_polarity = 0 negative_media_polarity = 1 class DeviceAttributesColourOrBlackAndWhiteMedia(Enum): colour_media = 0 black_and_white_media = 1 SEQ_FIELDS = ["reflective_or_transparency", "glossy_or_matte", "positive_or_negative_media_polarity", "colour_or_black_and_white_media", "reserved", "vendor_specific"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['reflective_or_transparency']['start'] = self._io.pos() self.reflective_or_transparency = KaitaiStream.resolve_enum(self._root.DeviceAttributes.DeviceAttributesReflectiveOrTransparency, self._io.read_bits_int(1)) self._debug['reflective_or_transparency']['end'] = self._io.pos() self._debug['glossy_or_matte']['start'] = self._io.pos() self.glossy_or_matte = KaitaiStream.resolve_enum(self._root.DeviceAttributes.DeviceAttributesGlossyOrMatte, self._io.read_bits_int(1)) self._debug['glossy_or_matte']['end'] = self._io.pos() self._debug['positive_or_negative_media_polarity']['start'] = self._io.pos() self.positive_or_negative_media_polarity = KaitaiStream.resolve_enum(self._root.DeviceAttributes.DeviceAttributesPositiveOrNegativeMediaPolarity, self._io.read_bits_int(1)) self._debug['positive_or_negative_media_polarity']['end'] = self._io.pos() self._debug['colour_or_black_and_white_media']['start'] = self._io.pos() self.colour_or_black_and_white_media = KaitaiStream.resolve_enum(self._root.DeviceAttributes.DeviceAttributesColourOrBlackAndWhiteMedia, self._io.read_bits_int(1)) self._debug['colour_or_black_and_white_media']['end'] = self._io.pos() self._debug['reserved']['start'] = self._io.pos() self.reserved = self._io.read_bits_int(28) self._debug['reserved']['end'] = self._io.pos() self._debug['vendor_specific']['start'] = self._io.pos() self.vendor_specific = self._io.read_bits_int(32) self._debug['vendor_specific']['end'] = self._io.pos() class DeviceManufacturer(KaitaiStruct): class DeviceManufacturers(Enum): erdt_systems_gmbh_and_co_kg = 878981744 aamazing_technologies_inc = 1094798657 acer_peripherals = 1094927698 acolyte_color_research = 1094929492 actix_sytems_inc = 1094931529 adara_technology_inc = 1094992210 adobe_systems_incorporated = 1094992453 adi_systems_inc = 1094994208 agfa_graphics_nv = 1095190081 alps_electric_usa_inc = 1095519556 alps_electric_usa_inc_2 = 1095520339 alwan_color_expertise = 1095522126 amiable_technologies_inc = 1095586889 aoc_international_usa_ltd = 1095713568 apago = 1095778631 apple_computer_inc = 1095782476 ast = 1095980064 atandt_computer_systems = 1096033876 barbieri_electronic = 1111573836 barco_nv = 1112687439 breakpoint_pty_limited = 1112689488 brother_industries_ltd = 1112690516 bull = 1112886348 bus_computer_systems = 1112888096 c_itoh = 1127041364 intel_corporation = 1128353106 canon_inc_canon_development_americas_inc = 1128353359 carroll_touch = 1128354386 casio_computer_co_ltd = 1128354633 colorbus_pl = 1128420691 crossfield = 1128614944 crossfield_2 = 1128615032 cgs_publishing_technologies_international_gmbh = 1128747808 rochester_robotics = 1128811808 colour_imaging_group_london = 1128875852 citizen = 1128879177 candela_ltd = 1129066544 color_iq = 1129072977 chromaco_inc = 1129136975 chromix = 1129146712 colorgraphic_communications_corporation = 1129270351 compaq_computer_corporation = 1129270608 compeq_usa_focus_technology = 1129270640 conrac_display_products = 1129270866 cordata_technologies_inc = 1129271876 compaq_computer_corporation_2 = 1129337120 colorpro = 1129337423 cornerstone = 1129467424 ctx_international_inc = 1129601056 colorvision = 1129728339 fujitsu_laboratories_ltd = 1129792288 darius_technology_ltd = 1145131593 dataproducts = 1145132097 dry_creek_photo = 1145262112 digital_contents_resource_center_chung_ang_university = 1145262659 dell_computer_corporation = 1145392204 dainippon_ink_and_chemicals = 1145652000 diconix = 1145652047 digital = 1145653065 digital_light_and_color = 1145841219 doppelganger_llc = 1146113095 dainippon_screen = 1146298400 doosol = 1146310476 dupont = 1146441806 epson = 1162892111 esko_graphics = 1163086671 electronics_and_telecommunications_research_institute = 1163153993 everex_systems_inc = 1163281746 exactcode_gmbh = 1163411779 eizo_nanao_corporation = 1164540527 falco_data_products_inc = 1178684483 fuji_photo_film_coltd = 1179000864 fujifilm_electronic_imaging_ltd = 1179010377 fnord_software = 1179537988 fora_inc = 1179603521 forefront_technology_corporation = 1179603525 fujitsu = 1179658794 waytech_development_inc = 1179664672 fujitsu_2 = 1179994697 fuji_xerox_co_ltd = 1180180512 gcc_technologies_inc = 1195590432 global_graphics_software_limited = 1195856716 gretagmacbeth = 1196245536 gmg_gmbh_and_co_kg = 1196246816 goldstar_technology_inc = 1196379204 giantprint_pty_ltd = 1196446292 gretagmacbeth_2 = 1196707138 waytech_development_inc_2 = 1196835616 sony_corporation = 1196896843 hci = 1212369184 heidelberger_druckmaschinen_ag = 1212435744 hermes = 1212502605 hitachi_america_ltd = 1212765249 hewlett_packard = 1213210656 hitachi_ltd = 1213481760 hiti_digital_inc = 1214862441 ibm_corporation = 1229081888 scitex_corporation_ltd = 1229213268 hewlett_packard_2 = 1229275936 iiyama_north_america_inc = 1229543745 ikegami_electronics_inc = 1229669703 image_systems_corporation = 1229799751 ingram_micro_inc = 1229801760 intel_corporation_2 = 1229870147 intl = 1229870156 intra_electronics_usa_inc = 1229870162 iocomm_international_technology_corporation = 1229931343 infoprint_solutions_company = 1230000928 scitex_corporation_ltd_3 = 1230129491 ichikawa_soft_laboratory = 1230195744 itnl = 1230261836 ivm = 1230392608 iwatsu_electric_co_ltd = 1230455124 scitex_corporation_ltd_2 = 1231318644 inca_digital_printers_ltd = 1231971169 scitex_corporation_ltd_4 = 1232234867 jetsoft_development = 1246971476 jvc_information_products_co = 1247167264 scitex_corporation_ltd_6 = 1262572116 kfc_computek_components_corporation = 1262895904 klh_computers = 1263290400 konica_minolta_holdings_inc = 1263355972 konica_corporation = 1263420225 kodak = 1263486017 kyocera = 1264144195 scitex_corporation_ltd_7 = 1264677492 leica_camera_ag = 1279476039 leeds_colour = 1279476548 left_dakota = 1279541579 leading_technology_inc = 1279607108 lexmark_international_inc = 1279613005 link_computer_inc = 1279872587 linotronic = 1279872591 lite_on_inc = 1279874117 mag_computronic_usa_inc = 1296123715 mag_innovision_inc = 1296123721 mannesmann = 1296125518 micron_technology_inc = 1296646990 microtek = 1296646994 microvitec_inc = 1296646998 minolta = 1296649807 mitsubishi_electronics_america_inc = 1296651347 mitsuba_corporation = 1296651379 minolta_2 = 1296976980 modgraph_inc = 1297040455 monitronix_inc = 1297043017 monaco_systems_inc = 1297043027 morse_technology_inc = 1297044051 motive_systems = 1297044553 microsoft_corporation = 1297303124 mutoh_industries_ltd = 1297437775 mitsubishi_electric_corporation_kyoto_works = 1298756723 nanao_usa_corporation = 1312902721 nec_corporation = 1313162016 nexpress_solutions_llc = 1313167440 nissei_sangyo_america_ltd = 1313428307 nikon_corporation = 1313558350 oce_technologies_bv = 1329808672 ocecolor = 1329808707 oki = 1330333984 okidata = 1330334020 okidata_2 = 1330334032 olivetti = 1330399574 olympus_optical_co_ltd = 1330403661 onyx_graphics = 1330534744 optiquest = 1330664521 packard_bell = 1346454347 matsushita_electric_industrial_co_ltd = 1346457153 pantone_inc = 1346457172 packard_bell_2 = 1346522656 pfu_limited = 1346786592 philips_consumer_electronics_co = 1346914636 hoya_corporation_pentax_imaging_systems_division = 1347310680 phase_one_a_s = 1347382885 premier_computer_innovations = 1347568973 princeton_graphic_systems = 1347569998 princeton_publishing_labs = 1347570000 qlux = 1363957080 qms_inc = 1364022048 qpcard_ab = 1364214596 quadlaser = 1364541764 qume_corporation = 1364544837 radius_inc = 1380009033 integrated_color_solutions_inc_2 = 1380205688 roland_dg_corporation = 1380206368 redms_group_inc = 1380271181 relisys = 1380273225 rolf_gierling_multitools = 1380404563 ricoh_corporation = 1380533071 edmund_ronald = 1380863044 royal = 1380931905 ricoh_printing_systemsltd = 1380991776 royal_information_electronics_co_ltd = 1381256224 sampo_corporation_of_america = 1396788560 samsung_inc = 1396788563 jaime_santana_pomares = 1396788820 scitex_corporation_ltd_9 = 1396918612 dainippon_screen_3 = 1396920910 scitex_corporation_ltd_12 = 1396985888 samsung_electronics_coltd = 1397048096 seiko_instruments_usa_inc = 1397049675 seikosha = 1397049707 scanguycom = 1397183833 sharp_laboratories = 1397244242 international_color_consortium = 1397310275 sony_corporation_2 = 1397706329 spectracal = 1397769036 star = 1398030674 sampo_technology_corporation = 1398031136 scitex_corporation_ltd_10 = 1399023988 scitex_corporation_ltd_13 = 1399091232 sony_corporation_3 = 1399811705 talon_technology_corporation = 1413565519 tandy = 1413566020 tatung_co_of_america_inc = 1413567573 taxan_america_inc = 1413568577 tokyo_denshi_sekei_kk = 1413763872 teco_information_systems_inc = 1413825359 tegra = 1413826386 tektronix_inc = 1413827412 texas_instruments = 1414078496 typemaker_ltd = 1414351698 toshiba_corp = 1414484802 toshiba_inc = 1414484808 totoku_electric_co_ltd = 1414485067 triumph = 1414678869 toshiba_tec_corporation = 1414742612 ttx_computer_products_inc = 1414813728 tvm_professional_monitor_corporation = 1414941984 tw_casper_corporation = 1414996000 ulead_systems = 1431065432 unisys = 1431193939 utz_fehlau_and_sohn = 1431591494 varityper = 1447121481 viewsonic = 1447642455 visual_communication = 1447646028 wang = 1463897671 wilbur_imaging = 1464615506 ware_to_go = 1465141042 wyse_technology = 1465471813 xerox_corporation = 1480938072 x_rite = 1481787732 lavanyas_test_company = 1513173555 zoran_corporation = 1515340110 zebra_technologies_inc = 1516593778 basiccolor_gmbh = 1648968515 bergdesign_incorporated = 1650815591 integrated_color_solutions_inc = 1667594596 macdermid_colorspan_inc = 1668051824 dainippon_screen_2 = 1685266464 dupont_2 = 1685418094 fujifilm_electronic_imaging_ltd_2 = 1717986665 fluxdata_corporation = 1718383992 scitex_corporation_ltd_5 = 1769105779 scitex_corporation_ltd_8 = 1801548404 erdt_systems_gmbh_and_co_kg_2 = 1868706916 medigraph_gmbh = 1868720483 qubyx_sarl = 1903518329 scitex_corporation_ltd_11 = 1935894900 dainippon_screen_4 = 1935897198 scitex_corporation_ltd_14 = 1935962144 siwi_grafika_corporation = 1936291689 yxymaster_gmbh = 2037938541 SEQ_FIELDS = ["device_manufacturer"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['device_manufacturer']['start'] = self._io.pos() self.device_manufacturer = KaitaiStream.resolve_enum(self._root.DeviceManufacturer.DeviceManufacturers, self._io.read_u4be()) self._debug['device_manufacturer']['end'] = self._io.pos() class S15Fixed16Number(KaitaiStruct): SEQ_FIELDS = ["number"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['number']['start'] = self._io.pos() self.number = self._io.read_bytes(4) self._debug['number']['end'] = self._io.pos() class PositionNumber(KaitaiStruct): SEQ_FIELDS = ["offset_to_data_element", "size_of_data_element"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['offset_to_data_element']['start'] = self._io.pos() self.offset_to_data_element = self._io.read_u4be() self._debug['offset_to_data_element']['end'] = self._io.pos() self._debug['size_of_data_element']['start'] = self._io.pos() self.size_of_data_element = self._io.read_u4be() self._debug['size_of_data_element']['end'] = self._io.pos()