def path_table(self):
if hasattr(self, '_m_path_table'):
return self._m_path_table
_pos = self._io.pos()
self._io.seek((self.lba_path_table_le * self._root.sector_size))
self._raw__m_path_table = self._io.read_bytes(
self.path_table_size.le)
_io__raw__m_path_table = KaitaiStream(
BytesIO(self._raw__m_path_table))
self._m_path_table = Iso9660.PathTableLe(_io__raw__m_path_table,
self, self._root)
self._io.seek(_pos)
return getattr(self, '_m_path_table', None)
def _read(self):
self._debug['extra_zero']['start'] = self._io.pos()
self.extra_zero = self._io.read_bytes(1)
self._debug['extra_zero']['end'] = self._io.pos()
if not self.extra_zero == b"\x00":
raise kaitaistruct.ValidationNotEqualError(
b"\x00", self.extra_zero, self._io,
u"/types/exif_in_jpeg/seq/0")
self._debug['data']['start'] = self._io.pos()
self._raw_data = self._io.read_bytes_full()
_io__raw_data = KaitaiStream(BytesIO(self._raw_data))
self.data = exif.Exif(_io__raw_data)
self.data._read()
self._debug['data']['end'] = self._io.pos()
def _read(self):
self.left = self._io.read_u2le()
self.top = self._io.read_u2le()
self.width = self._io.read_u2le()
self.height = self._io.read_u2le()
self.flags = self._io.read_u1()
if self.has_color_table:
self._raw_local_color_table = self._io.read_bytes(
(self.color_table_size * 3))
io = KaitaiStream(BytesIO(self._raw_local_color_table))
self.local_color_table = self._root.ColorTable(
io, self, self._root)
self.image_data = self._root.ImageData(self._io, self, self._root)
def _read(self):
self._debug['len_header']['start'] = self._io.pos()
self.len_header = self._io.read_u4le()
self._debug['len_header']['end'] = self._io.pos()
self._debug['header']['start'] = self._io.pos()
self._raw_header = self._io.read_bytes((self.len_header - 4))
_io__raw_header = KaitaiStream(BytesIO(self._raw_header))
self.header = Bmp.BitmapHeader(self.len_header, _io__raw_header, self, self._root)
self.header._read()
self._debug['header']['end'] = self._io.pos()
if self.is_color_mask_here:
self._debug['color_mask']['start'] = self._io.pos()
self.color_mask = Bmp.ColorMask(self.header.bitmap_info_ext.compression == Bmp.Compressions.alpha_bitfields, self._io, self, self._root)
self.color_mask._read()
self._debug['color_mask']['end'] = self._io.pos()
if not (self._io.is_eof()):
self._debug['color_table']['start'] = self._io.pos()
self._raw_color_table = self._io.read_bytes_full()
_io__raw_color_table = KaitaiStream(BytesIO(self._raw_color_table))
self.color_table = Bmp.ColorTable(not (self.header.is_core_header), (self.header.bitmap_info_ext.num_colors_used if self.header.extends_bitmap_info else 0), _io__raw_color_table, self, self._root)
self.color_table._read()
self._debug['color_table']['end'] = self._io.pos()
def extent_as_dir(self):
if hasattr(self, '_m_extent_as_dir'):
return self._m_extent_as_dir if hasattr(self, '_m_extent_as_dir') else None
if (self.file_flags & 2) != 0:
io = self._root._io
_pos = io.pos()
io.seek((self.lba_extent.le * self._root.sector_size))
self._raw__m_extent_as_dir = io.read_bytes(self.size_extent.le)
io = KaitaiStream(BytesIO(self._raw__m_extent_as_dir))
self._m_extent_as_dir = self._root.DirEntries(io, self, self._root)
io.seek(_pos)
return self._m_extent_as_dir if hasattr(self, '_m_extent_as_dir') else None
def _read(self):
self._raw_records = []
self.records = []
i = 0
while True:
_buf = self._io.read_bytes(self._root.recordsize)
self._raw_records.append(_buf)
_io__raw_records = KaitaiStream(BytesIO(self._raw_records[-1]))
_ = Model3Hrl.Record(_io__raw_records, self, self._root)
self.records.append(_)
if i == (self._root.header.blocksize // self._root.recordsize -
1):
break
i += 1
def _read(self):
self.xp3fileindex_compressed_flag = self._io.read_u1()
if self.xp3fileindex_compressed_flag == 1:
self.compressed_size = self._io.read_u8le()
self.uncompressed_size = self._io.read_u8le()
if self.xp3fileindex_compressed_flag == 1:
self._raw__raw_file_entries_compressed = self._io.read_bytes(
self.compressed_size)
self._raw_file_entries_compressed = zlib.decompress(
self._raw__raw_file_entries_compressed)
_io__raw_file_entries_compressed = KaitaiStream(
BytesIO(self._raw_file_entries_compressed))
self.file_entries_compressed = self._root.FileEntries(
_io__raw_file_entries_compressed, self, self._root)
if self.xp3fileindex_compressed_flag == 0:
self._raw_file_entries_uncompressed = self._io.read_bytes(
self.uncompressed_size)
_io__raw_file_entries_uncompressed = KaitaiStream(
BytesIO(self._raw_file_entries_uncompressed))
self.file_entries_uncompressed = self._root.FileEntries(
_io__raw_file_entries_uncompressed, self, self._root)
def _read(self):
self._raw_header = self._io.read_bytes(16)
_io__raw_header = KaitaiStream(BytesIO(self._raw_header))
self.header = Ines.Header(_io__raw_header, self, self._root)
if self.header.f6.trainer:
self.trainer = self._io.read_bytes(512)
self.prg_rom = self._io.read_bytes((self.header.len_prg_rom * 16384))
self.chr_rom = self._io.read_bytes((self.header.len_chr_rom * 8192))
if self.header.f7.playchoice10:
self.playchoice10 = Ines.Playchoice10(self._io, self, self._root)
if not (self._io.is_eof()):
self.title = (self._io.read_bytes_full()).decode(u"ASCII")
def package_capsule(self):
if hasattr(self, "_m_package_capsule"):
if hasattr(self, "_m_package_capsule"):
return self._m_package_capsule
return
_pos = self._io.pos()
self._io.seek(self.package_footer.capsule_offset + 8)
self._raw__m_package_capsule = self._io.read_bytes(
self.package_capsule_len)
io = KaitaiStream(BytesIO(self._raw__m_package_capsule))
self._m_package_capsule = DlstCapsule(io)
self._io.seek(_pos)
if hasattr(self, "_m_package_capsule"):
return self._m_package_capsule
def path_table(self):
if hasattr(self, '_m_path_table'):
return self._m_path_table if hasattr(self, '_m_path_table') else None
_pos = self._io.pos()
self._io.seek((self.lba_path_table_le * self._root.sector_size))
self._debug['_m_path_table']['start'] = self._io.pos()
self._raw__m_path_table = self._io.read_bytes(self.path_table_size.le)
_io__raw__m_path_table = KaitaiStream(BytesIO(self._raw__m_path_table))
self._m_path_table = Iso9660.PathTableLe(_io__raw__m_path_table, self, self._root)
self._m_path_table._read()
self._debug['_m_path_table']['end'] = self._io.pos()
self._io.seek(_pos)
return self._m_path_table if hasattr(self, '_m_path_table') else None
def _read(self):
self.icflag = self._root.Icflag(self._io, self, self._root)
_on = self.icflag.type
if _on == self._root.RecordType.data_initial:
self._raw_content = self._io.read_bytes((1536 - 4))
io = KaitaiStream(BytesIO(self._raw_content))
self.content = self._root.DataInitial(io, self, self._root)
elif _on == self._root.RecordType.data_continuation:
self._raw_content = self._io.read_bytes((1536 - 4))
io = KaitaiStream(BytesIO(self._raw_content))
self.content = self._root.DataContinuation(
io, self, self._root)
elif _on == self._root.RecordType.text_continuation:
self._raw_content = self._io.read_bytes((1536 - 4))
io = KaitaiStream(BytesIO(self._raw_content))
self.content = self._root.TextContinuation(
io, self, self._root)
elif _on == self._root.RecordType.text_initial:
self._raw_content = self._io.read_bytes((1536 - 4))
io = KaitaiStream(BytesIO(self._raw_content))
self.content = self._root.TextInitial(io, self, self._root)
else:
self.content = self._io.read_bytes((1536 - 4))
def _read(self):
self._debug['image_header']['start'] = self._io.pos()
self._raw_image_header = self._io.read_bytes(32)
_io__raw_image_header = KaitaiStream(BytesIO(self._raw_image_header))
self.image_header = self._root.ImageHeader(_io__raw_image_header, self,
self._root)
self.image_header._read()
self._debug['image_header']['end'] = self._io.pos()
self._debug['ilm']['start'] = self._io.pos()
self.ilm = self._io.read_bytes(self.image_header.ilm_len)
self._debug['ilm']['end'] = self._io.pos()
self._debug['dlm']['start'] = self._io.pos()
self.dlm = self._io.read_bytes(self.image_header.dlm_len)
self._debug['dlm']['end'] = self._io.pos()
def _read(self):
self.padding = self._io.read_bytes(((8 - self._io.pos()) % 8))
self.object_type = self._root.JournalObject.ObjectTypes(
self._io.read_u1())
self.flags = self._io.read_u1()
self.reserved = self._io.read_bytes(6)
self.len_object = self._io.read_u8le()
_on = self.object_type
if _on == self._root.JournalObject.ObjectTypes.data:
self._raw_payload = self._io.read_bytes((self.len_object - 16))
io = KaitaiStream(BytesIO(self._raw_payload))
self.payload = self._root.DataObject(io, self, self._root)
else:
self.payload = self._io.read_bytes((self.len_object - 16))
def _read(self):
self.len_filename = self._io.read_u4le()
self.filename = self._io.read_bytes(self.len_filename)
self.len_data_uncompressed = self._io.read_u4le()
self.timestamp = self._io.read_u4le()
self.len_data_compressed = self._io.read_u4le()
self.crc32 = self._io.read_u4le()
self.flags = PharWithoutStub.FileFlags(self._io, self, self._root)
self.len_metadata = self._io.read_u4le()
if self.len_metadata != 0:
self._raw_metadata = self._io.read_bytes(self.len_metadata)
_io__raw_metadata = KaitaiStream(BytesIO(self._raw_metadata))
self.metadata = PharWithoutStub.SerializedValue(
_io__raw_metadata, self, self._root)
def _read(self):
self.version_made_by = self._io.read_u2le()
self.version_needed_to_extract = self._io.read_u2le()
self.flags = self._io.read_u2le()
self.compression_method = KaitaiStream.resolve_enum(Zip.Compression, self._io.read_u2le())
self._raw_file_mod_time = self._io.read_bytes(4)
_io__raw_file_mod_time = KaitaiStream(BytesIO(self._raw_file_mod_time))
self.file_mod_time = dos_datetime.DosDatetime(_io__raw_file_mod_time)
self.crc32 = self._io.read_u4le()
self.len_body_compressed = self._io.read_u4le()
self.len_body_uncompressed = self._io.read_u4le()
self.len_file_name = self._io.read_u2le()
self.len_extra = self._io.read_u2le()
self.len_comment = self._io.read_u2le()
self.disk_number_start = self._io.read_u2le()
self.int_file_attr = self._io.read_u2le()
self.ext_file_attr = self._io.read_u4le()
self.ofs_local_header = self._io.read_s4le()
self.file_name = (self._io.read_bytes(self.len_file_name)).decode(u"UTF-8")
self._raw_extra = self._io.read_bytes(self.len_extra)
_io__raw_extra = KaitaiStream(BytesIO(self._raw_extra))
self.extra = Zip.Extras(_io__raw_extra, self, self._root)
self.comment = (self._io.read_bytes(self.len_comment)).decode(u"UTF-8")
def _read(self):
self.metadata = self._io.read_bytes(
self._root.header.header_main.block_metadata_size)
self._raw_data = []
self.data = []
i = 0
while not self._io.is_eof():
self._raw_data.append(
self._io.read_bytes(
self._root.header.header_main.block_data_size))
_io__raw_data = KaitaiStream(BytesIO(self._raw_data[-1]))
self.data.append(
Vdi.Disk.Block.Sector(_io__raw_data, self, self._root))
i += 1
def _read(self):
self.unused1 = self._io.read_bytes(1)
if not self.unused1 == b"\x00":
raise kaitaistruct.ValidationNotEqualError(
b"\x00", self.unused1, self._io,
u"/types/vol_desc_primary/seq/0")
self.system_id = (self._io.read_bytes(32)).decode(u"UTF-8")
self.volume_id = (self._io.read_bytes(32)).decode(u"UTF-8")
self.unused2 = self._io.read_bytes(8)
if not self.unused2 == b"\x00\x00\x00\x00\x00\x00\x00\x00":
raise kaitaistruct.ValidationNotEqualError(
b"\x00\x00\x00\x00\x00\x00\x00\x00", self.unused2,
self._io, u"/types/vol_desc_primary/seq/3")
self.vol_space_size = Iso9660.U4bi(self._io, self, self._root)
self.unused3 = self._io.read_bytes(32)
if not self.unused3 == b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00":
raise kaitaistruct.ValidationNotEqualError(
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
self.unused3, self._io, u"/types/vol_desc_primary/seq/5")
self.vol_set_size = Iso9660.U2bi(self._io, self, self._root)
self.vol_seq_num = Iso9660.U2bi(self._io, self, self._root)
self.logical_block_size = Iso9660.U2bi(self._io, self, self._root)
self.path_table_size = Iso9660.U4bi(self._io, self, self._root)
self.lba_path_table_le = self._io.read_u4le()
self.lba_opt_path_table_le = self._io.read_u4le()
self.lba_path_table_be = self._io.read_u4be()
self.lba_opt_path_table_be = self._io.read_u4be()
self._raw_root_dir = self._io.read_bytes(34)
_io__raw_root_dir = KaitaiStream(BytesIO(self._raw_root_dir))
self.root_dir = Iso9660.DirEntry(_io__raw_root_dir, self,
self._root)
self.vol_set_id = (self._io.read_bytes(128)).decode(u"UTF-8")
self.publisher_id = (self._io.read_bytes(128)).decode(u"UTF-8")
self.data_preparer_id = (self._io.read_bytes(128)).decode(u"UTF-8")
self.application_id = (self._io.read_bytes(128)).decode(u"UTF-8")
self.copyright_file_id = (self._io.read_bytes(38)).decode(u"UTF-8")
self.abstract_file_id = (self._io.read_bytes(36)).decode(u"UTF-8")
self.bibliographic_file_id = (
self._io.read_bytes(37)).decode(u"UTF-8")
self.vol_create_datetime = Iso9660.DecDatetime(
self._io, self, self._root)
self.vol_mod_datetime = Iso9660.DecDatetime(
self._io, self, self._root)
self.vol_expire_datetime = Iso9660.DecDatetime(
self._io, self, self._root)
self.vol_effective_datetime = Iso9660.DecDatetime(
self._io, self, self._root)
self.file_structure_version = self._io.read_u1()
self.unused4 = self._io.read_u1()
self.application_area = self._io.read_bytes(512)
def __init__(self, _io, _parent=None, _root=None):
self._io = _io
self._parent = _parent
self._root = _root if _root else self
self.const1 = self._io.ensure_fixed_contents(
struct.pack('11b', 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 1))
self.hash1 = self._root.Hash(self._io, self, self._root)
self.const2 = self._io.ensure_fixed_contents(
struct.pack('6b', 29, 0, 4, 0, -95, 0))
self.data2_hash = self._root.Hash(self._io, self, self._root)
self._raw_data2 = self._io.read_bytes(161)
io = KaitaiStream(BytesIO(self._raw_data2))
self.data2 = self._root.Data2(io, self, self._root)
self.const3 = self._io.ensure_fixed_contents(
struct.pack('4b', 3, 0, -72, 0))
self.data3_hash = self._root.Hash(self._io, self, self._root)
self._raw_data3 = self._io.read_bytes(184)
io = KaitaiStream(BytesIO(self._raw_data3))
self.data3 = self._root.Data3(io, self, self._root)
self.const4 = self._io.ensure_fixed_contents(
struct.pack('4b', 5, 0, -92, 1))
self.data4_hash = self._root.Hash(self._io, self, self._root)
self.data4 = self._io.read_bytes(420)
self.const5 = self._io.ensure_fixed_contents(
struct.pack('4b', 1, 0, 0, 1))
self.data5_hash = self._root.Hash(self._io, self, self._root)
self.data5 = self._io.read_bytes(256)
self.const6 = self._io.ensure_fixed_contents(
struct.pack('4b', 2, 0, 0, 1))
self.data6_hash = self._root.Hash(self._io, self, self._root)
self.data6 = self._io.read_bytes(256)
self.const7 = self._io.ensure_fixed_contents(
struct.pack('4b', 6, 0, -112, 1))
self.data7_hash = self._root.Hash(self._io, self, self._root)
self._raw_data7 = self._io.read_bytes(400)
io = KaitaiStream(BytesIO(self._raw_data7))
self.data7 = self._root.Data7(io, self, self._root)
def _read(self):
self._debug['block_type']['start'] = self._io.pos()
self.block_type = KaitaiStream.resolve_enum(
CreativeVoiceFile.BlockTypes, self._io.read_u1())
self._debug['block_type']['end'] = self._io.pos()
if self.block_type != CreativeVoiceFile.BlockTypes.terminator:
self._debug['body_size1']['start'] = self._io.pos()
self.body_size1 = self._io.read_u2le()
self._debug['body_size1']['end'] = self._io.pos()
if self.block_type != CreativeVoiceFile.BlockTypes.terminator:
self._debug['body_size2']['start'] = self._io.pos()
self.body_size2 = self._io.read_u1()
self._debug['body_size2']['end'] = self._io.pos()
if self.block_type != CreativeVoiceFile.BlockTypes.terminator:
self._debug['body']['start'] = self._io.pos()
_on = self.block_type
if _on == CreativeVoiceFile.BlockTypes.sound_data_new:
self._raw_body = self._io.read_bytes(self.body_size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = CreativeVoiceFile.BlockSoundDataNew(
_io__raw_body, self, self._root)
self.body._read()
elif _on == CreativeVoiceFile.BlockTypes.repeat_start:
self._raw_body = self._io.read_bytes(self.body_size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = CreativeVoiceFile.BlockRepeatStart(
_io__raw_body, self, self._root)
self.body._read()
elif _on == CreativeVoiceFile.BlockTypes.marker:
self._raw_body = self._io.read_bytes(self.body_size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = CreativeVoiceFile.BlockMarker(
_io__raw_body, self, self._root)
self.body._read()
elif _on == CreativeVoiceFile.BlockTypes.sound_data:
self._raw_body = self._io.read_bytes(self.body_size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = CreativeVoiceFile.BlockSoundData(
_io__raw_body, self, self._root)
self.body._read()
elif _on == CreativeVoiceFile.BlockTypes.extra_info:
self._raw_body = self._io.read_bytes(self.body_size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = CreativeVoiceFile.BlockExtraInfo(
_io__raw_body, self, self._root)
self.body._read()
elif _on == CreativeVoiceFile.BlockTypes.silence:
self._raw_body = self._io.read_bytes(self.body_size)
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = CreativeVoiceFile.BlockSilence(
_io__raw_body, self, self._root)
self.body._read()
else:
self.body = self._io.read_bytes(self.body_size)
self._debug['body']['end'] = self._io.pos()
def _read(self):
self._debug['len_manifest']['start'] = self._io.pos()
self.len_manifest = self._io.read_u4le()
self._debug['len_manifest']['end'] = self._io.pos()
self._debug['num_files']['start'] = self._io.pos()
self.num_files = self._io.read_u4le()
self._debug['num_files']['end'] = self._io.pos()
self._debug['api_version']['start'] = self._io.pos()
self.api_version = PharWithoutStub.ApiVersion(
self._io, self, self._root)
self.api_version._read()
self._debug['api_version']['end'] = self._io.pos()
self._debug['flags']['start'] = self._io.pos()
self.flags = PharWithoutStub.GlobalFlags(self._io, self,
self._root)
self.flags._read()
self._debug['flags']['end'] = self._io.pos()
self._debug['len_alias']['start'] = self._io.pos()
self.len_alias = self._io.read_u4le()
self._debug['len_alias']['end'] = self._io.pos()
self._debug['alias']['start'] = self._io.pos()
self.alias = self._io.read_bytes(self.len_alias)
self._debug['alias']['end'] = self._io.pos()
self._debug['len_metadata']['start'] = self._io.pos()
self.len_metadata = self._io.read_u4le()
self._debug['len_metadata']['end'] = self._io.pos()
if self.len_metadata != 0:
self._debug['metadata']['start'] = self._io.pos()
self._raw_metadata = self._io.read_bytes(self.len_metadata)
_io__raw_metadata = KaitaiStream(BytesIO(self._raw_metadata))
self.metadata = PharWithoutStub.SerializedValue(
_io__raw_metadata, self, self._root)
self.metadata._read()
self._debug['metadata']['end'] = self._io.pos()
self._debug['file_entries']['start'] = self._io.pos()
self.file_entries = [None] * (self.num_files)
for i in range(self.num_files):
if not 'arr' in self._debug['file_entries']:
self._debug['file_entries']['arr'] = []
self._debug['file_entries']['arr'].append(
{'start': self._io.pos()})
_t_file_entries = PharWithoutStub.FileEntry(
self._io, self, self._root)
_t_file_entries._read()
self.file_entries[i] = _t_file_entries
self._debug['file_entries']['arr'][i]['end'] = self._io.pos()
self._debug['file_entries']['end'] = self._io.pos()
def data(self):
if hasattr(self, '_m_data'):
return self._m_data
if self.size != 0:
_pos = self._io.pos()
self._io.seek(self.offset)
self._raw__m_data = self._io.read_bytes(self.size)
_io__raw__m_data = KaitaiStream(
BytesIO(self._raw__m_data))
self._m_data = Lvm2.PhysicalVolume.Label.VolumeHeader.MetadataArea(
_io__raw__m_data, self, self._root)
self._io.seek(_pos)
return getattr(self, '_m_data', None)
def index(self):
if hasattr(self, '_m_index'):
return self._m_index if hasattr(self, '_m_index') else None
_pos = self._io.pos()
self._io.seek(self.ofs_index)
self._debug['_m_index']['start'] = self._io.pos()
self._raw__m_index = self._io.read_bytes(self.len_index)
_io__raw__m_index = KaitaiStream(BytesIO(self._raw__m_index))
self._m_index = QuakePak.IndexStruct(_io__raw__m_index, self,
self._root)
self._m_index._read()
self._debug['_m_index']['end'] = self._io.pos()
self._io.seek(_pos)
return self._m_index if hasattr(self, '_m_index') else None
def _read(self):
self.version = self._io.read_bits_int_be(2)
self.padding = self._io.read_bits_int_be(1) != 0
self.subtype = self._io.read_bits_int_be(5)
self._io.align_to_byte()
self.payload_type = KaitaiStream.resolve_enum(
RtcpPayload.PayloadType, self._io.read_u1())
self.length = self._io.read_u2be()
_on = self.payload_type
if _on == RtcpPayload.PayloadType.sr:
self._raw_body = self._io.read_bytes((4 * self.length))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = RtcpPayload.SrPacket(_io__raw_body, self,
self._root)
elif _on == RtcpPayload.PayloadType.psfb:
self._raw_body = self._io.read_bytes((4 * self.length))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = RtcpPayload.PsfbPacket(_io__raw_body, self,
self._root)
elif _on == RtcpPayload.PayloadType.rr:
self._raw_body = self._io.read_bytes((4 * self.length))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = RtcpPayload.RrPacket(_io__raw_body, self,
self._root)
elif _on == RtcpPayload.PayloadType.rtpfb:
self._raw_body = self._io.read_bytes((4 * self.length))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = RtcpPayload.RtpfbPacket(_io__raw_body, self,
self._root)
elif _on == RtcpPayload.PayloadType.sdes:
self._raw_body = self._io.read_bytes((4 * self.length))
_io__raw_body = KaitaiStream(BytesIO(self._raw_body))
self.body = RtcpPayload.SdesPacket(_io__raw_body, self,
self._root)
else:
self.body = self._io.read_bytes((4 * self.length))
def _read(self):
self._raw_vars = self._io.read_bytes(self._parent.var_size)
_io__raw_vars = KaitaiStream(BytesIO(self._raw_vars))
self.vars = NtMdt.Frame.FdSpectroscopy.Vars(
_io__raw_vars, self, self._root)
self.fm_mode = self._io.read_u2le()
self.fm_xres = self._io.read_u2le()
self.fm_yres = self._io.read_u2le()
self.dots = NtMdt.Frame.Dots(self._io, self, self._root)
self.data = []
for i in range((self.fm_xres * self.fm_yres)):
self.data.append(self._io.read_s2le())
self.title = NtMdt.Title(self._io, self, self._root)
self.xml = NtMdt.Xml(self._io, self, self._root)
def _read(self):
self._raw_vars = self._io.read_bytes(self._parent.var_size)
io = KaitaiStream(BytesIO(self._raw_vars))
self.vars = self._root.Frame.FdSpectroscopy.Vars(
io, self, self._root)
self.fm_mode = self._io.read_u2le()
self.fm_xres = self._io.read_u2le()
self.fm_yres = self._io.read_u2le()
self.dots = self._root.Frame.Dots(self._io, self, self._root)
self.data = [None] * ((self.fm_xres * self.fm_yres))
for i in range((self.fm_xres * self.fm_yres)):
self.data[i] = self._io.read_s2le()
self.title = self._root.Title(self._io, self, self._root)
self.xml = self._root.Xml(self._io, self, self._root)
def _read(self):
self._debug['len_payload']['start'] = self._io.pos()
self.len_payload = vlq_base128_be.VlqBase128Be(self._io)
self.len_payload._read()
self._debug['len_payload']['end'] = self._io.pos()
self._debug['row_id']['start'] = self._io.pos()
self.row_id = vlq_base128_be.VlqBase128Be(self._io)
self.row_id._read()
self._debug['row_id']['end'] = self._io.pos()
self._debug['payload']['start'] = self._io.pos()
self._raw_payload = self._io.read_bytes(self.len_payload.value)
_io__raw_payload = KaitaiStream(BytesIO(self._raw_payload))
self.payload = Sqlite3.CellPayload(_io__raw_payload, self, self._root)
self.payload._read()
self._debug['payload']['end'] = self._io.pos()
def resource_map(self):
"""The resource file's resource map."""
if hasattr(self, '_m_resource_map'):
return self._m_resource_map if hasattr(self, '_m_resource_map') else None
_pos = self._io.pos()
self._io.seek(self.header.ofs_resource_map)
self._debug['_m_resource_map']['start'] = self._io.pos()
self._raw__m_resource_map = self._io.read_bytes(self.header.len_resource_map)
_io__raw__m_resource_map = KaitaiStream(BytesIO(self._raw__m_resource_map))
self._m_resource_map = self._root.ResourceMap(_io__raw__m_resource_map, self, self._root)
self._m_resource_map._read()
self._debug['_m_resource_map']['end'] = self._io.pos()
self._io.seek(_pos)
return self._m_resource_map if hasattr(self, '_m_resource_map') else None
def type_list_and_reference_lists(self):
"""The resource map's resource type list, followed by the resource reference list area."""
if hasattr(self, '_m_type_list_and_reference_lists'):
return self._m_type_list_and_reference_lists if hasattr(self, '_m_type_list_and_reference_lists') else None
_pos = self._io.pos()
self._io.seek(self.ofs_type_list)
self._debug['_m_type_list_and_reference_lists']['start'] = self._io.pos()
self._raw__m_type_list_and_reference_lists = self._io.read_bytes((self.ofs_names - self.ofs_type_list))
_io__raw__m_type_list_and_reference_lists = KaitaiStream(BytesIO(self._raw__m_type_list_and_reference_lists))
self._m_type_list_and_reference_lists = self._root.ResourceMap.TypeListAndReferenceLists(_io__raw__m_type_list_and_reference_lists, self, self._root)
self._m_type_list_and_reference_lists._read()
self._debug['_m_type_list_and_reference_lists']['end'] = self._io.pos()
self._io.seek(_pos)
return self._m_type_list_and_reference_lists if hasattr(self, '_m_type_list_and_reference_lists') else None
def data(self):
if hasattr(self, '_m_data'):
return self._m_data
_pos = self._io.pos()
self._io.seek(self.ofs_data)
_on = self.stream_type
if _on == WindowsMinidump.StreamTypes.memory_list:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = WindowsMinidump.MemoryList(
_io__raw__m_data, self, self._root)
elif _on == WindowsMinidump.StreamTypes.misc_info:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = WindowsMinidump.MiscInfo(
_io__raw__m_data, self, self._root)
elif _on == WindowsMinidump.StreamTypes.thread_list:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = WindowsMinidump.ThreadList(
_io__raw__m_data, self, self._root)
elif _on == WindowsMinidump.StreamTypes.exception:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = WindowsMinidump.ExceptionStream(
_io__raw__m_data, self, self._root)
elif _on == WindowsMinidump.StreamTypes.system_info:
self._raw__m_data = self._io.read_bytes(self.len_data)
_io__raw__m_data = KaitaiStream(BytesIO(self._raw__m_data))
self._m_data = WindowsMinidump.SystemInfo(
_io__raw__m_data, self, self._root)
else:
self._m_data = self._io.read_bytes(self.len_data)
self._io.seek(_pos)
return getattr(self, '_m_data', None)
def _read(self):
self._debug['name_index']['start'] = self._io.pos()
self.name_index = self._io.read_u2be()
self._debug['name_index']['end'] = self._io.pos()
self._debug['attribute_length']['start'] = self._io.pos()
self.attribute_length = self._io.read_u4be()
self._debug['attribute_length']['end'] = self._io.pos()
self._debug['info']['start'] = self._io.pos()
_on = self.name_as_str
if _on == u"SourceFile":
self._raw_info = self._io.read_bytes(self.attribute_length)
_io__raw_info = KaitaiStream(BytesIO(self._raw_info))
self.info = JavaClass.AttributeInfo.AttrBodySourceFile(
_io__raw_info, self, self._root)
self.info._read()
elif _on == u"LineNumberTable":
self._raw_info = self._io.read_bytes(self.attribute_length)
_io__raw_info = KaitaiStream(BytesIO(self._raw_info))
self.info = JavaClass.AttributeInfo.AttrBodyLineNumberTable(
_io__raw_info, self, self._root)
self.info._read()
elif _on == u"Exceptions":
self._raw_info = self._io.read_bytes(self.attribute_length)
_io__raw_info = KaitaiStream(BytesIO(self._raw_info))
self.info = JavaClass.AttributeInfo.AttrBodyExceptions(
_io__raw_info, self, self._root)
self.info._read()
elif _on == u"Code":
self._raw_info = self._io.read_bytes(self.attribute_length)
_io__raw_info = KaitaiStream(BytesIO(self._raw_info))
self.info = JavaClass.AttributeInfo.AttrBodyCode(
_io__raw_info, self, self._root)
self.info._read()
else:
self.info = self._io.read_bytes(self.attribute_length)
self._debug['info']['end'] = self._io.pos()
