def __init__(self, path='/tmp', display=False, fullscreen=True):
gr.basic_block.__init__(self,
name="k2sat_image_decoder",
in_sig=[],
out_sig=[])
self.num_images = 0
self.path = path
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.display = display
self.next_frame_count = None
self.feh = FehOpener(fullscreen, interval=0.1)
def __init__(self, path='/tmp', display=False, fullscreen=True):
gr.basic_block.__init__(self,
name="by701_image_decoder",
in_sig=[],
out_sig=[])
self.path = path
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.files = dict()
self.remaining = dict()
self.display = display
self.displaying = list()
self.feh = FehOpener(fullscreen)
def __init__(self, path='/tmp', display=False, fullscreen=True):
gr.basic_block.__init__(self,
name="sat_1kuns_pf_image_decoder",
in_sig=[],
out_sig=[])
self.path = path
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.current_file = -1
self.expected_block = 0
self.display = display
self.displaying = False
self.feh = FehOpener(fullscreen)
class by701_image_decoder(gr.basic_block):
"""
docstring for block by701_image_decoder
"""
def __init__(self, path='/tmp', display=False, fullscreen=True):
gr.basic_block.__init__(self,
name="by701_image_decoder",
in_sig=[],
out_sig=[])
self.path = path
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.files = dict()
self.remaining = dict()
self.display = display
self.displaying = list()
self.feh = FehOpener(fullscreen)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = bytearray(pmt.u8vector_elements(msg))
# check packet len
if len(packet) <= 15 + 8:
return
csp = CSP(packet[:4])
# destination 6 is used for JPEG chunks
if csp.destination != 6:
return
image_id = struct.unpack('<I', packet[4:8])[0]
flag = struct.unpack('<b', packet[8:9])[0]
length = struct.unpack('<I', packet[9:12] + bytearray([0]))[0]
index = struct.unpack('<I', packet[12:15] + bytearray([0]))[0]
data = packet[15:-8]
if flag in flags:
print 'Received flag', flags[flag]
return
filename = os.path.join(self.path, str(image_id) + '.jpg')
if image_id not in self.files:
self.files[image_id] = open(filename, 'wb', 0)
self.remaining[image_id] = length
# check that index and length make sense
if index + len(data) > length:
return
f = self.files[image_id]
f.seek(index)
f.write(data)
self.remaining[image_id] = self.remaining[image_id] - len(data)
if self.display and image_id not in self.displaying and \
length - self.remaining[image_id] >= 64*10:
self.displaying.append(image_id)
try:
self.feh.open(filename)
except Exception:
pass
if self.remaining[image_id] <= 0:
# image finished
print 'Finished downloading image', image_id
f.close()
del self.remaining[image_id]
del self.files[image_id]
class dsat_image_decoder(gr.basic_block):
"""
docstring for block by701_image_decoder
"""
def __init__(self, path='/tmp', display=False, fullscreen=True):
gr.basic_block.__init__(self,
name="dsat_image_decoder",
in_sig=[],
out_sig=[])
self.path = path
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.files = dict()
self.remaining = dict()
self.display = display
self.displaying = list()
self.current_id = None
self.feh = FehOpener(fullscreen)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = bytearray(pmt.u8vector_elements(msg))
# check packet len
if len(packet) <= 15 + 8:
return
csp = CSP(packet[:4])
# destination port 12 is used for announcements
if csp.dest_port == 12:
self.current_timestamp = datetime.utcfromtimestamp(
struct.unpack('<i', packet[4:8])[0])
self.current_id = struct.unpack('<I', packet[8:12])[0]
# next 12 bytes are for GPS position
self.length = struct.unpack('<I', packet[21:25])[0]
print 'Image {} announced. Length {}. Timestamp {}'.format(
self.current_id, self.length, self.current_timestamp)
self.filename = os.path.join(self.path,
str(self.current_id) + '.jpg')
if self.current_id not in self.files:
self.files[self.current_id] = open(self.filename, 'wb', 0)
self.remaining[self.current_id] = self.length
self.bytes_done = 0
self.old_index = 0
return
# destination port 30 is used for JPEG blocks
if csp.dest_port != 30:
return
if not self.current_id:
# we haven't heard the image announcement, we have to ignore the block
return
data = packet[4:-8]
index = struct.unpack('>I', packet[-8:-4])[0]
# handle index rollover
if self.old_index > index:
self.bytes_done += self.msg_datasize
self.old_index = index
self.msg_datasize = struct.unpack(
'>I', packet[-4:])[0] # not really needed to decode image
f = self.files[self.current_id]
f.seek(self.bytes_done + index)
f.write(data)
self.remaining[
self.current_id] = self.remaining[self.current_id] - len(data)
if self.display and self.current_id not in self.displaying and \
self.length - self.remaining[self.current_id] >= 64*10:
self.displaying.append(self.current_id)
try:
self.feh.open(self.filename)
except Exception:
pass
if self.remaining[self.current_id] <= 0:
# image finished
print 'Finished downloading image', self.current_id
f.close()
del self.remaining[self.current_id]
del self.files[self.current_id]
class k2sat_image_decoder(gr.basic_block):
"""
docstring for block k2sat_image_decoder
"""
def __init__(self, path='/tmp', display=False, fullscreen=True):
gr.basic_block.__init__(self,
name="k2sat_image_decoder",
in_sig=[],
out_sig=[])
self.num_images = 0
self.path = path
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.display = display
self.next_frame_count = None
self.feh = FehOpener(fullscreen, interval=0.1)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = bytearray(pmt.u8vector_elements(msg))
# check packet len
if len(packet) <= 16 + 4 + 1:
return
virtual_channel_frame_count = packet[16 + 2]
first_header_pointer = packet[16 + 3]
if first_header_pointer == 0x00:
# first packet in image
filename = os.path.join(self.path,
'image_{}.jpg'.format(self.num_images))
self.f = open(filename, 'wb')
print 'Started image', self.num_images
self.num_images += 1
self.next_frame_count = virtual_channel_frame_count
if self.next_frame_count == None:
# current image has failed
return
if virtual_channel_frame_count != self.next_frame_count:
print 'Lost image packet. Image decoding failed.'
self.next_frame_count = None
self.f.close()
return
self.f.write(packet[20:-1])
self.f.flush()
self.next_frame_count = (self.next_frame_count + 1) % 256
if self.display and first_header_pointer == 0x00:
try:
self.feh.open(filename)
except Exception:
pass
if first_header_pointer == 0xff:
# last packet in image
self.f.close()
self.next_frame_count = None
print 'Finished downloading image'
class sat_1kuns_pf_image_decoder(gr.basic_block):
"""
docstring for block sat_1kuns_pf_image_decoder
"""
def __init__(self, path='/tmp', display=False, fullscreen=True):
gr.basic_block.__init__(self,
name="sat_1kuns_pf_image_decoder",
in_sig=[],
out_sig=[])
self.path = path
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.current_file = -1
self.expected_block = 0
self.display = display
self.displaying = False
self.feh = FehOpener(fullscreen)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = bytearray(pmt.u8vector_elements(msg))
# check packet len
if len(packet) != 138:
return
block = struct.unpack('>H', packet[4:6])[0]
data = packet[6:-4]
if self.current_file == -1:
if block == 0:
# first file received
print "Starting image 0"
self.current_file = 0
self.filename = os.path.join(
self.path, 'img{}.jpg'.format(self.current_file))
self.f = open(self.filename, 'wb', 0)
else:
return
elif block == 0:
# new file
print "Image {} finished. Starting image {}".format(
self.current_file, self.current_file + 1)
self.f.close()
self.current_file += 1
self.expected_block = 0
self.filename = os.path.join(self.path,
'img{}.jpg'.format(self.current_file))
self.f = open(self.filename, 'wb', 0)
self.displaying = False
elif block != self.expected_block:
# lost block
print "Lost image block {}".format(self.expected_block)
print "Received image block {}".format(block)
self.f.write(data)
self.expected_block = block + 1
if self.display and not self.displaying and block >= 5:
self.displaying = True
try:
self.feh.open(self.filename)
except Exception:
pass