def deserialize(self, str):
   """
   unpack serialized message in str into this message instance
   :param str: byte array of serialized message, ``str``
   """
   try:
     end = 0
     start = end
     end += 4
     (self.result,) = _struct_i.unpack(str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%si'%length
     start = end
     end += struct.calcsize(pattern)
     self.resolution = struct.unpack(pattern, str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sf'%length
     start = end
     end += struct.calcsize(pattern)
     self.buffer = struct.unpack(pattern, str[start:end])
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
示例#2
0
def get_images(filename):
	bin_file = open(filename,'rb')
	buf = bin_file.read()#all the file are put into memory
	bin_file.close()# release the measure of operating system
	index = 0
	magic, num_images, num_rows, num_colums = struct.unpack_from(big_endian+four_bytes, buf,index)

	index += struct.calcsize(big_endian + four_bytes)   # TODO why not multy 4?
	print num_images

	images = [] #temp images as tuple
	for x in range(num_images):
	    im = struct.unpack_from(big_endian + picture_bytes, buf, index)
	    index += struct.calcsize(big_endian + picture_bytes)
	    im = list(im)
	    for i in range(len(im)) :
	    	if im[i] >= 1 and im[i] < 64:
	    		im[i] = 1

	    	if im[i] >= 64 and im[i] < 128:
	    		im[i] = 2

	    	if im[i] >= 128 and im[i] < 192:
	    		im[i] = 3

	    	if im[i] >= 192 and im[i] < 256:
	    		im[i] = 4

	    	else: im[i] = 0
	            
	    images.append(im)
	a = np.array(images)
	return a
示例#3
0
    def _parse_hpr_time_series(self, offset, rules):
        """
        Convert the binary data into particle data for the Heading, Pitch, Time Series Data Type
        """
        # Unpack the unpacking rules
        (hpr_num_name, beam_angle_name, spare_name, hpr_time_names),\
        (hpr_num_fmt, beam_angle_fmt, spare_fmt, hpr_time_fmt) = zip(*rules)

        # First unpack the array length and single length value, no need to unpack spare
        (hpr_num_data, beam_angle_data) = struct.unpack_from(
            '<%s%s' % (hpr_num_fmt, beam_angle_fmt), self.raw_data, offset)

        # Then unpack the array using the retrieved lengths value
        next_offset = offset + struct.calcsize(hpr_num_fmt) + struct.calcsize(beam_angle_fmt) + \
                      struct.calcsize(spare_fmt)
        hpr_time_list_data = struct.unpack_from(
            '<%s%s' % (hpr_num_data * HPR_TIME_SERIES_ARRAY_SIZE, hpr_time_fmt), self.raw_data, next_offset)

        # convert to numpy array and reshape the data to a 2d array per IDD spec
        transformed_hpr_time_data = numpy.array(hpr_time_list_data).reshape(
            (hpr_num_data, HPR_TIME_SERIES_ARRAY_SIZE)).transpose().tolist()

        # Add to the collected parameter data
        self.final_result.extend(
            ({DataParticleKey.VALUE_ID: hpr_num_name, DataParticleKey.VALUE: hpr_num_data},
             {DataParticleKey.VALUE_ID: beam_angle_name, DataParticleKey.VALUE: beam_angle_data},
             {DataParticleKey.VALUE_ID: hpr_time_names[HEADING_TIME_SERIES_IDX],
              DataParticleKey.VALUE: transformed_hpr_time_data[HEADING_TIME_SERIES_IDX]},
             {DataParticleKey.VALUE_ID: hpr_time_names[PITCH_TIME_SERIES_IDX],
              DataParticleKey.VALUE: transformed_hpr_time_data[PITCH_TIME_SERIES_IDX]},
             {DataParticleKey.VALUE_ID: hpr_time_names[ROLL_TIME_SERIES_IDX],
              DataParticleKey.VALUE: transformed_hpr_time_data[ROLL_TIME_SERIES_IDX]}))
  def _unpack(self, data):
    """ Unpack the data blob as a motoboot image and return the list
    of contained image objects"""
    num_imgs_fmt = "<L"
    num_imgs_size = struct.calcsize(num_imgs_fmt)
    num_imgs, = struct.unpack(num_imgs_fmt, data[:num_imgs_size])

    img_info_format = "<24sLL"
    img_info_size = struct.calcsize(img_info_format)

    imgs = [ struct.unpack(img_info_format, data[num_imgs_size + i*img_info_size:num_imgs_size + (i+1)*img_info_size]) for i in range(num_imgs) ]

    magic_format = "<8s"
    magic_size = struct.calcsize(magic_format)
    magic, = struct.unpack(magic_format, data[num_imgs_size + NUM_MAX_IMAGES*img_info_size:num_imgs_size + NUM_MAX_IMAGES*img_info_size + magic_size])
    if magic != MAGIC:
      raise BadMagicError

    img_objs = []
    for name, start, end in imgs:
      start_offset = HEADER_SIZE + start * SECTOR_SIZE
      end_offset = HEADER_SIZE + (end + 1) * SECTOR_SIZE - 1
      img = common.File(trunc_to_null(name), data[start_offset:end_offset+1])
      img_objs.append(img)

    self.unpacked_images = img_objs
示例#5
0
    def _parse_values(self, offset, rules):
        """
        Convert the binary data into particle data for the given rules
        """
        position = offset

        # Iterate through the unpacking rules and append the retrieved values with its corresponding
        # particle name
        for key, formatter in rules:
            # Skip over spare values
            if AdcptMWVSParticleKey.SPARE in key:
                position += struct.calcsize(formatter)
                continue
            value = list(struct.unpack_from('<%s' % formatter, self.raw_data, position))
            # Support unpacking single values and lists
            if len(value) == 1:
                value = value[0]
            if AdcptMWVSParticleKey.START_TIME in key:
                timestamp = ((value[0]*100 + value[1]), value[2], value[3], value[4],
                             value[5], value[6], value[7], 0, 0)
                log.trace("TIMESTAMP: %s", timestamp)
                elapsed_seconds = calendar.timegm(timestamp)
                self.set_internal_timestamp(unix_time=elapsed_seconds)
            log.trace("DATA: %s:%s @ %s", key, value, position)
            position += struct.calcsize(formatter)
            self.final_result.append({DataParticleKey.VALUE_ID: key,
                                      DataParticleKey.VALUE: value})
示例#6
0
    def render(self):
        """
        Returns a tuple of format and data suitable for ``struct.pack``.

        Each (<offset>, <message>) tuple in ``self.messages`` is `render()`-ed
        and the output collected int a single format and data list, prefaced
        with a single integer denoting the size of the message set.
        """
        fmt = ["i"]
        data = []
        total_size = 0

        for offset, message in self.messages:
            offset_format, offset_data = Int64(offset).render()
            message_format, message_data = message.render()

            message_size = struct.calcsize(message_format)
            size_format, size_data = Int32(message_size).render()

            message_format = "".join([
                offset_format, size_format, message_format
            ])
            total_size += struct.calcsize("!" + message_format)

            fmt.append(message_format)
            data.extend(offset_data)
            data.extend(size_data)
            data.extend(message_data)

        data.insert(0, total_size)

        return "".join(fmt), data
示例#7
0
    def _parse_directional_spectrum(self, offset, rules):
        """
        Convert the binary data into particle data for the Directional Spectrum Data Type
        """
        # Unpack the unpacking rules
        (num_freq_name, num_dir_name, good_name, dat_name),\
        (num_freq_fmt, num_dir_fmt, good_fmt, dat_fmt) = zip(*rules)

        # First unpack the array lengths and single length values
        (num_freq_data, num_dir_data, dspec_good_data) = struct.unpack_from(
            '<%s%s%s' % (num_freq_fmt, num_dir_fmt, good_fmt), self.raw_data, offset)

        # Then unpack the array using the retrieved lengths values
        next_offset = offset + struct.calcsize(num_freq_fmt) + struct.calcsize(num_dir_fmt) + \
                      struct.calcsize(good_fmt)
        dspec_dat_list_data = struct.unpack_from(
            '<%s%s' % (num_freq_data * num_dir_data, dat_fmt), self.raw_data, next_offset)

        # convert to numpy array and reshape the data per IDD spec
        transformed_dat_data = numpy.array(dspec_dat_list_data).reshape(
            (num_freq_data, num_dir_data)).tolist()

        # Add to the collected parameter data
        self.final_result.extend(
            ({DataParticleKey.VALUE_ID: num_freq_name, DataParticleKey.VALUE: num_freq_data},
             {DataParticleKey.VALUE_ID: num_dir_name, DataParticleKey.VALUE: num_dir_data},
             {DataParticleKey.VALUE_ID: good_name, DataParticleKey.VALUE: dspec_good_data},
             {DataParticleKey.VALUE_ID: dat_name, DataParticleKey.VALUE: transformed_dat_data}))
示例#8
0
	def __init__(self,fileID):
		temp = fileID.read(struct.calcsize(self.binary_format))
		data = struct.unpack(self.binary_format,temp)
		self.meshname = "".join([str(x, "ascii") for x in data[0:64] if x[0] < 127 ]) #Name of Mesh every Char is a  String on his own
		self.framecount = data[64]				#Framecount = Number of Animationsteps
		self.vertexcount = data[65]			   #Number of Vertices in each Frame
		self.indexcount = data[66]				#Number of Indices in Mesh (Triangles = Indexcount/3)
		self.diffusecolor = data[67:70]	   #RGB diffuse color
		self.specularcolor = data[70:73]	  #RGB specular color (unused)
		self.specularpower = data[73]		 #Specular power (unused)
		self.opacity = data[74]					   #Opacity
		self.properties= data[75]				  #Property flags
		self.textures = data[76]					  #Texture flag
		if self.properties & 1:					  #PropertyBit is Mesh Alpha Channel custom Color in Game ?
			self.customalpha = True
		else:
			self.customalpha = False
		if self.properties & 2:					  #PropertyBit is Mesh TwoSided ?
			self.istwosided = True
		else:
			self.istwosided = False
		if self.textures & 1:						#PropertyBit is Mesh Textured ?
			temp = fileID.read(struct.calcsize(self.texname_format))
			data = struct.unpack(self.texname_format,temp)
			self.texturefilename = "".join([str(x, "ascii") for x in data[0:-1] if x[0] < 127 ])
			self.hastexture = True
		else:
			self.hastexture = False
			self.texturefilename = None
示例#9
0
    def _parse_sync_response(self, data):
        keyspecs = []
        nkeys = struct.unpack(">H", data[0: struct.calcsize("H")])[0]
        offset = struct.calcsize("H")
        for i in xrange(nkeys):
            spec = {}
            width = struct.calcsize("QHHB")
            spec['cas'], spec['vbucket'], keylen, eventid = struct.unpack(">QHHB", data[offset: offset + width])

            offset += width
            spec['key'] = data[offset: offset + keylen]
            offset += keylen

            if eventid == MemcachedConstants.CMD_SYNC_EVENT_PERSISTED:
                spec['event'] = 'persisted'
            elif eventid == MemcachedConstants.CMD_SYNC_EVENT_MODIFED:
                spec['event'] = 'modified'
            elif eventid == MemcachedConstants.CMD_SYNC_EVENT_DELETED:
                spec['event'] = 'deleted'
            elif eventid == MemcachedConstants.CMD_SYNC_EVENT_REPLICATED:
                spec['event'] = 'replicated'
            elif eventid == MemcachedConstants.CMD_SYNC_INVALID_KEY:
                spec['event'] = 'invalid key'
            elif spec['event'] == MemcachedConstants.CMD_SYNC_INVALID_CAS:
                spec['event'] = 'invalid cas'
            else:
                spec['event'] = eventid

            keyspecs.append(spec)
        return keyspecs
示例#10
0
    def __init__(self, player_response):
        self.players = []
        if player_response != None: 
            pre_header,\
            header,\
            num_players = struct.unpack('<IBB', player_response)
            assert header == 0x44

            player_response = player_response[pystruct.calcsize('<IBB'):]

            # unpack all the players in the player response
            while len(player_response) > 0:
                index,\
                name,\
                kills,\
                time = struct.unpack('<Bzif', player_response)
           
                # don't include 'players' with no name - the steam
                # browser itself appears to ignore these
                if len(name) > 0:
                    self.players.append(ServerPlayer(name, kills, time))

                # add 1 for null byte in the player name 
                packet_size = pystruct.calcsize('<Bif') + len(name) + 1
                player_response = player_response[packet_size:]

            self.players.sort(reverse=True)
示例#11
0
 def deserialize_numpy(self, str, numpy):
     """
 unpack serialized message in str into this message instance using numpy for array types
 :param str: byte array of serialized message, ``str``
 :param numpy: numpy python module
 """
     try:
         if self.c is None:
             self.c = lab5_msgs.msg.ColorMsg()
         end = 0
         _x = self
         start = end
         end += 28
         (_x.c.r, _x.c.g, _x.c.b, _x.numVertices) = _struct_3qi.unpack(str[start:end])
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = "<%sf" % length
         start = end
         end += struct.calcsize(pattern)
         self.x = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = "<%sf" % length
         start = end
         end += struct.calcsize(pattern)
         self.y = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
         _x = self
         start = end
         end += 8
         (_x.closed, _x.filled) = _struct_2i.unpack(str[start:end])
         return self
     except struct.error as e:
         raise genpy.DeserializationError(e)  # most likely buffer underfill
示例#12
0
 def deserialize(self, str):
     """
 unpack serialized message in str into this message instance
 :param str: byte array of serialized message, ``str``
 """
     try:
         if self.c is None:
             self.c = lab5_msgs.msg.ColorMsg()
         end = 0
         _x = self
         start = end
         end += 28
         (_x.c.r, _x.c.g, _x.c.b, _x.numVertices) = _struct_3qi.unpack(str[start:end])
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = "<%sf" % length
         start = end
         end += struct.calcsize(pattern)
         self.x = struct.unpack(pattern, str[start:end])
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = "<%sf" % length
         start = end
         end += struct.calcsize(pattern)
         self.y = struct.unpack(pattern, str[start:end])
         _x = self
         start = end
         end += 8
         (_x.closed, _x.filled) = _struct_2i.unpack(str[start:end])
         return self
     except struct.error as e:
         raise genpy.DeserializationError(e)  # most likely buffer underfill
 def deserialize(self, str):
   """
   unpack serialized message in str into this message instance
   :param str: byte array of serialized message, ``str``
   """
   try:
     if self.header is None:
       self.header = std_msgs.msg.Header()
     end = 0
     _x = self
     start = end
     end += 12
     (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     start = end
     end += length
     if python3:
       self.header.frame_id = str[start:end].decode('utf-8')
     else:
       self.header.frame_id = str[start:end]
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.acceleration = struct.unpack(pattern, str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.orientation = struct.unpack(pattern, str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.angular = struct.unpack(pattern, str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.magnetic = struct.unpack(pattern, str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.timestamp = struct.unpack(pattern, str[start:end])
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
示例#14
0
def UnpackDEV_BROADCAST(lparam):
    # guard for 0 here, otherwise PyMakeBuffer will create a new buffer.
    if lparam == 0:
        return None
    hdr_size = struct.calcsize("iii")
    hdr_buf = win32gui.PyMakeBuffer(hdr_size, lparam)
    size, devtype, reserved = struct.unpack("iii", hdr_buf)
    rest = win32gui.PyMakeBuffer(size-hdr_size, lparam+hdr_size)

    extra = x = {}
    if devtype == win32con.DBT_DEVTYP_HANDLE:
        # 2 handles, a GUID, a LONG and possibly an array following...
        fmt = "PP16sl"
        x['handle'], x['hdevnotify'], guid_bytes, x['nameoffset'] = \
            struct.unpack(fmt, rest[:struct.calcsize(fmt)])
        x['eventguid'] = pywintypes.IID(guid_bytes, True)
    elif devtype == win32con.DBT_DEVTYP_DEVICEINTERFACE:
        # guid, null-terminated name
        x['classguid'] = pywintypes.IID(rest[:16], 1)
        name = rest[16:]
        if '\0' in name:
            name = name.split('\0', 1)[0]
        x['name'] = name
    elif devtype == win32con.DBT_DEVTYP_VOLUME:
        # int mask and flags
        x['unitmask'], x['flags'] = struct.unpack("II", rest[:struct.calcsize("II")])
    else:
        raise NotImplementedError("unknown device type %d" % (devtype,))
    return DEV_BROADCAST_INFO(devtype, **extra)
示例#15
0
def ReadRecord(d, offset=0x0):
    id = d[0]
    d=d[1:] # Eat id
    if id == 0xff or id == 0x4: # Normal end of Data
        return id, None, None
    sztotal = 1 
    assert RecPack.has_key(id), "Unknown record ID %i at offset %i" % (id, offset)
    if RecRepeat.has_key(id):
        sz = struct.calcsize(RecPack[id])
        init=struct.unpack_from(RecRepeat[id][1], d)
        szinit=struct.calcsize(RecRepeat[id][1])
        d=d[szinit:]
        sztotal += szinit
        res=[]
        for i in range(0, RecRepeat[id][0]):
            res.append(struct.unpack_from(RecPack[id], d))
            d=d[sz:]
            sztotal += sz
    elif type(RecPack[id]) == str:
        sz = struct.calcsize(RecPack[id])
        res = struct.unpack_from(RecPack[id], d)
        sztotal += sz
    elif type(RecPack[id]) == int: # 12-bit field array
        # A padding byte 0xFF may be present
        sz = RecPack[id] - 1
        res = ReadPacked12Bit(d[:sz])
        sztotal += sz
    return id, sztotal, res
 def shake_hand(self, size=0, action="receive"):
     hi_msg_len = struct.calcsize(self.hi_format)
     ack_msg_len = struct.calcsize(self.ack_format)
     if action == "send":
         self.send(self.hi_msg)
         txt = self.receive(hi_msg_len)
         out = struct.unpack(self.hi_format, txt)[0]
         if out != "HI":
             raise ShakeHandError("Fail to get HI from guest.")
         size_s = struct.pack("q", size)
         self.send(size_s)
         txt = self.receive(ack_msg_len)
         ack_str = struct.unpack(self.ack_format, txt)[0]
         if ack_str != self.ack_msg:
             raise "Guest did not ACK the file size message."
         return size
     elif action == "receive":
         txt = self.receive(hi_msg_len)
         hi_str = struct.unpack(self.hi_format, txt)[0]
         if hi_str != self.hi_msg:
             raise ShakeHandError("Fail to get HI from guest.")
         self.send(txt)
         size = self.receive(8)
         print("xxxx size = %s" % size)
         if size:
             size = struct.unpack("q", size)[0]
             txt = struct.pack(self.ack_format, self.ack_msg)
             self.send(txt)
         return size
示例#17
0
def PrintRecords(labels, s4, fmtHead, fmtTail="", printHex=True, printNorm=True):
    fmt = fmtHead
    szHead = struct.calcsize(fmtHead)
    szTail = struct.calcsize(fmtTail)
    printableHead = string.join([x for x in fmtHead if fmtmap.has_key(x)],"")
    printableTail = string.join([x for x in fmtTail if fmtmap.has_key(x)],"")
    if fmtTail != "":
        gap = len(s4[0]) - (struct.calcsize(fmtHead) + struct.calcsize(fmtTail))
        fmt = fmtHead + ("x"*gap) + fmtTail
    labels = ["LINE"] + labels[:len(printableHead)] + labels[len(labels)-len(printableTail):]
    PrintMultiLineLabels(labels,6)
    sys.stdout.write(6*" ")
    PrintByteLabels(fmt, len(s4))
    for i in range(0, len(s4)):
        if printNorm:
            sys.stdout.write("%5i:%s\n" % (i, StructToString(s4[i], fmt, 6)))
        if printHex:
            sys.stdout.write("\33[0m")
            sys.stdout.write("            %s\n" % (StructToString(s4[i], fmt, 6, color=False, hexonly=True)))
        if not ((i+1) % 40) or (i == len(s4) - 1):
            PrintMultiLineLabels(labels,6)
            sys.stdout.write(6*" ")
            PrintByteLabels(fmt, len(s4))
        #HexPrintMod(s4[i][:szHead].tostring() + s4[i][len(s4[i]) - szTail:].tostring(), szHead + szTail)
    PrintByteStats(s4, fmt)
示例#18
0
	def _callfunc(self, fid, argsfmt, args, retfmt):
		"""Call a function on the device by id, directly passing argument/return format parameters."""
		# Make a list out of the arguments if they are none
		#print('calling function No. {}, args({}) {}, returning {}'.format(fid, argsfmt, args, retfmt))
		if not (isinstance(args, tuple) or isinstance(args, list)):
			args = [args]
		with self._ser as s:
			# Send the encoded data
			cmd = b'\\#' + escape(struct.pack(">HHH", self.node_id, fid, struct.calcsize(argsfmt)) + struct.pack(argsfmt, *args))
			s.write(cmd)
			# payload length
			(clen,) = struct.unpack(">H", s.read(2))
			# payload data
			cbytes = s.read(clen)
			if clen != struct.calcsize(retfmt):
				# CAUTION! This error is thrown not because the user supplied a wrong value but because the device answered in an unexpected manner.
				# FIXME raise an error here or let the whole operation just fail in the following struct.unpack?
				raise AttributeError("Device response format problem: Length mismatch: {} != {}".format(clen, struct.calcsize(retfmt)))
			rv = struct.unpack(retfmt, cbytes)
			# Try to interpret the return value in a useful manner
			if len(rv) == 0:
				return None
			elif len(rv) == 1:
				return rv[0]
			else:
				return list(rv)
示例#19
0
 def unpack(self, data):
     n = struct.unpack('!I', data[:struct.calcsize('!I')])[0]
     items = struct.unpack('!%d%c' % (n, self.format_char),\
             data[struct.calcsize('!I'):])
     self.vals = [v for v in items]
     format_str = '!I%d%c' % (len(self.vals), self.format_char)
     self.struct = struct.Struct(format_str)
示例#20
0
文件: extfs.py 项目: leyyer/exfsh
 def __init__(self, idx, buf):
     self.inode_no = idx
     sb = buffer(bytearray(buf))
     sz = 0
     fmt = "<2H5I2H3I"
     (self.i_mode,
      self.i_uid,
      self.i_size,
      self.i_atime,
      self.i_ctime,
      self.i_mtime,
      self.i_dtime,
      self.i_gid,
      self.i_links_count,
      self.i_blocks,
      self.i_flags,
      self.i_osd1) = struct.unpack_from(fmt, sb, sz)
     sz += struct.calcsize(fmt)
     fmt = "<15I"
     self.i_block = struct.unpack_from(fmt, sb, sz)
     sz += struct.calcsize(fmt)
     fmt = "<4I12s"
     (self.i_gneration,
      self.i_file_acl,
      self.i_dir_acl,
      self.i_faddr,
      self.i_osd2) = struct.unpack_from(fmt, sb, sz)
  def old_obs_callback(self, data, sender=None):
    print "Received deprecated observation messages. Please update your Piksi."
    if (sender is not None and
        (self.relay ^ (sender == 0))):
      return

    hdr_fmt = "<dH"
    hdr_size = struct.calcsize(hdr_fmt)
    tow, wn = struct.unpack("<dH", data[:hdr_size])
    self.gps_tow = tow
    self.gps_week = wn
    self.t = datetime.datetime(1980, 1, 6) + \
             datetime.timedelta(weeks=self.gps_week) + \
             datetime.timedelta(seconds=self.gps_tow)

    # Observation message format
    # double P;      /**< Pseudorange (m) */
    # double L;      /**< Carrier-phase (cycles) */
    # float snr;     /**< Signal-to-Noise ratio */
    # u8 prn;        /**< Satellite number. */
    obs_fmt = '<ddfB'

    obs_size = struct.calcsize(obs_fmt)
    n_obs = (len(data) - hdr_size) / obs_size
    obs_data = data[hdr_size:]

    self.obs = {}
    for i in range(n_obs):
      P, L, snr, prn = struct.unpack(obs_fmt, obs_data[:obs_size])
      obs_data = obs_data[obs_size:]
      self.obs[prn] = (P, L, snr)

    self.update_obs()
    self.rinex_save()
示例#22
0
 def deserialize(self, str):
   """
   unpack serialized message in str into this message instance
   :param str: byte array of serialized message, ``str``
   """
   try:
     if self.timestamp is None:
       self.timestamp = genpy.Time()
     end = 0
     _x = self
     start = end
     end += 8
     (_x.timestamp.secs, _x.timestamp.nsecs,) = _struct_2I.unpack(str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.state = struct.unpack(pattern, str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.covariance = struct.unpack(pattern, str[start:end])
     self.timestamp.canon()
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
 def deserialize_numpy(self, str, numpy):
   """
   unpack serialized message in str into this message instance using numpy for array types
   :param str: byte array of serialized message, ``str``
   :param numpy: numpy python module
   """
   try:
     if self.workspace_region_shape is None:
       self.workspace_region_shape = arm_navigation_msgs.msg.Shape()
     if self.workspace_region_pose is None:
       self.workspace_region_pose = geometry_msgs.msg.PoseStamped()
     end = 0
     start = end
     end += 1
     (self.workspace_region_shape.type,) = _struct_b.unpack(str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.workspace_region_shape.dimensions = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length)
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%si'%length
     start = end
     end += struct.calcsize(pattern)
     self.workspace_region_shape.triangles = numpy.frombuffer(str[start:end], dtype=numpy.int32, count=length)
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     self.workspace_region_shape.vertices = []
     for i in range(0, length):
       val1 = geometry_msgs.msg.Point()
       _x = val1
       start = end
       end += 24
       (_x.x, _x.y, _x.z,) = _struct_3d.unpack(str[start:end])
       self.workspace_region_shape.vertices.append(val1)
     _x = self
     start = end
     end += 12
     (_x.workspace_region_pose.header.seq, _x.workspace_region_pose.header.stamp.secs, _x.workspace_region_pose.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     start = end
     end += length
     if python3:
       self.workspace_region_pose.header.frame_id = str[start:end].decode('utf-8')
     else:
       self.workspace_region_pose.header.frame_id = str[start:end]
     _x = self
     start = end
     end += 56
     (_x.workspace_region_pose.pose.position.x, _x.workspace_region_pose.pose.position.y, _x.workspace_region_pose.pose.position.z, _x.workspace_region_pose.pose.orientation.x, _x.workspace_region_pose.pose.orientation.y, _x.workspace_region_pose.pose.orientation.z, _x.workspace_region_pose.pose.orientation.w,) = _struct_7d.unpack(str[start:end])
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
示例#24
0
 def deserialize_numpy(self, str, numpy):
   """
   unpack serialized message in str into this message instance using numpy for array types
   :param str: byte array of serialized message, ``str``
   :param numpy: numpy python module
   """
   try:
     if self.timestamp is None:
       self.timestamp = genpy.Time()
     end = 0
     _x = self
     start = end
     end += 8
     (_x.timestamp.secs, _x.timestamp.nsecs,) = _struct_2I.unpack(str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.state = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length)
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sd'%length
     start = end
     end += struct.calcsize(pattern)
     self.covariance = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length)
     self.timestamp.canon()
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
示例#25
0
 def deserialize_numpy(self, str, numpy):
   """
   unpack serialized message in str into this message instance using numpy for array types
   :param str: byte array of serialized message, ``str``
   :param numpy: numpy python module
   """
   try:
     end = 0
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%si'%length
     start = end
     end += struct.calcsize(pattern)
     self.handles = numpy.frombuffer(str[start:end], dtype=numpy.int32, count=length)
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     start = end
     end += length
     if python3:
       self.setModes = str[start:end].decode('utf-8')
     else:
       self.setModes = str[start:end]
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sf'%length
     start = end
     end += struct.calcsize(pattern)
     self.values = numpy.frombuffer(str[start:end], dtype=numpy.float32, count=length)
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
示例#26
0
 def deserialize(self, str):
   """
   unpack serialized message in str into this message instance
   :param str: byte array of serialized message, ``str``
   """
   try:
     end = 0
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%si'%length
     start = end
     end += struct.calcsize(pattern)
     self.handles = struct.unpack(pattern, str[start:end])
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     start = end
     end += length
     if python3:
       self.setModes = str[start:end].decode('utf-8')
     else:
       self.setModes = str[start:end]
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     pattern = '<%sf'%length
     start = end
     end += struct.calcsize(pattern)
     self.values = struct.unpack(pattern, str[start:end])
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
def writeData(data, datafile, dataformat=defformat):
    
    # Check given format string is valid
    try:
        bytesperpix = struct.calcsize(dataformat)
    except:
        raise ValueError, "Supplied data format " + str(dataformat) + " is invalid"
    # end try
    
    # Get the size in bytes for the given data format
    itemsize = struct.calcsize(dataformat)
    
    writestr = ""
    
    for i in range(0, len(data)):
        try:
            packeditem = struct.pack(dataformat, data[i])
        except:
            datafile.close()
            raise IOError, "Could not pack " + str(dataitem) + " into " + str(bytesperpix) + " bytes. Reason: " + str(sys.exc_info()[1])
        # end try
        
        if ((i % 1000 != 999) and (i != len(data) - 1)):
            writestr = writestr + packeditem
        else:
            writestr = writestr + packeditem
            try:
                datafile.write(writestr)
            except:
                datafile.close()
                raise IOError, "Failed to write to data file. Reason: " + str(sys.exc_info()[1])           
            # end try
            writestr = ""
示例#28
0
 def __init__(self, varlist):
     """ construct a SharedMemoryReader, given a variable list (names
     from ALMemory). Since this is done in async style, there is a deferred
     for completion of the init called self.openDeferred which
     can be used, i.e. self.openDeferred.addCallback(on_shm_inited)
     """
     if not self.isMMapAvailable():
         raise Exception("Don't initialize me if there is no MMAP!")
     self._shm_proxy = shm_proxy = burst.getBurstMemProxy(deferred=True)
     self._var_names = varlist
     self._fd = None
     self._buf = None
     self._unpack = 'f' * len(self._var_names)
     start_offset = BURST_SHARED_MEMORY_VARIABLES_START_OFFSET
     self._unpack_start = start_offset
     self._unpack_end = start_offset + struct.calcsize(self._unpack)
     self._sonar_unpack = 'f'*US_ELEMENTS_NUM
     self._sonar_start = 0
     self._sonar_end = struct.calcsize(self._sonar_unpack) + self._sonar_start
     self.vars = dict((k, 0.0) for k in self._var_names)
     # TODO - ugly (next year)
     self.vars[US_DISTANCES_VARNAME] = [0.0] * US_ELEMENTS_NUM
     print "SharedMemory: asked burstmem to map %s variables" % len(self._var_names)
     # set all the names of the variables we want mapped - we don't block
     # or anything since we expect the first few frames to be eventless,
     # but this is definitely a TODO
     self.openDeferred = Deferred()
     shm_proxy.clearMappedVariables().addCallback(self._complete_init).addErrback(log.err)
示例#29
0
def main(infile, outfile):

  # Read the cloop head

  pream, uncomp_buf_size, total_blocks = \
    unpack(CLOOP_HEAD_FMT, infile.read(calcsize(CLOOP_HEAD_FMT)))

  comp_buf_size = uncomp_buf_size + uncomp_buf_size // 1000 + 12 + 4
  total_offsets = total_blocks + 1

  # Read the block offsets

  offsets_fmt = ('!%dQ' % total_offsets).encode('ascii')
  offsets = unpack(offsets_fmt, infile.read(calcsize(offsets_fmt)))

  # Pipe the blocks through the decompressor and onto the output

  block_modulo = total_blocks // 10
  for i in range(total_blocks):
    size = offsets[i + 1] - offsets[i]
    if size < 0 or size > comp_buf_size:
      raise SystemExit(
        "Size %d for block %d (offset %d) wrong, corrupt data!"
        % (size, i, offsets[i])
      )
    comp_buf = infile.read(size)
    if len(comp_buf) != size:
      raise SystemExit("Error read %d data bytes" % size)
    uncomp_buf = zlib.decompress(comp_buf)
    outfile.write(uncomp_buf)
def load_mnist(im_path, lb_path):
	# loading images
	binfile = open(im_path, 'rb')
	buf = binfile.read()
	index = 0
	magic,numImages,numRows,numColumns = \
		struct.unpack_from('>IIII' , buf , index)
	index += struct.calcsize('>IIII')
	if magic!=2051:
		raise NameError('MNIST TRAIN-IMAGE INCCORECT!')
	ims = np.zeros([numImages, numRows*numColumns])
	for i in range(numImages):
		ims[i,:] = struct.unpack_from('>784B', buf, index)
		index += struct.calcsize('>784B');
	# loading labels
	binfile = open(lb_path, 'rb')
	buf = binfile.read()
	index = 0
	magic,numLabels = struct.unpack_from(
		'>II', 
		buf, 
		index
	)
	index += struct.calcsize('>II')
	if magic!=2049:
		raise NameError('MNIST TRAIN-LABEL INCORRECT!')
	lbs = np.zeros(numLabels)
	lbs[:] = struct.unpack_from(
		'>'+ str(numLabels) +'B', 
		buf, 
		index
	)
	return [ims, numRows, numColumns, lbs]
示例#31
0
 def deserialize(self, str):
     """
 unpack serialized message in str into this message instance
 :param str: byte array of serialized message, ``str``
 """
     try:
         if self.poses is None:
             self.poses = None
         end = 0
         start = end
         end += 4
         (length, ) = _struct_I.unpack(str[start:end])
         self.poses = []
         for i in range(0, length):
             val1 = geometry_msgs.msg.PoseStamped()
             _v6 = val1.header
             start = end
             end += 4
             (_v6.seq, ) = _struct_I.unpack(str[start:end])
             _v7 = _v6.stamp
             _x = _v7
             start = end
             end += 8
             (
                 _x.secs,
                 _x.nsecs,
             ) = _struct_2I.unpack(str[start:end])
             start = end
             end += 4
             (length, ) = _struct_I.unpack(str[start:end])
             start = end
             end += length
             if python3:
                 _v6.frame_id = str[start:end].decode('utf-8')
             else:
                 _v6.frame_id = str[start:end]
             _v8 = val1.pose
             _v9 = _v8.position
             _x = _v9
             start = end
             end += 24
             (
                 _x.x,
                 _x.y,
                 _x.z,
             ) = _struct_3d.unpack(str[start:end])
             _v10 = _v8.orientation
             _x = _v10
             start = end
             end += 32
             (
                 _x.x,
                 _x.y,
                 _x.z,
                 _x.w,
             ) = _struct_4d.unpack(str[start:end])
             self.poses.append(val1)
         start = end
         end += 4
         (length, ) = _struct_I.unpack(str[start:end])
         pattern = '<%sh' % length
         start = end
         end += struct.calcsize(pattern)
         self.sizes = struct.unpack(pattern, str[start:end])
         return self
     except struct.error as e:
         raise genpy.DeserializationError(e)  #most likely buffer underfill
示例#32
0
############################################################################

MAX_IDENT_LENGTH = 50

FRAME_TYPE_PROTOCOL_VERSION = 0
FRAME_TYPE_INCOMPATIBLE_PROTOCOL = 1
FRAME_TYPE_IDENTIFICATION = 2
FRAME_TYPE_MESSAGE = 3
FRAME_TYPE_PING = 4
FRAME_TYPE_P0NG = 5

FRAME_TYPE_TYPE = "B"
FRAME_TYPE_SIZE = 1  # 1 byte

FRAME_FORMAT_PROTOCOL_VERSION = "!I"
FRAME_FORMAT_PROTOCOL_VERSION_SIZE = struct.calcsize(FRAME_FORMAT_PROTOCOL_VERSION)
FRAME_FORMAT_MESSAGE = "!16sII"
FRAME_FORMAT_MESSAGE_SIZE = struct.calcsize(FRAME_FORMAT_MESSAGE)

MIN_FRAME_SIZE = 1  # just the type field

INFINITE_TTL = 0xffffffff

ENCODING = "utf-8"

#############################################################################
#############################################################################

class Messaging(object):
    def __init__(self, identifier, domain, packeter, queues_storage=None):
        """
 def deserialize(self, str):
   """
   unpack serialized message in str into this message instance
   :param str: byte array of serialized message, ``str``
   """
   try:
     if self.mod_paths is None:
       self.mod_paths = None
     end = 0
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     self.mod_paths = []
     for i in range(0, length):
       val1 = ramp_msgs.msg.Path()
       start = end
       end += 4
       (length,) = _struct_I.unpack(str[start:end])
       val1.points = []
       for i in range(0, length):
         val2 = ramp_msgs.msg.KnotPoint()
         _v6 = val2.motionState
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v6.positions = struct.unpack(pattern, str[start:end])
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v6.velocities = struct.unpack(pattern, str[start:end])
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v6.accelerations = struct.unpack(pattern, str[start:end])
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v6.jerks = struct.unpack(pattern, str[start:end])
         start = end
         end += 8
         (_v6.time,) = _get_struct_d().unpack(str[start:end])
         start = end
         end += 4
         (val2.stopTime,) = _get_struct_I().unpack(str[start:end])
         val1.points.append(val2)
       self.mod_paths.append(val1)
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
示例#34
0
 def deserialize_numpy(self, str, numpy):
     """
 unpack serialized message in str into this message instance using numpy for array types
 :param str: byte array of serialized message, ``str``
 :param numpy: numpy python module
 """
     try:
         if self.poses is None:
             self.poses = None
         end = 0
         start = end
         end += 4
         (length, ) = _struct_I.unpack(str[start:end])
         self.poses = []
         for i in range(0, length):
             val1 = geometry_msgs.msg.PoseStamped()
             _v16 = val1.header
             start = end
             end += 4
             (_v16.seq, ) = _struct_I.unpack(str[start:end])
             _v17 = _v16.stamp
             _x = _v17
             start = end
             end += 8
             (
                 _x.secs,
                 _x.nsecs,
             ) = _struct_2I.unpack(str[start:end])
             start = end
             end += 4
             (length, ) = _struct_I.unpack(str[start:end])
             start = end
             end += length
             if python3:
                 _v16.frame_id = str[start:end].decode('utf-8')
             else:
                 _v16.frame_id = str[start:end]
             _v18 = val1.pose
             _v19 = _v18.position
             _x = _v19
             start = end
             end += 24
             (
                 _x.x,
                 _x.y,
                 _x.z,
             ) = _struct_3d.unpack(str[start:end])
             _v20 = _v18.orientation
             _x = _v20
             start = end
             end += 32
             (
                 _x.x,
                 _x.y,
                 _x.z,
                 _x.w,
             ) = _struct_4d.unpack(str[start:end])
             self.poses.append(val1)
         start = end
         end += 4
         (length, ) = _struct_I.unpack(str[start:end])
         pattern = '<%sh' % length
         start = end
         end += struct.calcsize(pattern)
         self.sizes = numpy.frombuffer(str[start:end],
                                       dtype=numpy.int16,
                                       count=length)
         return self
     except struct.error as e:
         raise genpy.DeserializationError(e)  #most likely buffer underfill
示例#35
0
    def read_field_data(self):

        endian = '>'
        nfields = self.master_header['nfields']

        PROJ_LATLON = 0
        PROJ_LAMBERT_CONF = 3
        PROJ_FLAT = 8
        PROJ_POLAR_RADAR = 9
        PROJ_OBLIQUE_STEREO = 12
        PROJ_RHI_RADAR = 13

        I = self.data_types['ui32']

        data = {}
        self.field_names = []

        for i in range(nfields):

            proj_type = self.field_headers[i]['proj_type']
            offset = self.field_headers[i]['field_data_offset']
            nx = self.field_headers[i]['nx']
            ny = self.field_headers[i]['ny']
            nz = self.field_headers[i]['nz']
            field_name = self.field_headers[i]['field_name']

            encoding_type = self.field_headers[i]['encoding_type']
            data_element_nbytes = self.field_headers[i]['data_element_nbytes']
            transform_type = self.field_headers[i]['transform_type']
            scaling_type = self.field_headers[i]['scaling_type']
            scale = self.field_headers[i]['scale']
            bias = self.field_headers[i]['bias']

            self.mdvfile.seek(offset)

            vlevel_names = ['vlevel_offsets', 'vlevel_nbytes']
            vlevel_types = [str(nz) + I] * 2
            vlevel = self.read_mdv_bytes(vlevel_names, vlevel_types, endian)

            vlevel_nbytes = struct.calcsize("".join(vlevel_types))

            vdata = np.ones((nz, ny, nx), dtype=np.float)

            for j in range(len(vlevel['vlevel_nbytes'])):

                voffset = offset + vlevel['vlevel_offsets'][j] + vlevel_nbytes
                self.mdvfile.seek(voffset)

                compression = self.get_compression_info()
                uncompressed_bytes = self.decompress_data(compression)

                sdata = np.array(
                    self.scale_data(uncompressed_bytes, encoding_type,
                                    data_element_nbytes, transform_type,
                                    scaling_type, scale, bias))
                vdata[j, :, :] = sdata.reshape((ny, nx))

                if proj_type == PROJ_FLAT:
                    vdata[j, :, :] = vdata[j, ::-1, :]
                elif proj_type == PROJ_POLAR_RADAR:
                    vdata[j, :, :] = vdata[j, :, :]

            data[field_name] = vdata
            self.field_names.append(field_name)

        return data
 def deserialize_numpy(self, str, numpy):
   """
   unpack serialized message in str into this message instance using numpy for array types
   :param str: byte array of serialized message, ``str``
   :param numpy: numpy python module
   """
   try:
     if self.mod_paths is None:
       self.mod_paths = None
     end = 0
     start = end
     end += 4
     (length,) = _struct_I.unpack(str[start:end])
     self.mod_paths = []
     for i in range(0, length):
       val1 = ramp_msgs.msg.Path()
       start = end
       end += 4
       (length,) = _struct_I.unpack(str[start:end])
       val1.points = []
       for i in range(0, length):
         val2 = ramp_msgs.msg.KnotPoint()
         _v8 = val2.motionState
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v8.positions = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length)
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v8.velocities = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length)
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v8.accelerations = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length)
         start = end
         end += 4
         (length,) = _struct_I.unpack(str[start:end])
         pattern = '<%sd'%length
         start = end
         end += struct.calcsize(pattern)
         _v8.jerks = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=length)
         start = end
         end += 8
         (_v8.time,) = _get_struct_d().unpack(str[start:end])
         start = end
         end += 4
         (val2.stopTime,) = _get_struct_I().unpack(str[start:end])
         val1.points.append(val2)
       self.mod_paths.append(val1)
     return self
   except struct.error as e:
     raise genpy.DeserializationError(e) #most likely buffer underfill
示例#37
0
from collections import defaultdict
from collections import namedtuple

from chipsec.logger import *
from chipsec.file import *

import chipsec.hal.acpi_tables
import chipsec.hal.uefi

class AcpiRuntimeError (RuntimeError):
    pass

# ACPI Table Header Format
ACPI_TABLE_HEADER_FORMAT = '=4sIBB6s8sI4sI'
ACPI_TABLE_HEADER_SIZE   = struct.calcsize(ACPI_TABLE_HEADER_FORMAT) # 36
assert( 36 == ACPI_TABLE_HEADER_SIZE )

class ACPI_TABLE_HEADER( namedtuple('ACPI_TABLE_HEADER', 'Signature Length Revision Checksum OEMID OEMTableID OEMRevision CreatorID CreatorRevision') ):
    __slots__ = ()
    def __str__(self):
        return """  Table Header
------------------------------------------------------------------
  Signature        : %s
  Length           : 0x%08X
  Revision         : 0x%02X
  Checksum         : 0x%02X
  OEM ID           : %s
  OEM Table ID     : %s
  OEM Revision     : 0x%08X
  Creator ID       : %s
示例#38
0
文件: selection.py 项目: tardyp/Xpra
    def acquire(self, when):
        old_owner = self._owner()
        if when is self.IF_UNOWNED and old_owner != XNone:
            raise AlreadyOwned

        set_clipboard_data(self.clipboard, "VERSION")

        # Having acquired the selection, we have to announce our existence
        # (ICCCM 2.8, still).  The details here probably don't matter too
        # much; I've never heard of an app that cares about these messages,
        # and metacity actually gets the format wrong in several ways (no
        # MANAGER or owner_window atoms).  But might as well get it as right
        # as possible.

        # To announce our existence, we need:
        #   -- the timestamp we arrived at
        #   -- the manager selection atom
        #   -- the window that registered the selection
        # Of course, because Gtk is doing so much magic for us, we have to do
        # some weird tricks to get at these.

        # Ask ourselves when we acquired the selection:
        contents = wait_for_contents(self.clipboard, "TIMESTAMP")
        ts_data = selectiondata_get_data(contents)

        #data is a timestamp, X11 datatype is Time which is CARD32,
        #(which is 64 bits on 64-bit systems!)
        Lsize = calcsize("@L")
        if len(ts_data)==Lsize:
            ts_num = unpack("@L", ts_data[:Lsize])[0]
        else:
            ts_num = 0      #CurrentTime
            log.warn("invalid data for 'TIMESTAMP': %s", ([hex(ord(x)) for x in ts_data]))
        # Calculate the X atom for this selection:
        selection_xatom = get_xatom(self.atom)
        # Ask X what window we used:
        self._xwindow = X11Window.XGetSelectionOwner(self.atom)

        root = self.clipboard.get_display().get_default_screen().get_root_window()
        xid = get_xwindow(root)
        X11Window.sendClientMessage(xid, xid, False, StructureNotifyMask,
                          "MANAGER",
                          ts_num, selection_xatom, self._xwindow)

        if old_owner != XNone and when is self.FORCE:
            # Block in a recursive mainloop until the previous owner has
            # cleared out.
            try:
                with xsync:
                    window = get_pywindow(self.clipboard, old_owner)
                    window.set_events(window.get_events() | STRUCTURE_MASK)
                log("got window")
            except XError:
                log("Previous owner is already gone, not blocking")
            else:
                log("Waiting for previous owner to exit...")
                add_event_receiver(window, self)
                gtk_main()
                log("...they did.")
        window = get_pywindow(self.clipboard, self._xwindow)
        window.set_title("Xpra-ManagerSelection")
示例#39
0
文件: tools.py 项目: tmbinc/migen
def arch_bits():
	return struct.calcsize("P")*8
示例#40
0
MULTICAST_ADDRESS = "239.255.42.99"  # IANA, local network
PORT_COMMAND = 1510
PORT_DATA = 1511  # Default multicast group
SOCKET_BUFSIZE = 0x100000

###
### NatNet packet format ###
###

# sPacket struct (PacketClient.cpp:65)
#  - iMessage (unsigned short),
#  - nDataBytes (unsigned short),
#  - union of possible payloads (MAX_PAYLOADSIZE bytes)
PACKET_HEADER_FORMAT = "=2H"
PACKET_FORMAT = PACKET_HEADER_FORMAT + ("%dB" % MAX_PAYLOADSIZE)
MAX_PACKETSIZE = struct.calcsize(PACKET_FORMAT)

# sender payload struct (PacketClient.cpp:57)
#  - szName (string MAX_NAMELENGTH),
#  - Version (4 unsigned chars),
#  - NatNetVersion (4 unsigned chars)
SENDER_FORMAT = "=" + ("%ds" % MAX_NAMELENGTH) + "4B4B"
SenderData = namedtuple("SenderData", "appname version natnet_version")

# rigid body payload (PacketClient.cpp:586)
#  - id (int, 32 bits)
#  - x,y,z (3 floats, 3x32 bits)
#  - qx,qy,qz,qw (4 floats, 4x32 bits)
RIGIDBODY_FORMAT = "=i3f4f"
# RigidBody:
#   id is an integer
示例#41
0
import weakref
import pickle
import operator
import io
import math
import struct
import sys
import warnings

import array
from array import _array_reconstructor as array_reconstructor

try:
    # Try to determine availability of long long independently
    # of the array module under test
    struct.calcsize('@q')
    have_long_long = True
except struct.error:
    have_long_long = False

sizeof_wchar = array.array('u').itemsize


class ArraySubclass(array.array):
    pass

class ArraySubclassWithKwargs(array.array):
    def __init__(self, typecode, newarg=None):
        array.array.__init__(self)

typecodes = "ubBhHiIlLfd"
示例#42
0
文件: utils.py 项目: lordlee0702/grr
 def GetSize(cls):
   """Calculate the size of the struct."""
   format_str = "".join([x[0] for x in cls._fields])
   return struct.calcsize(format_str)