def decrypt_com2us_png():
com2us_decrypt_values = [
0x2f, 0x7c, 0x47, 0x55, 0x32, 0x77, 0x9f, 0xfb, 0x5b, 0x86, 0xfe, 0xb6,
0x3e, 0x06, 0xf4, 0xc4, 0x2e, 0x08, 0x49, 0x11, 0x0e, 0xce, 0x84, 0xd3,
0x7b, 0x18, 0xa6, 0x5c, 0x71, 0x56, 0xe2, 0x3b, 0xfd, 0xb3, 0x2b, 0x97,
0x9d, 0xfc, 0xca, 0xba, 0x8e, 0x7e, 0x6f, 0x0f, 0xe8, 0xbb, 0xc7, 0xc2,
0xd9, 0xa4, 0xd2, 0xe0, 0xa5, 0x95, 0xee, 0xab, 0xf3, 0xe4, 0xcb, 0x63,
0x25, 0x70, 0x4e, 0x8d, 0x21, 0x37, 0x9a, 0xb0, 0xbc, 0xc6, 0x48, 0x3f,
0x23, 0x80, 0x20, 0x01, 0xd7, 0xf9, 0x5e, 0xec, 0x16, 0xd6, 0xd4, 0x1f,
0x51, 0x42, 0x6c, 0x10, 0x14, 0xb7, 0xcc, 0x82, 0x7f, 0x13, 0x02, 0x00,
0x72, 0xed, 0x90, 0x57, 0xc1, 0x2c, 0x5d, 0x28, 0x81, 0x1d, 0x38, 0x1a,
0xac, 0xad, 0x35, 0x78, 0xdc, 0x68, 0xb9, 0x8b, 0x6a, 0xe1, 0xc3, 0xe3,
0xdb, 0x6d, 0x04, 0x27, 0x9c, 0x64, 0x5a, 0x8f, 0x83, 0x0c, 0xd8, 0xa8,
0x1c, 0x89, 0xd5, 0x43, 0x74, 0x73, 0x4d, 0xae, 0xea, 0x31, 0x6e, 0x1e,
0x91, 0x1b, 0x59, 0xc9, 0xbd, 0xf7, 0x07, 0xe7, 0x8a, 0x05, 0x8c, 0x4c,
0xbe, 0xc5, 0xdf, 0xe5, 0xf5, 0x2d, 0x4b, 0x76, 0x66, 0xf2, 0x50, 0xd0,
0xb4, 0x85, 0xef, 0xb5, 0x3c, 0x7d, 0x3d, 0xe6, 0x9b, 0x03, 0x0d, 0x61,
0x33, 0xf1, 0x92, 0x53, 0xff, 0x96, 0x09, 0x67, 0x69, 0x44, 0xa3, 0x4a,
0xaf, 0x41, 0xda, 0x54, 0x46, 0xd1, 0xfa, 0xcd, 0x24, 0xaa, 0x88, 0xa7,
0x19, 0xde, 0x40, 0xeb, 0x94, 0x5f, 0x45, 0x65, 0xf0, 0xb8, 0x34, 0xdd,
0x0b, 0xb1, 0x29, 0xe9, 0x2a, 0x75, 0x87, 0x39, 0xcf, 0x79, 0x93, 0xa1,
0xb2, 0x30, 0x15, 0x7a, 0x52, 0x12, 0x62, 0x36, 0xbf, 0x22, 0x4f, 0xc0,
0xa2, 0x17, 0xc8, 0x99, 0x3a, 0x60, 0xa9, 0xa0, 0x58, 0xf6, 0x0a, 0x9e,
0xf8, 0x6b, 0x26, 0x98
]
for im_path in iglob('herders/static/herders/images/**/*.png',
recursive=True):
encrypted = BitStream(filename=im_path)
# Check if it is encrypted. 8th byte is 0x0B instead of the correct signature 0x0A
encrypted.pos = 0x07 * 8
signature = encrypted.peek('uint:8')
if signature == 0x0B:
print('Decrypting {}'.format(im_path))
# Correct the PNG signature
encrypted.overwrite('0x0A', encrypted.pos)
# Replace bits with magic decrypted values
try:
while True:
pos = encrypted.pos
val = encrypted.peek('uint:8')
encrypted.overwrite(
Bits(uint=com2us_decrypt_values[val], length=8), pos)
except ReadError:
# EOF
pass
# Write it back to the file
with open(im_path, 'wb') as f:
encrypted.tofile(f)
def decrypt_images(**kwargs):
path = kwargs.pop('path', 'herders/static/herders/images')
for im_path in iglob(f'{path}/**/*.png', recursive=True):
encrypted = BitStream(filename=im_path)
# Check if it is 'encrypted'. 8th byte is 0x0B instead of the correct signature 0x0A
encrypted.pos = 0x07 * 8
signature = encrypted.peek('uint:8')
if signature == 0x0B:
print(f'Decrypting {im_path}')
# Correct the PNG signature
encrypted.overwrite('0x0A', encrypted.pos)
# Replace bits with magic decrypted values
try:
while True:
pos = encrypted.pos
val = encrypted.peek('uint:8')
encrypted.overwrite(
Bits(uint=com2us_decrypt_values[val], length=8), pos)
except ReadError:
# EOF
pass
# Write it back to the file
with open(im_path, 'wb') as f:
encrypted.tofile(f)
continue
# Check for weird jpeg format with extra header junk. Convert to png.
encrypted.pos = 0
if encrypted.peek('bytes:5') == b'Joker':
print(f'Converting Joker container JPEG to PNG {im_path}')
with open(im_path, 'rb') as f:
img = JokerContainerFile(f)
# Open it as a jpg and resave to disk
try:
new_imfile = Image.open(io.BytesIO(img.data.tobytes()))
new_imfile.save(im_path)
except IOError:
print(f'Unable to open {im_path}')
class Serializer(object):
"""
Class for serialize and de-serialize messages.
"""
def __init__(self):
"""
Initialize a Serializer.
"""
self._reader = None
self._writer = None
def deserialize(self, raw, host, port):
"""
De-serialize a stream of byte to a message.
:param raw: received bytes
:param host: source host
:param port: source port
:return: the message
"""
self._reader = BitStream(bytes=raw, length=(len(raw) * 8))
version = self._reader.read(defines.VERSION_BITS).uint
message_type = self._reader.read(defines.TYPE_BITS).uint
token_length = self._reader.read(defines.TOKEN_LENGTH_BITS).uint
code = self._reader.read(defines.CODE_BITS).uint
mid = self._reader.read(defines.MESSAGE_ID_BITS).uint
if self.is_response(code):
message = Response()
message.code = code
elif self.is_request(code):
message = Request()
message.code = code
else:
message = Message()
message.source = (host, port)
message.destination = None
message.version = version
message.type = message_type
message.mid = mid
if token_length > 0:
message.token = self._reader.read(token_length * 8).bytes
else:
message.token = None
current_option = 0
try:
while self._reader.pos < self._reader.len:
next_byte = self._reader.peek(8).uint
if next_byte != int(defines.PAYLOAD_MARKER):
# the first 4 bits of the byte represent the option delta
delta = self._reader.read(4).uint
# the second 4 bits represent the option length
length = self._reader.read(4).uint
current_option += self.read_option_value_from_nibble(delta)
option_length = self.read_option_value_from_nibble(length)
# read option
try:
option_name, option_type, option_repeatable, default = defines.options[current_option]
except KeyError:
log.err("unrecognized option")
return message, "BAD_OPTION"
if option_length == 0:
value = None
elif option_type == defines.INTEGER:
value = self._reader.read(option_length * 8).uint
else:
value = self._reader.read(option_length * 8).bytes
option = Option()
option.number = current_option
option.value = self.convert_to_raw(current_option, value, option_length)
message.add_option(option)
else:
self._reader.pos += 8 # skip payload marker
if self._reader.len <= self._reader.pos:
log.err("Payload Marker with no payload")
return message, "BAD_REQUEST"
to_end = self._reader.len - self._reader.pos
message.payload = self._reader.read(to_end).bytes
return message
except ReadError, e:
log.err("Error parsing message: " + str(e))
return None
class CoreSightProtocol(Thread):
def __init__(self, avatar, origin):
self.avatar = avatar
self._avatar_queue = avatar.queue
self._avatar_fast_queue = avatar.fast_queue
self._origin = origin
self.trace_queue = None
self.trace_buffer = BitStream()
self._close = Event()
self._closed = Event()
self._close.clear()
self._closed.clear()
self._sync_responses_cv = Condition()
self._last_exec_token = 0
# logger = logging.getLogger('%s.%s' %
# (origin.log.name, self.__class__.__name__)
# ) if origin else \
# logging.getLogger(self.__class__.__name__)
self._monitor_stub_base = None
self._monitor_stub_isr = None
self._monitor_stub_loop = None
self._monitor_stub_writeme = None
Thread.__init__(self)
self.daemon = True
def __del__(self):
self.shutdown()
def inject_interrupt(self, interrupt_number, cpu_number=0):
# Set an interrupt using the STIR
self._origin.write_memory(SCB_STIR, 4, interrupt_number)
def enable_interrupt(self, interrupt_number):
"""
Enables an interrupt (e.g., in the NIVC)
:param interrupt_number:
:return:
"""
assert (0 < interrupt_number < 256)
iser_num = interrupt_number >> 5
iser_addr = NVIC_ISER0 + (iser_num * 4)
# iser_off = interrupt_number % 32
# iser_val = self._origin.read_memory(iser_addr, 4)
iser_val = ((1 << interrupt_number) & 0x1F)
# iser_val |= 0x1 << iser_off
self._origin.write_memory(iser_addr, 4, iser_val)
def get_vtor(self):
return self._origin.read_memory(SCB_VTOR, 4)
def get_ivt_addr(self):
if getattr(self._origin, 'ivt_address', None) is not None:
return self._origin.ivt_address
else:
return self.get_vtor()
def set_vtor(self, addr):
return self._origin.write_memory(SCB_VTOR, 4, addr)
def get_isr(self, interrupt_num):
return self._origin.read_memory(
self.get_ivt_addr() + (interrupt_num * 4), 4)
def set_isr(self, interrupt_num, addr):
return self._origin.write_memory(
self.get_ivt_addr() + (interrupt_num * 4), 4, addr)
def cpuid(self):
c = self._origin.read_memory(SCB_CPUID, 4, 1)
print("CPUID: %#08x" % c)
if (0x412fc230 & 0x000f0000) >> 16 == 0xf:
print("Found ARM Cortex CPUID")
else:
return
impl = (c >> 24)
vari = (c & 0x00f00000) >> 20
part = (c & 0x0000fff0) >> 4
rev = (c & 0x0000000f)
print("Implementer %#08x, Variant %#08x, Part %#08x, Rev %#08x" %
(impl, vari, part, rev))
def shutdown(self):
if self.is_alive() is True:
self.stop()
def connect(self):
if not isinstance(self._origin.protocols.monitor, OpenOCDProtocol):
raise Exception(("CoreSightProtocol requires OpenOCDProtocol "
)("to be present."))
def has_bits_to_read(self, b, n):
return b.len - b.pos > n
def enable_interrupts(self, use_tcl_tracing=False, use_stub=True):
try:
logger.info("Starting CoreSight Protocol")
if not isinstance(self._origin.protocols.monitor, OpenOCDProtocol):
raise Exception(
"CoreSightProtocol requires OpenOCDProtocol to be present."
)
openocd = self._origin.protocols.monitor
logger.debug("Resetting target")
openocd.reset()
if use_tcl_tracing:
# Enable TCL tracing
if not openocd.trace_enabled.is_set():
openocd.enable_trace()
if not openocd.trace_enabled.is_set():
logger.error(
"Can't get trace events without tcl_trace! aborting..."
)
return False
self.trace_queue = openocd.trace_queue
# Enable the TPIO output to the FIFO
logger.debug("Enabling TPIU output events")
openocd.execute_command(
'tpiu config internal - uart off 32000000')
# Enable the DWT to get interrupts
logger.debug("Enabling exceptions in DWT")
openocd.execute_command(
"setbits $COREDEBUG_DEMCR 0x1000000"
) # Enable access to trace regs - set TRCENA to 1
openocd.execute_command(
"mww $DWT_CTRL 0x40010000") # exc trace only
logger.debug("Enabling ITM passthrough of DWT events")
# Enable the ITM to pass DWT output to the TPIU
openocd.execute_command("mww $ITM_LAR 0xC5ACCE55")
openocd.execute_command("mww $ITM_TCR 0x0000000d"
) # TraceBusID 1, enable dwt/itm/sync
openocd.execute_command(
"mww $ITM_TER 0xffffffff") # Enable all stimulus ports
# Run our little daemon thingy
logger.debug("Starting interrupt handling thread")
self.daemon = True
self.start()
elif use_stub:
self.inject_monitor_stub()
except:
logger.exception("Error starting Coresight")
"""
What this does:
Hang in a loop at `loop`
When an interrupt comes, go to `stub`
At `stub`, load `writeme`, if it's not zero, reset it, and jump to the written value.
This lets us inject exc_return values into the running program
"""
# MONITOR_STUB = """
# loop: b loop
# nop
# mov r2, pc
# ldr r1, [r2, #16]
# stub:
# ldr r0, [r2, #12]
# cmp r1, r0
# beq stub
# str r1, [r2, #12]
# bx r0
# nop
# writeme: .word 0xffffffff
# loadme: .word 0xffffffff
# """
# str r2, [r1]
MONITOR_STUB = """
dcscr: .word 0xe000edf0
haltme: .word 0xA05F0003
writeme: .word 0x00000000
init:
ldr r1, =dcscr
ldr r2, =haltme
ldr r3, =writeme
ldr r1, [r1]
ldr r2, [r2]
loop: b loop
stub:
nop
intloop:
ldr r4, [r3]
cmp r4, #0
beq intloop
ldr r4, #0
str r4, [r3]
bx lr
"""
def get_user_pc(self):
"""
Return the "user PC", that is, the PC at the time an interrupt occurred.
Returns None if we're not in an interrupt right now.
:return:
"""
if self.get_current_isr_num() > 0:
sp = self._origin.get_register('sp')
val = self._origin.read_memory(sp - 24)
return val
return None
def get_current_isr_num(self):
"""
If we're in an interrupt, return the current ISR number that we're in.
:return:
"""
# The bottom 8 bits of xPSR
xpsr = self._origin.read_register("xPSR")
xpsr &= 0xff
return xpsr
def inject_monitor_stub(self, addr=0x20001234, vtor=0x20002000):
"""
Injects a safe monitoring stub.
This has the following effects:
0. Pivot the VTOR to someplace sane
1. Insert an infinite loop at addr
2. Set the PC to addr
3. set up logic for the injection of interrupt returns.
Write to return_code_register to trigger an IRET
4.
:return:
"""
logger.info("Injecting monitor stub. (IVT: %s, %s, %s)"
")" % (self.get_ivt_addr(), self.get_vtor(), vtor))
self._monitor_stub_base = addr
self._monitor_stub_loop = addr + 12
self._monitor_stub_isr = addr + 25
self._monitor_stub_writeme = addr + 8
# Pivot VTOR, if needed
# On CM0, you can't, so don't.
if getattr(self._origin, 'ivt_address', None) is None:
if self.get_vtor() == 0:
self.set_vtor(vtor)
# Sometimes, we need to gain access to the IVT (make it writable). Do that here.
if getattr(self._origin, 'ivt_unlock', None) is not None:
unlock_addr, unlock_val = self._origin.ivt_unlock
self._origin.write_memory(unlock_addr, 4, unlock_val)
# put the stub
self._origin.inject_asm(self.MONITOR_STUB, self._monitor_stub_base)
# wreck the IVT
# ...oh but don't wipe out the 0'th position.
for x in range(1, 254):
self.set_isr(x, self._monitor_stub_isr)
if self._origin.state != TargetStates.STOPPED:
logger.warning(
"Not setting PC to the monitor stub; Target not stopped")
else:
self._origin.regs.pc = self._monitor_stub_loop
def inject_exc_return(self, exc_return):
if not self._monitor_stub_base:
logger.error(
"You need to inject the monitor stub before you can inject exc_returns"
)
return False
# We can just BX LR for now.
return self._origin.write_memory(self._monitor_stub_writeme, 4, 1)
def dispatch_exception_packet(self, packet):
int_num = ((ord(packet[1]) & 0x01) << 8) | ord(packet[0])
transition_type = (ord(packet[1]) & 0x30) >> 4
msg = RemoteInterruptEnterMessage(self._origin, transition_type,
int_num)
self._avatar_fast_queue.put(msg)
def run(self):
DWT_PKTSIZE_BITS = 24
trace_re = re.compile("type target_trace data ([0-9a-f]+)")
logger.debug("Starting interrupt thread")
try:
while not self._close.is_set():
if self._close.is_set():
break
# OpenOCD gives us target_trace events packed with many, many packets.
# Get them out, then do them packet-at-a-time
if not self.has_bits_to_read(self.trace_buffer,
DWT_PKTSIZE_BITS):
# get some more data
if self.trace_queue.empty():
# make sure we can see the shutdown flag
continue
new_data = self.trace_queue.get()
m = trace_re.match(new_data)
if m:
self.trace_buffer.append("0x" + m.group(1))
else:
raise ValueError("Got a really weird trace packet " +
new_data)
if not self.has_bits_to_read(self.trace_buffer,
DWT_PKTSIZE_BITS):
continue
try:
pkt = self.trace_buffer.peek(DWT_PKTSIZE_BITS).bytes
except ReadError:
logger.error("F**k you length is " +
repr(len(self.trace_buffer)) + " " +
repr(DWT_PKTSIZE_BITS))
if ord(pkt[0]) == 0x0E: # exception packets
pkt = pkt[1:]
self.dispatch_exception_packet(pkt)
# eat the bytes
self.trace_buffer.read(DWT_PKTSIZE_BITS)
# the first byte didn't match, rotate it out
else:
self.trace_buffer.read(8)
except:
logger.exception("Error processing trace")
self._closed.set()
logger.debug("Interrupt thread exiting...")
def stop(self):
"""Stops the listening thread. Useful for teardown of the target"""
self._close.set()
self._closed.wait()
def main():
"""
"""
if args.infile == args.outfile :
print ('Error! Source and Destination can not be the same file!')
sys.exit()
if not os.path.exists(args.infile) :
print ('Error! Given input file name not found! Please check path given in CMD or set in script code!')
sys.exit()
if md_arg_str :
md = re.findall('\d+',md_arg_str)
if len(md) != 10 :
print ('Specified wrong "-masterdisplay" parameter! Please check!\n Example: G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1) or do not specify')
sys.exit()
if maxcll :
mcll = re.findall('\d+',maxcll)
sei_ok = 0
F = open (args.infile,'r+b')
o = open (args.outfile,'wb')
print ('Parsing the infile:')
print ('')
print ('==========================')
print ('')
print ('Prepending SEI data')
s = BitStream(F.read(chunk))
nals = list(s.findall('0x000001', bytealigned=True))
sps_nals = list(s.findall('0x00000142', bytealigned=True))
sei_pref_nals = list (s.findall('0x0000014e', bytealigned=True))
size = [y - x for x,y in zip(nals,nals[1:])]
sps_pos = list(set(nals).intersection(sps_nals))
sei_pref_nals_pos = list(set(nals).intersection(sei_pref_nals))
sps_size = size[nals.index(sps_nals[0])]
if sei_pref_nals :
sei_pref_nal_size = ( size[nals.index(sei_pref_nals[0])])
### MAXCLL & MAXFALL ###
if args.maxcll or md_arg_str :
sei_forbidden_zero_bit = 0
sei_nal_unit_type = 39
sei_nuh_layer_id = 0
sei_nuh_temporal_id_plus1 = 1
new_sei_string = pack ('uint:1,2*uint:6,uint:3',sei_forbidden_zero_bit,sei_nal_unit_type,sei_nuh_layer_id,sei_nuh_temporal_id_plus1)
print ('Starting new SEI NALu...')
if maxcll :
sei_last_payload_type_byte = 144
sei_last_payload_size_byte = 4
sei_max_content_light_level = int(mcll[0])
sei_max_pic_average_light_level = int(mcll[1])
new_sei_string += pack ('2*uint:8,2*uint:16',sei_last_payload_type_byte,sei_last_payload_size_byte,sei_max_content_light_level,sei_max_pic_average_light_level)
print ('SEI message with MaxCLL=',sei_max_content_light_level,' and MaxFall=',sei_max_pic_average_light_level,' created in SEI NAL')
if md_arg_str :
md_sei_last_payload_type_byte = 137
md_sei_last_payload_size_byte = 24
#MD string ref
#G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,1)
new_sei_string += pack ('2*uint:8',md_sei_last_payload_type_byte,md_sei_last_payload_size_byte)
for i in range (len(md)-2) :
new_sei_string += pack ('uint:16',int(md[i]))
new_sei_string += pack ('uint:32',int(md[8]))
new_sei_string += pack ('uint:32',int(md[9]))
new_sei_string.replace ('0x0000','0x000003',bytealigned=True)
print ('SEI message Mastering Display Data',md_arg_str,'created in SEI NAL')
new_sei_string = '0x00000001' + new_sei_string + '0x00'
sei_ok = True
### ------------------ ###
print ('Looking for SPS.........', sps_pos)
print ('SPS_Nals_addresses', sps_pos)
print ('SPS NAL Size', sps_size)
print ('Starting reading SPS NAL contents')
s.pos = sps_pos[0]
t = s.peek(sps_size)
t.pos = t.pos + 24
forbidden_zero_bit = t.read('uint:1')
nal_unit_type = t.read('uint:6')
nuh_layer_id = t.read('uint:6')
nuh_temporal_id_plus1 = t.read('uint:3')
nal_t = t[:]
# 7.3.1.1
# Convert NAL data (Annex B format) to RBSP data
t.tobytes()
t.replace ('0x000003','0x0000')
# SPS parse block
sps_video_parameter_set_id = t.read('uint:4')
sps_max_sub_layers_minus1 = t.read('uint:3')
sps_temporal_id_nesting_flag = t.read('uint:1')
ptl = profile_tier_level(t, sps_max_sub_layers_minus1)
sps_seq_parameter_set_id = t.read('ue')
chroma_format_idc = t.read('ue')
if chroma_format_idc == 3:
separate_colour_plane_flag = t.read('uint:1')
pic_width_in_luma_samples = t.read ('ue')
pic_height_in_luma_samples = t.read ('ue')
conformance_window_flag = t.read ('uint:1')
if (conformance_window_flag) :
conf_win_left_offset = t.read('ue')
conf_win_right_offset = t.read('ue')
conf_win_top_offset = t.read('ue')
conf_win_bottom_offset = t.read('ue')
bit_depth_luma_minus8 = t.read ('ue')
bit_depth_chroma_minus8 = t.read ('ue')
log2_max_pic_order_cnt_lsb_minus4 = t.read('ue')
sps_sub_layer_ordering_info_present_flag = t.read('uint:1')
# for (i = (sps_sub_layer_ordering_info_present_flag ? 0 : sps.max_sub_layers_minus1); i <= sps.max_sub_layers_minus1; i++)
if sps_sub_layer_ordering_info_present_flag :
sps_max_dec_pic_buffering_minus1 = t.read('ue')
sps_max_num_reorder_pics = t.read('ue')
sps_max_latency_increase_plus1 = t.read('ue')
log2_min_luma_coding_block_size_minus3 = t.read ('ue')
log2_diff_max_min_luma_coding_block_size = t.read ('ue')
log2_min_luma_transform_block_size_minus2 = t.read ('ue')
log2_diff_max_min_luma_transform_block_size = t.read ('ue')
max_transform_hierarchy_depth_inter = t.read ('ue')
max_transform_hierarchy_depth_intra = t.read ('ue')
scaling_list_enabled_flag = t.read ('uint:1')
"""
if( scaling_list_enabled_flag ) {
sps_scaling_list_data_present_flag u(1)
if( sps_scaling_list_data_present_flag )
scaling_list_data( )
}
"""
amp_enabled_flag = t.read ('uint:1')
sample_adaptive_offset_enabled_flag = t.read ('uint:1')
pcm_enabled_flag = t.read ('uint:1')
if pcm_enabled_flag :
pcm_sample_bit_depth_luma_minus1 = t.read ('uint:4')
pcm_sample_bit_depth_chroma_minus1 = t.read ('uint:4')
log2_min_pcm_luma_coding_block_size_minus3 = t.read ('ue')
log2_diff_max_min_pcm_luma_coding_block_size = t.read ('ue')
pcm_loop_filter_disabled_flag = t.read ('uint:1')
num_short_term_ref_pic_sets = t.read ('ue')
if num_short_term_ref_pic_sets :
for i in range (num_short_term_ref_pic_sets):
if i != 0 :
inter_ref_pic_set_prediction_flag = t.read ('uint:1')
if not 'inter_ref_pic_set_prediction_flag' in globals() :
"""
if i == num_short_term_ref_pic_sets :
delta_idx_minus1 = t.read ('ue')
if not 'delta_idx_minus1' in globals():
delta_idx_minus1 = 0
delta_rps_sign = t.read ('uint:1')
abs_delta_rps_minus1 = t.read ('ue')
for j in range (NumDeltaPoc) :
used_by_curr_pic_flag[j] = t.read ('uint:1')
if used_by_curr_pic_flag[j] :
use_delta_flag[j] = t.read ('uint:1')
else:
"""
num_negative_pics = t.read ('ue')
num_positive_pics = t.read ('ue')
delta_poc_s0_minus1 = [t.read ('ue') for _ in range (num_negative_pics)]
used_by_curr_pic_s0_flag = [ t.read ('uint:1') for _ in range (num_negative_pics)]
delta_poc_s1_minus1 = [t.read ('ue') for _ in range(num_positive_pics)]
used_by_curr_pic_s1_flag = [t.read ('uint:1') for _ in range(num_positive_pics)]
long_term_ref_pics_present_flag = t.read ('uint:1')
if long_term_ref_pics_present_flag :
num_long_term_ref_pics_sps = t.read ('ue')
for i in range < (num_long_term_ref_pics_sps):
lt_ref_pic_poc_lsb_sps[i] = t.read ('ue')
used_by_curr_pic_lt_sps_flag[i] = t.read ('uint:1')
sps_temporal_mvp_enabled_flag = t.read ('uint:1')
strong_intra_smoothing_enabled_flag = t.read ('uint:1')
vui_parameters_present_flag = t.read ('uint:1')
if vui_parameters_present_flag :
vp = vui_parameters(t)
sps_extension_present_flag = t.read ('uint:1')
if sps_extension_present_flag :
sps_range_extension_flag = t.read ('uint:1')
sps_multilayer_extension_flag = t.read ('uint:1')
sps_3d_extension_flag = t.read ('uint:1')
sps_extension_5bits = t.read ('uint:1')
tb = rbsp_trailing_bits(t,len(t))
print ('Reading of SPS NAL finished. Read ',len(t),' of SPS NALu data.\n')
# print block
"""
print ('sps_video_parameter_set_id', sps_video_parameter_set_id)
print ('sps_max_sub_layers_minus1', sps_max_sub_layers_minus1)
print ('sps_temporal_id_nesting_flag', sps_temporal_id_nesting_flag)
ptl.show()
print ('sps_seq_parameter_set_id', sps_seq_parameter_set_id)
print ('chroma_format_idc', chroma_format_idc)
if chroma_format_idc == 3:
print ('separate_colour_plane_flag', separate_colour_plane_flag)
print ('pic_width_in_luma_samples ', pic_width_in_luma_samples) #produces wrong number
print ('pic_height_in_luma_samples', pic_height_in_luma_samples) #produces wrong number
print ('conformance_window_flag', conformance_window_flag)
print ('bit_depth_luma_minus8', bit_depth_luma_minus8)
print ('bit_depth_chroma_minus8', bit_depth_chroma_minus8)
print ('log2_max_pic_order_cnt_lsb_minus4', log2_max_pic_order_cnt_lsb_minus4)
print ('sps_sub_layer_ordering_info_present_flag', sps_sub_layer_ordering_info_present_flag)
if sps_sub_layer_ordering_info_present_flag :
print ('sps_max_dec_pic_buffering_minus1', sps_max_dec_pic_buffering_minus1)
print ('sps_max_num_reorder_pics', sps_max_num_reorder_pics)
print ('sps_max_latency_increase_plus1', sps_max_latency_increase_plus1)
print ('log2_min_luma_coding_block_size_minus3',log2_min_luma_coding_block_size_minus3)
print ('log2_diff_max_min_luma_coding_block_size',log2_diff_max_min_luma_coding_block_size)
print ('log2_min_luma_transform_block_size_minus2',log2_min_luma_transform_block_size_minus2)
print ('log2_diff_max_min_luma_transform_block_size', log2_diff_max_min_luma_transform_block_size)
print ('max_transform_hierarchy_depth_inter', max_transform_hierarchy_depth_inter)
print ('max_transform_hierarchy_depth_intra', max_transform_hierarchy_depth_intra)
print ('scaling_list_enabled_flag',scaling_list_enabled_flag)
print ('amp_enabled_flag',amp_enabled_flag)
print ('sample_adaptive_offset_enabled_flag',sample_adaptive_offset_enabled_flag)
print ('pcm_enabled_flag',pcm_enabled_flag)
if pcm_enabled_flag :
print ('pcm_sample_bit_depth_luma_minus1',pcm_sample_bit_depth_luma_minus1)
print ('pcm_sample_bit_depth_chroma_minus1',pcm_sample_bit_depth_chroma_minus1)
print ('log2_min_pcm_luma_coding_block_size_minus3',log2_min_pcm_luma_coding_block_size_minus3)
print ('log2_diff_max_min_pcm_luma_coding_block_size',log2_diff_max_min_pcm_luma_coding_block_size)
print ('pcm_loop_filter_disabled_flag',pcm_loop_filter_disabled_flag)
print ('num_short_term_ref_pic_sets',num_short_term_ref_pic_sets)
print ('long_term_ref_pics_present_flag',long_term_ref_pics_present_flag)
print ('sps_temporal_mvp_enabled_flag',sps_temporal_mvp_enabled_flag)
print ('strong_intra_smoothing_enabled_flag',strong_intra_smoothing_enabled_flag)
print ('vui_parameters_present_flag',vui_parameters_present_flag)
if vui_parameters_present_flag :
vp.show()
print ('sps_extension_present_flag',sps_extension_present_flag)
"""
# New BS write Block
print ('Making modified SPS NALu...')
new_bs = BitStream()
new_bs += pack('uint:4,uint:3,uint:1',sps_video_parameter_set_id,sps_max_sub_layers_minus1,sps_temporal_id_nesting_flag)
new_bs += pack ('uint:2,uint:1,uint:5',ptl.general_profile_space, ptl.general_tier_flag,ptl.general_profile_idc)
for i in range (32) :
new_bs += pack('uint:1',int(ptl.general_profile_compatibility_flag[i]))
new_bs += pack ('uint:1',ptl.general_progressive_source_flag)
new_bs += pack ('uint:1',ptl.general_interlaced_source_flag)
new_bs += pack ('uint:1',ptl.general_non_packed_constraint_flag)
new_bs += pack ('uint:1',ptl.general_frame_only_constraint_flag)
new_bs += pack ('uint:44',ptl.general_reserved_zero_44bits)
new_bs += pack ('uint:8',ptl.general_level_idc)
new_bs += pack ('ue',sps_seq_parameter_set_id)
new_bs += pack ('ue',chroma_format_idc)
if chroma_format_idc == 3:
new_bs += pack ('uint:1',separate_colour_plane_flag)
new_bs += pack ('ue',pic_width_in_luma_samples)
new_bs += pack ('ue',pic_height_in_luma_samples)
new_bs += pack ('uint:1',conformance_window_flag)
if (conformance_window_flag) :
new_bs += pack ('ue',conf_win_left_offset)
new_bs += pack ('ue',conf_win_right_offset)
new_bs += pack ('ue',conf_win_top_offset)
new_bs += pack ('ue',conf_win_bottom_offset)
new_bs += pack ('ue',bit_depth_luma_minus8)
new_bs += pack ('ue',bit_depth_chroma_minus8)
new_bs += pack ('ue',log2_max_pic_order_cnt_lsb_minus4)
new_bs += pack ('uint:1',sps_sub_layer_ordering_info_present_flag)
# for (i = (sps_sub_layer_ordering_info_present_flag ? 0 : sps.max_sub_layers_minus1); i <= sps.max_sub_layers_minus1; i++)
if sps_sub_layer_ordering_info_present_flag :
new_bs += pack ('ue',sps_max_dec_pic_buffering_minus1)
new_bs += pack ('ue',sps_max_num_reorder_pics)
new_bs += pack ('ue',sps_max_latency_increase_plus1)
new_bs += pack ('ue',log2_min_luma_coding_block_size_minus3)
new_bs += pack ('ue',log2_diff_max_min_luma_coding_block_size)
new_bs += pack ('ue',log2_min_luma_transform_block_size_minus2)
new_bs += pack ('ue',log2_diff_max_min_luma_transform_block_size)
new_bs += pack ('ue',max_transform_hierarchy_depth_inter)
new_bs += pack ('ue',max_transform_hierarchy_depth_intra)
new_bs += pack ('uint:1',scaling_list_enabled_flag)
#
new_bs += pack ('uint:1',amp_enabled_flag)
new_bs += pack ('uint:1',sample_adaptive_offset_enabled_flag)
new_bs += pack ('uint:1',pcm_enabled_flag)
if pcm_enabled_flag :
new_bs += pack ('uint:4',pcm_sample_bit_depth_luma_minus1)
new_bs += pack ('uint:4',pcm_sample_bit_depth_chroma_minus1)
new_bs += pack ('ue',log2_min_pcm_luma_coding_block_size_minus3)
new_bs += pack ('ue',log2_diff_max_min_pcm_luma_coding_block_size)
new_bs += pack ('uint:1',pcm_loop_filter_disabled_flag)
new_bs += pack ('ue',num_short_term_ref_pic_sets)
if num_short_term_ref_pic_sets :
for i in range (num_short_term_ref_pic_sets) :
if i != 0 :
new_bs += pack ('uint:1',inter_ref_pic_set_prediction_flag)
if not 'inter_ref_pic_set_prediction_flag' in globals() :
"""
if i == num_short_term_ref_pic_sets :
new_bs += pack ('ue',delta_idx_minus1)
new_bs += pack ('uint:1', delta_rps_sign)
new_bs += pack ('ue',abs_delta_rps_minus1)
for j in range (NumDeltaPocs[i - (delta_idx_minus1 +1)]) :
new_bs += pack ('uint:1', used_by_curr_pic_flag[j])
if used_by_curr_pic_flag[j] :
new_bs += pack ('uint:1',use_delta_flag[j])
else :
"""
new_bs += pack ('ue',num_negative_pics)
new_bs += pack ('ue',num_positive_pics)
new_bs += [pack ('ue',delta_poc_s0_minus1[_]) for _ in range (num_negative_pics)]
new_bs += [pack ('uint:1',used_by_curr_pic_s0_flag[_]) for _ in range (num_negative_pics)]
new_bs += [pack ('ue',delta_poc_s1_minus1[_]) for _ in range(num_positive_pics)]
new_bs += [pack ('uint:1',used_by_curr_pic_s1_flag[_]) for _ in range(num_positive_pics)]
new_bs += pack ('uint:1',long_term_ref_pics_present_flag)
if long_term_ref_pics_present_flag :
new_bs += pack ('ue',num_long_term_ref_pics_sps)
new_bs += pack ('uint:1',sps_temporal_mvp_enabled_flag)
new_bs += pack ('uint:1',strong_intra_smoothing_enabled_flag)
new_bs += pack ('uint:1',vui_parameters_present_flag)
# VUI VP pack Section
if vui_parameters_present_flag :
new_bs += pack ('uint:1',vp.aspect_ratio_info_present_flag)
if vp.aspect_ratio_info_present_flag :
new_bs += pack ('uint:8',vp.aspect_ratio_idc)
if vp.aspect_ratio_idc == 255 :
new_bs += pack ('uint:16',vp.sar_width)
new_bs += pack ('uint:16',vp.sar_height)
new_bs += pack ('uint:1',vp.overscan_info_present_flag)
if vp.overscan_info_present_flag :
new_bs += pack ('uint:1',vp.overscan_appropriate_flag)
new_bs += pack ('uint:1',vp.video_signal_type_present_flag)
if vp.video_signal_type_present_flag :
new_bs += pack ('uint:3',vp.video_format)
new_bs += pack ('uint:1',vp.video_full_range_flag)
new_bs += pack ('uint:1',vp.colour_description_present_flag)
if vp.colour_description_present_flag :
new_bs += pack ('uint:8',vp.colour_primaries)
new_bs += pack ('uint:8',vp.transfer_characteristics)
new_bs += pack ('uint:8',vp.matrix_coeffs)
new_bs += pack ('uint:1',vp.chroma_loc_info_present_flag)
if vp.chroma_loc_info_present_flag :
new_bs += pack ('ue',vp.chroma_sample_loc_type_top_field)
new_bs += pack ('ue',vp.chroma_sample_loc_type_bottom_field)
new_bs += pack ('uint:1',vp.neutral_chroma_indication_flag)
new_bs += pack ('uint:1',vp.field_seq_flag)
new_bs += pack ('uint:1',vp.frame_field_info_present_flag)
new_bs += pack ('uint:1',vp.default_display_window_flag)
if vp.default_display_window_flag :
new_bs += pack ('ue',vp.def_disp_win_left_offset)
new_bs += pack ('ue',vp.def_disp_win_right_offset)
new_bs += pack ('ue',vp.def_disp_win_top_offset)
new_bs += pack ('ue',vp.def_disp_win_bottom_offset)
new_bs += pack ('uint:1',vp.vui_timing_info_present_flag)
if vp.vui_timing_info_present_flag :
new_bs += pack ('uint:32',vp.vui_num_units_in_tick)
new_bs += pack ('uint:32',vp.vui_time_scale)
new_bs += pack ('uint:1',vp.vui_poc_proportional_to_timing_flag)
if vp.vui_poc_proportional_to_timing_flag :
new_bs += pack ('ue',vp.vui_num_ticks_poc_diff_one_minus1)
new_bs += pack ('uint:1',vp.vui_hrd_parameters_present_flag)
"""
if( vui_hrd_parameters_present_flag )
hrd_parameters( 1, sps_max_sub_layers_minus1 )
"""
new_bs += pack ('uint:1',vp.bitstream_restriction_flag)
if vp. bitstream_restriction_flag :
new_bs += pack ('uint:1',vp.tiles_fixed_structure_flag)
new_bs += pack ('uint:1',vp.motion_vectors_over_pic_boundaries_flag)
new_bs += pack ('uint:1',vp.restricted_ref_pic_lists_flag)
new_bs += pack ('ue',vp.min_spatial_segmentation_idc)
new_bs += pack ('ue',vp.max_bytes_per_pic_denom)
new_bs += pack ('ue',vp.max_bits_per_min_cu_denom)
new_bs += pack ('ue',vp.log2_max_mv_length_horizontal)
new_bs += pack ('ue',vp.log2_max_mv_length_vertical)
new_bs += pack ('uint:1',sps_extension_present_flag)
if sps_extension_present_flag :
new_bs += pack ('uint:1',sps_range_extension_flag)
new_bs += pack ('uint:1',sps_multilayer_extension_flag)
new_bs += pack ('uint:1',sps_3d_extension_flag)
new_bs += pack ('uint:1',sps_extension_5bits)
new_bs += pack ('uint:1',tb.rbsp_stop_one_bit)
while len(new_bs) < t.pos :
new_bs += pack ('uint:1',tb.rbsp_alignment_zero_bit)
# self.sub_layer_profile_present_flag = []
# self.sub_layer_level_present_flag = []
# for i in range(maxNumSubLayersMinus1):
# self.sub_layer_profile_present_flag.append(t.read('uint:1'))
# self.sub_layer_level_present_flag.append(t.read('uint:1'))
pre_new_bs = pack ('uint:1,2*uint:6,uint:3', forbidden_zero_bit,nal_unit_type,nuh_layer_id,nuh_temporal_id_plus1)
new_bs.replace ('0x0000','0x000003',bytealigned=True)
new_bs = pre_new_bs + new_bs + '0x00'
nal_t_rep = nal_t[24:]
repl = s.replace (nal_t_rep,new_bs, bytealigned=True)
print ('Made modified SPS NALu - OK')
if sei_ok :
s.prepend (new_sei_string)
print ('New SEI prepended')
print ('Writing new stream...')
s.tofile(o)
progr = chunk
while True:
s = F.read(chunk)
o.write(s)
if progr < os.path.getsize(args.infile):
print ('\rProgress ',int(round((progr/os.path.getsize(args.infile))*100)),'%',end='')
progr = progr + chunk
if not s:
break
o.close()
F.close()
print ('\rProgress: 100 %')
print ('=====================')
print ('Done!')
print ('')
print ('File ',args.outfile,' created.')
sys.exit()
def decrypt_images(**kwargs):
path = kwargs.pop('path', 'herders/static/herders/images')
for im_path in iglob(f'{path}/**/*.png', recursive=True):
encrypted = BitStream(filename=im_path)
# Check if it is 'encrypted'. 8th byte is 0x0B instead of the correct signature 0x0A
encrypted.pos = 0x07 * 8
signature = encrypted.peek('uint:8')
if signature == 0x0B:
print(f'Decrypting {im_path}')
# Correct the PNG signature
encrypted.overwrite('0x0A', encrypted.pos)
# Replace bits with magic decrypted values
try:
while True:
pos = encrypted.pos
val = encrypted.peek('uint:8')
encrypted.overwrite(
Bits(uint=com2us_decrypt_values[val], length=8), pos)
except ReadError:
# EOF
pass
# Write it back to the file
with open(im_path, 'wb') as f:
encrypted.tofile(f)
continue
# Check for weird jpeg format with extra header junk. Convert to png.
encrypted.pos = 0
if encrypted.peek('bytes:5') == b'Joker':
print(f'Converting Joker container JPEG to PNG {im_path}')
with open(im_path, 'rb') as f:
bts = f.read()
first_img = bts.find(b'JFIF')
second_img = bts.rfind(b'JFIF')
imgs = []
if second_img > -1 and first_img != second_img:
imgs = [bts[:second_img], bts[second_img:]]
# Add Joker & header to immitate new file
imgs[1] = imgs[0][imgs[0].find(b'Joker'
):first_img] + imgs[1]
imgs = [
JokerContainerFile(img, read=False) for img in imgs
]
else:
img = JokerContainerFile(bts, read=False)
# Open it as a jpg and resave to disk
try:
if len(imgs) > 1:
new_imfile = Image.open(io.BytesIO(imgs[0].data.tobytes()))
new_mask = Image.open(io.BytesIO(
imgs[1].data.tobytes())).convert('L')
new_imfile.putalpha(new_mask)
else:
new_imfile = Image.open(io.BytesIO(img.data.tobytes()))
new_imfile.save(im_path)
except IOError:
print(f'Unable to open {im_path}')
class Bitstream:
"""
class for input bitstream
"""
def __init__(self, file):
self.srcfile = BitStream(file)
self.cur_num_bytes_in_nalu = 0
self.cur_index = 0
self.nalu_list = []
def get_next_nalu(self):
self.cur_index += 1
return self.nalu_list[self.cur_index-1]
def set_next_nalu_pos(self, pos):
self.cur_index = pos
def get_all_nalu(self):
return self.nalu_list
def next_bits(self, bits, forward=False):
try:
if not forward:
ret = self.srcfile.peek('hex:%d' % bits)
else:
ret = self.srcfile.read('hex:%d' % bits)
except ReadError:
return 0
return ret
def calculate_nalu_size(self):
head_pos = self.srcfile.bytepos
value = self.next_bits(24)
while value != 0 \
and value != '000000' \
and value != '000001':
self.srcfile.bytepos += 1
value = self.next_bits(24)
else:
if value == 0:
# will be a bug here if last NALU is only 0 or 1 byte
# but NALU header needs 2 bytes, so ignore that
size = self.srcfile.bytepos - head_pos + 2
else:
size = self.srcfile.bytepos - head_pos
if self.srcfile.bytealign() != 0:
print('Byte Align Error when calculate NALU Size!')
exit(1)
self.srcfile.bytepos = head_pos
return size
def init(self):
"""
save all NALU positions in the list
"""
while 1:
while self.next_bits(24) != '000001' \
and self.next_bits(32) != '00000001':
value = self.next_bits(bits_of_leading_zero_8bits, forward=True)
if value != leading_zero_8bits:
print('wrong leading_zero_8bits')
exit(1)
if self.next_bits(24) != '000001':
value = self.next_bits(bits_of_zero_byte, forward=True)
if value != zero_byte:
print('wrong zero_byte')
exit(1)
value = self.next_bits(bits_of_start_code_prefix_one_3bytes, forward=True)
if value != start_code_prefix_one_3bytes:
print('wrong start_code_prefix_one_3bytes')
exit(1)
self.cur_num_bytes_in_nalu = self.calculate_nalu_size()
self.nalu_list.append(nalunit.get_nalu(self.srcfile, self.srcfile.bytepos, self.cur_num_bytes_in_nalu))
self.srcfile.bytepos = self.srcfile.bytepos + self.cur_num_bytes_in_nalu
while self.next_bits(8) != 0 \
and self.next_bits(24) != '000001' \
and self.next_bits(32) != '00000001':
value = self.next_bits(bits_of_trailing_zero_8bits, forward=True)
if value != trailing_zero_8bits:
print('wrong trailing_zero_8bits')
exit(1)
if self.next_bits(8) == 0:
return
def get_nalu_nums(self):
return len(self.nalu_list)
def __str__(self):
return 'bitstream: length=%d, numofNALU=%d' % (len(self.srcfile), self.get_nalu_nums())
