def __init__(self, f: IO):
super().__init__(f)
#: IRD file format version
self.version: int = read_u8(f)
self.logger.info(f"IRD Version: {self.version}")
#: Game ID (ex. BLUS12354)
self.game_id: str = f.read(GAME_ID_SIZE).decode('UTF-8')
self.logger.info(f"Game ID: {self.game_id}")
#: Game name length
self.game_name_size: int = read_u8(f)
self.logger.debug(f"Game Name Size: {self.game_name_size}")
#: Game name
self.game_name: str = f.read(self.game_name_size).decode('UTF-8')
self.logger.info(f"Game Name: {self.game_name}")
#: Update version
self.update_version: str = f.read(4)
self.logger.info(f"Update Version: {self.update_version}")
#: Game version
self.game_version: str = f.read(5)
self.logger.info(f"Game Version: {self.game_version}")
#: App version
self.app_version: str = f.read(5)
self.logger.info(f"App Version: {self.app_version}")
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
self.reserved_1: bytes = f.read(1)
self.logger.debug(f"Reserved 1: {hex_log_str(self.reserved_1)}")
self.sub_path_type: SubPathType = SubPathType(
read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(f"Sub Path Type: {self.sub_path_type}")
self.flags_1: bytes = f.read(2)
self.logger.debug(f"Flags 1: {hex_log_str(self.flags_1)}")
self.is_repeat_sub_path: bool = (self.flags_1[1] & 0b00000001) == 1
self.logger.debug(f"Is Repeat Sub Path: {self.is_repeat_sub_path}")
self.reserved_2: bytes = f.read(1)
self.logger.debug(f"Reserved 2: {hex_log_str(self.reserved_2)}")
self.num_sub_play_items: int = read_u8(f,
endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Num Sub Play Items: {self.length}")
self.sub_play_items: List[SubPlayItem] = []
for index in range(self.num_sub_play_items):
self.logger.debug(f"Reading Sub Play Item {index}")
self.sub_play_items.append(SubPlayItem(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.spn_program_sequence_start: int = read_u32(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"SPN Program Sequence Start: {self.spn_program_sequence_start}")
self.program_map_pid: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Program Map PID: {self.program_map_pid}")
self.number_of_streams_in_ps: int = read_u8(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Number of Streams in PS: {self.number_of_streams_in_ps}")
self.number_of_groups_in_ps: int = read_u8(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Number of Groups in PS: {self.number_of_groups_in_ps}")
self.streams: List[StreamInPS] = list()
for stream_in_ps_index in range(self.number_of_streams_in_ps):
self.logger.debug(f"Reading Stream in PS {stream_in_ps_index}")
self.streams.append(StreamInPS(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
self.clip_information_file_name: str = f.read(5).decode("ASCII")
self.logger.debug(
f"Clip Information File Name: {self.clip_information_file_name}")
self.clip_codec_identifier: str = f.read(4).decode("ASCII")
self.logger.debug(
f"Clip Codec Identifier: {self.clip_codec_identifier}")
self.flags_1: bytes = f.read(2)
self.logger.debug(f"Flags 1: {hex_log_str(self.flags_1)}")
self.is_multi_angle: bool = ((self.flags_1[1] & 0b00010000) >> 4) == 1
self.logger.debug(f"Is Multi Angle: {self.is_multi_angle}")
self.connection_condition: int = self.flags_1[1] & 0b00001111
self.logger.debug(f"Connection Condition: {self.connection_condition}")
self.ref_to_stc_id: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Reference to STC ID: {self.ref_to_stc_id}")
self.in_time: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"In Time: {self.in_time}")
self.out_time: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Out Time: {self.out_time}")
self.u0_mask_table: U0MaskTable = U0MaskTable(f)
self.flags_2: bytes = f.read(1)
self.logger.debug(f"Flags 2: {hex_log_str(self.flags_2)}")
self.random_access_flag: bool = (
(self.flags_2[0] & 0b10000000) >> 7) == 1
self.logger.debug(f"Random Access Flag: {self.random_access_flag}")
self.still_mode: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Still Mode: {self.still_mode}")
if self.still_mode == 0x01:
self.still_time: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Still Time: {self.still_time}")
else:
self.reserved: bytes = f.read(2)
self.logger.debug(f"Reserved: {hex_log_str(self.reserved)}")
if self.is_multi_angle:
self.multi_angle_entries: MultiAngleEntries = MultiAngleEntries(f)
self.stn_table: StnTable = StnTable(f)
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.number_of_clips: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Clips: {self.number_of_clips}")
self.reserved: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Reserved: {self.reserved}")
self.clips: List[Clip] = []
for index in range(self.number_of_clips):
self.logger.debug(f"Reading Clip {index}")
self.clips.append(Clip(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
if self.length != 0:
self.data_block_start_address: int = read_u32(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Data Block Start Address: {self.data_block_start_address}")
self.reserved_for_word_align: int = f.read(3)
self.logger.debug(
f"Reserved For Word Align: {self.reserved_for_word_align}")
self.number_of_ext_data_entries: int = read_u8(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Number of Ext Data Entries: {self.number_of_ext_data_entries}"
)
self.entries: List[Entry] = list()
for entry_index in range(self.number_of_ext_data_entries):
self.logger.debug(f"Reading Entry {entry_index}")
self.entries.append(Entry(f))
self.data_block: bytes = f.read(4 + self.length -
self.data_block_start_address)
self.logger.debug(f"Data Block: {hex_log_str(self.data_block)}")
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.reserved: int = f.read(1)
self.logger.debug(f"Reserved: {self.reserved}")
self.mark_type: MarkType = MarkType(
read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(f"Mark Type: {self.mark_type}")
self.ref_to_play_item_id: int = read_u16(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Ref To Play Item ID: {self.ref_to_play_item_id}")
self.mark_timestamp: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Mark Timestamp: {self.mark_timestamp}")
self.entry_esp_id: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Entry ESP Id: {self.entry_esp_id}")
self.duration: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Duration: {self.duration}")
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.spn_atc_start: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"SPN ATC Start: {self.spn_atc_start}")
self.number_of_stc_sequences: int = read_u8(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Number of STC Sequences: {self.number_of_stc_sequences}")
self.offset_stc_id: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Offset STC ID: {self.offset_stc_id}")
self.stc_sequences: List[StcSequence] = list()
for stc_sequence_index in range(self.number_of_stc_sequences):
self.logger.debug(f"Reading STC Sequence {stc_sequence_index}")
self.stc_sequences.append(StcSequence(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.clip_information_file_name: str = f.read(5).decode("ASCII")
self.logger.debug(f"Clip Information File Name: {self.clip_information_file_name}")
self.clip_codec_identifier: str = f.read(4).decode("ASCII")
self.logger.debug(f"Clip Codec Identifier: {self.clip_information_file_name}")
self.ref_to_stc_id: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Reference to STC ID: {self.ref_to_stc_id}")
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.number_of_angles: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Angles: {self.number_of_angles}")
self.flags: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Flags: {self.flags}")
self.is_different_audios: bool = ((self.flags & 0b00000010) >> 1) == 1
self.logger.debug(f"Is Different Audios: {self.is_different_audios}")
self.is_seamless_angle_change: bool = (
(self.flags & 0b00000001) >> 1) == 1
self.logger.debug(
f"Is Seamless Angle Change: {self.is_seamless_angle_change}")
self.angles: List[Angle] = []
for index in range(self.number_of_angles):
self.logger.debug(f"Reading Angle {index}")
self.angles.append(Angle(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
self.clip_information_file_name: str = f.read(5).decode("ASCII")
self.logger.debug(
f"Clip Information File Name: {self.clip_information_file_name}")
self.clip_codec_identifier: str = f.read(4).decode("ASCII")
self.logger.debug(
f"Clip Codec Identifier: {self.clip_information_file_name}")
self.flags_1: bytes = f.read(2)
self.logger.debug(f"Flags 1: {hex_log_str(self.flags_1)}")
self.connection_condition: int = (self.flags_1[1] & 0b00011110) >> 1
self.logger.debug(f"Connection Condition: {self.connection_condition}")
self.is_multi_clip_entries: bool = (self.flags_1[1] & 0b00000001) == 1
self.logger.debug(
f"Is Multi Clip Entries: {self.is_multi_clip_entries}")
self.ref_to_stc_id: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Reference to STC ID: {self.ref_to_stc_id}")
self.in_time: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"In Time: {self.in_time}")
self.out_time: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Out Time: {self.out_time}")
self.sync_play_item_id: int = read_u16(f,
endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Sync Play Item ID: {self.sync_play_item_id}")
self.sync_start_pts_of_play_item: int = read_u32(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Sync Start PTS of Play Item: {self.sync_start_pts_of_play_item}")
if self.is_multi_clip_entries:
self.multi_clip_entries: MultiClipEntries = MultiClipEntries(f)
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
self.reserved_1: bytes = f.read(8 // 8)
self.logger.debug(f"Reserved 1: {hex_log_str(self.reserved_1)}")
self.number_of_programs: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Programs: {self.number_of_programs}")
self.programs: List[Program] = list()
for program_index in range(self.number_of_programs):
self.logger.debug(f"Program Index {program_index}")
self.programs.append(Program(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
self.reserved_1: bytes = f.read(8 // 8)
self.logger.debug(f"Reserved 1: {hex_log_str(self.reserved_1)}")
self.number_of_atc_sequences: int = read_u8(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Number of ATC Sequences: {self.number_of_atc_sequences}")
self.atc_sequences: List[AtcSequence] = list()
for atc_sequence_index in range(self.number_of_atc_sequences):
self.logger.debug(f"Reading ATC Sequence {atc_sequence_index}")
self.atc_sequences.append(AtcSequence(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
self.reserved_1: bytes = f.read(2)
self.logger.debug(f"Reserved 1: {hex_log_str(self.reserved_1)}")
self.num_video: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Video Streams: {self.num_video}")
self.num_audio: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Audio Streams: {self.num_audio}")
self.num_pg: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of PG Streams: {self.num_pg}")
self.num_ig: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of IG Streams: {self.num_ig}")
self.num_secondary_audio: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Secondary Audio Streams: {self.num_secondary_audio}")
self.num_secondary_video: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Secondary Video Streams: {self.num_secondary_video}")
self.num_secondary_pg: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of Secondary PG Streams: {self.num_secondary_pg}")
self.num_dv: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Number of DV Streams: {self.num_dv}")
self.reserved_2: bytes = f.read(4)
self.logger.debug(f"Reserved 2: {hex_log_str(self.reserved_2)}")
self.video_streams: List[Stream] = []
for index in range(self.num_video):
self.logger.debug(f"Reading Video Stream {index}")
self.video_streams.append(Stream(f))
self.audio_streams: List[Stream] = []
for index in range(self.num_audio):
self.logger.debug(f"Reading Audio Stream {index}")
self.audio_streams.append(Stream(f))
self.pg_streams: List[Stream] = []
for index in range(self.num_pg):
self.logger.debug(f"Reading PG Stream {index}")
self.pg_streams.append(Stream(f))
self.secondary_pg_streams: List[Stream] = []
for index in range(self.num_secondary_pg):
self.logger.debug(f"Reading Secondary PG Stream {index}")
self.secondary_pg_streams.append(Stream(f))
self.ig_streams: List[Stream] = []
for index in range(self.num_ig):
self.logger.debug(f"Reading IG Stream {index}")
self.ig_streams.append(Stream(f))
self.secondary_audio_streams: List[Stream] = []
for index in range(self.num_secondary_audio):
self.logger.debug(f"Reading Secondary Audio Stream {index}")
self.secondary_audio_streams.append(Stream(f))
self.secondary_video_streams: List[Stream] = []
for index in range(self.num_secondary_video):
self.logger.debug(f"Reading Secondary Video Stream {index}")
self.secondary_video_streams.append(Stream(f))
self.dv_streams: List[Stream] = []
for index in range(self.num_dv):
self.logger.debug(f"Reading DV Stream {index}")
self.dv_streams.append(Stream(f))
def __init__(self, f: IO):
"""
Init
"""
super().__init__()
self.length: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
self.reserved_1: bytes = f.read(16 // 8)
self.logger.debug(f"Reserved 1: {hex_log_str(self.reserved_1)}")
self.clip_stream_type: ClipStreamType = ClipStreamType(
read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(f"Clip Stream Type: {self.clip_stream_type}")
self.application_type: ApplicationType = ApplicationType(
read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(f"Application Type: {self.application_type}")
self.flags: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Flags: {bin(self.flags)}")
self.is_cc5: bool = get_flag(self.flags, 31)
self.logger.debug(f"Is CC5 / Is ATC Delta: {self.is_cc5}")
self.ts_recording_rate: int = read_u32(f,
endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"TS Recording Rate: {self.ts_recording_rate}")
self.number_of_source_packets: int = read_u32(
f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(
f"Number of Source Packets: {self.number_of_source_packets}")
self.reserved_2: bytes = f.read(1024 // 8)
self.logger.debug(f"Reserved 2: {hex_log_str(self.reserved_2)}")
self.ts_type_info_block: TsTypeInfoBlock = TsTypeInfoBlock(f)
if self.is_cc5:
self.reserved_3: bytes = f.read(8 // 8)
self.logger.debug(f"Reserved 3: {hex_log_str(self.reserved_3)}")
self.following_clip_stream_type: FollowingClipStreamType = FollowingClipStreamType(
read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(
f"Following Clip Stream Type: {self.following_clip_stream_type}"
)
self.reserved_4: bytes = f.read(32 // 8)
self.logger.debug(f"Reserved 4: {hex_log_str(self.reserved_4)}")
self.following_clip_information_file_name: str = f.read(5).decode(
"ASCII")
self.logger.debug(
f"Following Clip Information File Name: {self.following_clip_information_file_name}"
)
self.following_clip_codec_identifier: str = f.read(4).decode(
"ASCII")
self.logger.debug(
f"Following Clip Codec Identifier: {self.following_clip_information_file_name}"
)
self.reserved_5: bytes = f.read(8 // 8)
self.logger.debug(f"Reserved 5: {hex_log_str(self.reserved_5)}")
def __init__(self, f: IO):
"""
Init
"""
super().__init__(f)
self.length: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Length: {self.length}")
current_position: int = f.tell()
self.logger.debug(f"Current Position: {current_position}")
self.stream_type: StreamType = StreamType(read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(f"Stream Type: {self.stream_type}")
if self.stream_type == StreamType.USED_BY_PLAY_ITEM:
self.pid: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"PID: {self.pid}")
elif self.stream_type == StreamType.USED_BY_SUB_PATH_TYPE_23456:
self.sub_path_id: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Sub Path ID: {self.sub_path_id}")
self.sub_clip_id: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Sub Clip ID: {self.sub_clip_id}")
self.pid: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"PID: {self.pid}")
elif self.stream_type == StreamType.USED_BY_SUB_PATH_TYPE_7:
self.sub_path_id: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Sub Path ID: {self.sub_path_id}")
self.pid: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"PID: {self.pid}")
self.logger.debug(f"Seeking to current_position + length")
self.seek(current_position + self.length)
self.attributes_length: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Attributes Length: {self.attributes_length}")
current_position: int = f.tell()
self.logger.debug(f"Current Position: {current_position}")
self.coding_type: CodingType = CodingType(read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(f"Coding Type: {self.coding_type}")
if self.coding_type in [
CodingType.MPEG1_VIDEO_PRIMARY_SECONDARY,
CodingType.MPEG2_VIDEO_PRIMARY_SECONDARY,
CodingType.MPEG4_AVC_VIDEO_PRIMARY_SECONDARY,
CodingType.MPEG4_MVC_VIDEO_PRIMARY_SECONDARY,
CodingType.VC1_VIDEO_PRIMARY_SECONDARY
]:
self.data: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Data: {self.data}")
self.format: VideoFormat = VideoFormat((self.data & 0b11110000) >> 4)
self.logger.debug(f"Video Format: {self.format}")
self.rate: FrameRate = FrameRate(self.data & 0b00001111)
self.logger.debug(f"Frame Rate: {self.rate}")
elif self.coding_type in [
CodingType.HEVC_VIDEO_PRIMARY_SECONDARY
]:
self.data: int = read_u16(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Data: {self.data}")
self.format: VideoFormat = VideoFormat((self.data & 0b1111000000000000) >> 12)
self.logger.debug(f"Video Format: {self.format}")
self.rate: FrameRate = FrameRate((self.data & 0b0000111100000000) >> 8)
self.logger.debug(f"Frame Rate: {self.rate}")
self.dynamic_range_type: DynamicRangeType = DynamicRangeType((self.data & 0b11110000) >> 8)
self.logger.debug(f"Dynamic Range Type: {self.dynamic_range_type}")
self.color_space: ColorSpace = ColorSpace((self.data & 0b00001111))
self.logger.debug(f"Frame Rate: {self.color_space}")
elif self.coding_type in [
CodingType.MPEG1_AUDIO_PRIMARY_SECONDARY,
CodingType.MPEG2_AUDIO_PRIMARY_SECONDARY,
CodingType.LPCM_AUDIO_PRIMARY,
CodingType.DOLBY_DIGITAL_AUDIO_PRIMARY,
CodingType.DTS_AUDIO_PRIMARY,
CodingType.DOLBY_DIGITAL_TRUEHD_AUDIO_PRIMARY,
CodingType.DOLBY_DIGITAL_PLUS_AUDIO_PRIMARY,
CodingType.DTS_HD_HIGH_RESOLUTION_AUDIO_PRIMARY,
CodingType.DTS_HD_MASTER_AUDIO_AUDIO_PRIMARY,
CodingType.DOLBY_DIGITAL_PLUS_AUDIO_SECONDARY,
CodingType.DTS_HD_AUDIO_SECONDARY
]:
self.data: int = read_u8(f, endianess=Endianess.BIG_ENDIAN)
self.logger.debug(f"Data: {bin(self.data)}")
self.format: AudioFormat = AudioFormat((self.data & 0b11110000) >> 4)
self.logger.debug(f"Audio Format: {self.format}")
self.rate: SampleRate = SampleRate(self.data & 0b00001111)
self.logger.debug(f"Sample Rate: {self.rate}")
self.language: str = f.read(3).decode("ASCII")
self.logger.debug(f"Language Code: {self.language}")
elif self.coding_type in [
CodingType.PRESENTATION_GRAPHICS_SUBTITLES,
CodingType.INTERACTIVE_GRAPHICS_MENU
]:
self.language: str = f.read(3).decode("ASCII")
self.logger.debug(f"Language Code: {self.language}")
elif self.coding_type in [
CodingType.TEXT_SUBTITLES
]:
self.char_code: CharacterCode = CharacterCode(read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.debug(f"Character Code: {self.char_code}")
self.language: str = f.read(3).decode("ASCII")
self.logger.debug(f"Language Code: {self.language}")
self.logger.debug(f"Seeking to current_position + attributes_length")
self.seek(current_position + self.attributes_length)
def __init__(self, path: str, verify=True):
super().__init__(path, IRDHeader)
if self.version == 7:
self.id: str = read_u32(self.file_handle)
self.logger.debug(f"ID (v7 only): {self.id}")
#: ISO9660 Header Size
self.iso_header_size: int = read_u32(self.file_handle,
endianess=Endianess.LITTLE_ENDIAN)
self.logger.debug(f"Header Size: {self.iso_header_size}")
# TODO: Write ISO9660 Header Parser
#: ISO9660 Header
self.iso_header: bytes = zlib.decompress(
self.file_handle.read(self.iso_header_size), 15 + 16)
#: ISO9660 Footer Size
self.iso_footer_size: int = read_u32(self.file_handle,
endianess=Endianess.LITTLE_ENDIAN)
self.logger.debug(f"Footer Size: {self.iso_footer_size}")
# TODO: Write ISO9660 Footer Parser
#: ISO9660 Footer
self.iso_footer: IO = gzip.GzipFile(
fileobj=self.file_handle.read(self.iso_footer_size))
#: TODO: Document this!
self.region_count: int = read_u8(self.file_handle)
self.logger.debug(f"Region Count: {self.region_count}")
#: TODO: Document this!
self.region_hashes: List[bytes] = []
for i in range(0, self.region_count):
region_hash: bytes = self.file_handle.read(16)
self.region_hashes.append(region_hash)
self.logger.debug(f"Region {i} hash: {hexlify(region_hash)}")
#: Number of file hash entries
self.file_count: int = read_u32(self.file_handle,
endianess=Endianess.LITTLE_ENDIAN)
self.logger.debug(f"File Count: {self.file_count}")
#: File Key -> File Hash map
self.file_map: Dict[bytes, bytes] = {}
for i in range(0, self.file_count):
file_key: bytes = self.file_handle.read(8)
file_hash: bytes = self.file_handle.read(16)
self.file_map[file_key] = file_hash
self.logger.debug(
f"File {i}: {hexlify(file_key)} -> {hexlify(file_hash)}")
#: 4 byte padding
self.padding: bytes = self.file_handle.read(4)
if self.version >= 9:
#: See http://www.t10.org/ftp/t10/document.04/04-328r0.pdf#page=43
self.pic: bytes = self.file_handle.read(115)
self.logger.debug(f"PIC: {hexlify(self.pic).decode('ASCII')}")
#: Used to derive the disc AES encryption pkg_internal_fs_key
self.data1: bytes = self.file_handle.read(16)
#: TODO: Document this!
self.data2: bytes = self.file_handle.read(16)
#: Data2 Decrypted
self.data2_decrypted: bytes = IRD.decrypt_data2(self.data2)
#: Data2 Patched
self.data2_patched: bytes = IRD.patch_data2(self.data2)
self.logger.info(f"Data1: {hexlify(self.data1).decode('ASCII')}")
self.logger.info(f"Data2: {hexlify(self.data2).decode('ASCII')}")
self.logger.info(
f"Data2(decrypted): {hexlify(self.data2_decrypted).decode('ASCII')}"
)
self.logger.info(
f"Data2(patched): {hexlify(self.data2_patched).decode('ASCII')}")
if self.version < 9:
#: See http://www.t10.org/ftp/t10/document.04/04-328r0.pdf#page=43
self.pic: bytes = self.file_handle.read(115)
self.logger.debug(f"PIC: {hexlify(self.pic).decode('ASCII')}")
if self.version > 7:
#: TODO: Document this!
self.uid: str = read_u32(self.file_handle,
endianess=Endianess.LITTLE_ENDIAN)
self.logger.debug(f"UID: {self.uid}")
if verify and self.verify(self.file_handle):
self.logger.info(f"CRC Verified")
else:
raise InvalidIRDCRCException()
self.logger.info(f"File successfully parsed")
def __init__(self, f: IO):
super().__init__(f)
#: EDAT file format version
self.version: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.info(f"EDAT Version: {self.version}")
#: Licence Type
self.licence_type: LicenceType = LicenceType(read_u32(f, endianess=Endianess.BIG_ENDIAN))
self.logger.info(f"Licence Type: {self.licence_type}")
#: Application Type
self.application_type: ApplicationType = ApplicationType(read_u32(f, endianess=Endianess.BIG_ENDIAN))
self.logger.info(f"Application Type: {self.application_type}")
#: Content ID
self.content_id: str = f.read(0x30).decode('UTF-8')
self.logger.info(f"Content ID: {self.content_id}")
#: Digest
"""
(seems like to be a SHA-1 hash of the non-finalized file)
hash of the original data which is unknown until the whole
file is read, can not be used as check. Can be used as
watermark or zeroed on forged file.
"""
# TODO: Do hashcheck
self.qa_digest: bytearray = f.read(0x10)
self.logger.info(f"QA Digest: {hexlify(self.qa_digest)}")
#: NPD Hash 1
"""
CID-FN hash (an AES CMAC hash of concatenation of Content
ID and File Name using the third NPDRM OMAC pkg_internal_fs_key as CMAC pkg_internal_fs_key)
"""
# TODO: Do hashcheck
self.npd_hash_1: bytearray = f.read(0x10)
self.logger.info(f"NPD Hash 1: {hexlify(self.npd_hash_1)}")
#: NPD Hash 2
"""
header hash (an AES CMAC hash of the 0x60 bytes from the
beginning of file using xored bytes of the developer's
klicensee and the second NPDRM OMAC pkg_internal_fs_key as CMAC pkg_internal_fs_key)
"""
# TODO: Do hashcheck
self.npd_hash_2: bytearray = f.read(0x10)
self.logger.info(f"NPD Hash 2: {hexlify(self.npd_hash_2)}")
#: Activation Time (start of the validity period, filled with 0x00 if not used)
# TODO: Reverse date format
self.activation_time: bytearray = f.read(0x08)
self.logger.info(f"Activation Time: {hexlify(self.activation_time)}")
#: Deactivation Time (end of the validity period, filled with 0x00 if not used)
# TODO: Reverse date format
self.deactivation_time: bytearray = f.read(0x08)
self.logger.info(f"Deactivation Time: {hexlify(self.deactivation_time)}")
#: Npd Type
# TODO: (Separated from Metadata type for wiki format)
self.npd_type: NpdType = NpdType(read_u8(f, endianess=Endianess.BIG_ENDIAN))
self.logger.info(f"Npd Type: {self.npd_type}")
#: Metadata Type
# TODO: (Outdated Flags description from talk page)
self.metadata_type: MetadataType = MetadataType(
unpack_u32(bytes([0]) + f.read(0x03), endianess=Endianess.BIG_ENDIAN)
)
self.logger.info(f"Metadata Type: {self.metadata_type}")
#: Block Size
self.block_size: int = read_u32(f, endianess=Endianess.BIG_ENDIAN)
self.logger.info(f"Block Size: {self.block_size}")
if self.block_size > 0x8000:
raise InvalidEDATBlockSizeException()
#: Data Size
self.data_size: int = read_u64(f, endianess=Endianess.BIG_ENDIAN)
self.logger.info(f"Data Size: {self.data_size}")
#: Metadata Sections Hash
# TODO: Do hashcheck
self.metadata_sections_hash: bytearray = f.read(0x10)
self.logger.info(f"Metadata Sections Hash: {hexlify(self.metadata_sections_hash)}")
#: Extended Header Hash
"""
An AES CMAC hash of 160 bytes from the beginning of file)
uses the hash pkg_internal_fs_key as CMAC pkg_internal_fs_key and it depends on the file
flags and keys
"""
# TODO: Do hashcheck
self.extended_header_hash: bytearray = f.read(0x10)
self.logger.info(f"Extended Header Hash: {hexlify(self.extended_header_hash)}")
#: ECDSA Metadata Signature
"""
Can be zeroed on forged file. curve_type is vsh type 0x02,
pub is vsh public pkg_internal_fs_key,
"""
# TODO: Do hashcheck
self.ecdsa_metadata_signature: bytearray = f.read(0x28)
self.logger.info(f"Extended Header Hash: {hexlify(self.ecdsa_metadata_signature)}")
#: ECDSA Header Signature
"""
Enabled (only?) for PS2 classic: all custom firmwares are
patched to skip the ECDSA check. Can be zeroed on forged file.
curve_type is vsh type 0x02, pub is vsh public pkg_internal_fs_key.
"""
# TODO: Do hashcheck
self.ecdsa_header_signature: bytearray = f.read(0x28)
self.logger.info(f"ECDSA Header Signature: {hexlify(self.ecdsa_header_signature)}")
