def __init__(self, kymera, endpoint_type, stream): self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log inherit_docstring(self) self.__stream = stream super(EndpointHydraSco, self).__init__(kymera, endpoint_type)
def __init__(self, cap, kymera, *args, **kwargs): self._log = logging.getLogger(__name__) if not hasattr(self, '_log') else self._log inherit_docstring(self) self._kymera = kymera cap_data = get_instance('capability_description') try: self._capability = get_capability_name(cap_data, cap) except Exception: # pylint: disable=broad-except self._capability = str(cap) self.cap_id = get_capability_id(cap_data, cap) self._cap_msg = get_capability_msgs(cap_data, cap) self._op_id = None self.__args = [] for entry in args: if not isinstance(entry, list): raise RuntimeError('arg %s invalid should be a list' % (entry)) elif len(entry) != 2: raise RuntimeError('arg %s invalid should be list of 2 elements' % (entry)) elif not isinstance(entry[1], list): raise RuntimeError('arg %s invalid should be a list' % (entry[1])) elif not isinstance(entry[0], int) and entry[0] not in self._cap_msg: raise RuntimeError('arg %s invalid msg unknown' % (entry[0])) self.__args.append(entry) for entry in kwargs: if not isinstance(kwargs[entry], list): raise RuntimeError('kwarg %s invalid should be a list' % (kwargs[entry])) elif entry not in self._cap_msg: raise RuntimeError('kwarg %s invalid msg unknown' % (entry)) self.__args.append([entry, kwargs[entry]]) super(CapabilityGeneric, self).__init__(cap, kymera, *args, **kwargs)
def __init__(self, filename, mode=MODE_DEFAULT, *args, **kwargs): inherit_docstring(self) self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log self._filename = filename self._mode = mode self._data_read = False self._param = argparse.Namespace() self._param.channels = kwargs.pop('channels', CHANNELS_DEFAULT) self._param.sample_rate = kwargs.pop('sample_rate', SAMPLE_RATE_DEFAULT) self._param.sample_width = kwargs.pop('sample_width', SAMPLE_WIDTH_DEFAULT) self._param.big_endian = kwargs.pop('big_endian', BIG_ENDIAN_DEFAULT) self._param.start_offset = kwargs.pop('start_offset', START_OFFSET_DEFAULT) if self._param.channels < 1: raise RuntimeError('channels %s invalid' % (self._param.channels)) if self._param.sample_width not in SAMPLE_WIDTH_LIST: raise RuntimeError('sample_width %s invalid' % (self._param.sample_width)) self._audio = [[] for _ in range(self._param.channels)] super(AudioRaw, self).__init__(filename, mode=mode, *args, **kwargs)
def __init__(self, uut, *args, **kwargs): inherit_docstring(self) self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log self._accmd = Accmd(uut, *args, **kwargs) super(KymeraHydra, self).__init__(uut, *args, **kwargs)
def __init__(self, stream_type, **kwargs): self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log inherit_docstring(self) # initialise default values self.__parameters = {} for entry in self.__param_schema: if entry in kwargs or self.__param_schema[entry][ PARAM_DEFAULT] is not None: self.__parameters[entry] = kwargs.pop( entry, self.__param_schema[entry][PARAM_DEFAULT]) # only if the external packetiser is not used then we can handle backing and control drive if not self.__parameters[EXTERNAL_PACKETISER]: raise RuntimeError( 'hydra_audio_metadata requires external packetiser') # this instance is associated with a hydra_audio stream self._stream_hydra_audio = get_instance('stream_hydra_audio', self.__parameters[HYDRA_AUDIO]) self._hydra_kwargs = kwargs self._hydra_kwargs.update({ HYDRA_TYPE: HYDRA_TYPE_SUBSYSTEM, HYDRA_BAC_HANDLE: 0, # we will modify this when we know the handle STREAM_FLOW_CONTROL_BLOCK_SIZE: 1, }) super(StreamHydraAudioMetadata, self).__init__(stream_type, **self._hydra_kwargs)
def __init__(self, stream_type, **kwargs): self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log inherit_docstring(self) DefaultValidatingDraft4Validator(PARAM_SCHEMA).validate(kwargs) self.__helper = argparse.Namespace() # helper modules self.__helper.uut = get_instance('uut') self.__config = argparse.Namespace() # configuration values self.__config.backing = kwargs.pop(BACKING) self.__config.device = kwargs.pop(DEVICE, 0) # currently unused self.__config.callback_data_received = None # backing=data sink stream callback self.__config.delay = None self.__data = argparse.Namespace() # data values self.__data.loop_timer_id = None # timer when looping self.__data.loop = 1 # number of loops pending self.__data.source_packetiser = None # source with packet based streaming self.__data.sink_timer_id = None # sink manual streaming timer id self.__data.sink_timer_remain = 0.0 # sink manual timer remainder self.__data.sink_audio_buffer = None # sink manual streaming audio data buffer if self.__config.backing == BACKING_FILE: self.__config.filename = kwargs.pop(FILENAME) if stream_type == STREAM_TYPE_SOURCE: self.__config.delay = kwargs.pop(DELAY, DELAY_DEFAULT) else: self.__config.delay = None self.__config.loop = kwargs.pop(LOOP, LOOP_DEFAULT) self.__config.user_callback_eof = kwargs.get( CALLBACK_EOF, lambda *args, **kwargs: None) params = getattr(self, '_init_%s_file' % (stream_type))(kwargs) params[CALLBACK_EOF] = self.__eof # required for loop else: # BACKING_DATA self.__config.sample_width = kwargs.pop(SAMPLE_WIDTH) if stream_type == STREAM_TYPE_SINK: self.__config.sample_rate = kwargs.pop(SAMPLE_RATE) self.__config.frame_size = kwargs.pop(FRAME_SIZE, FRAME_SIZE_DEFAULT) self.__config.callback_consume = kwargs.pop( CALLBACK_CONSUME, None) else: self.__config.frame_size = None self.__config.loop = 1 params = get_user_stream_config(self.__config.sample_width) self.__parameters = {} self.__parameters[HYDRA_TYPE] = HYDRA_TYPE_AUDIO_SLOT self.__parameters[HYDRA_AUDIOSLOT] = self._compute_audioslot( stream_type) if kwargs: self._log.warning('unknown kwargs:%s', str(kwargs)) super(StreamPcm, self).__init__(stream_type, **params)
def __init__(self, kymera, endpoint_type, stream): self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log inherit_docstring(self) self.__stream = stream self._log.warning('a2dp endpoints are obsolete, please use l2cap') super(EndpointHydraA2dp, self).__init__(kymera, endpoint_type)
def __init__(self, **kwargs): self._log = logging.getLogger(__name__) if not hasattr(self, '_log') else self._log inherit_docstring(self) DefaultValidatingDraft4Validator(PARAM_SCHEMA).validate(kwargs) self.__helper = argparse.Namespace() # helper modules self.__helper.uut = get_instance('uut') self.__helper.hydra_prot = get_instance('hydra_protocol') self.__helper.kalcmd = get_instance('kalcmd') self.__config = argparse.Namespace() # configuration values self.__config.service_tag = kwargs.get(SERVICE_TAG) self.__config.hci_handle = kwargs.get(HCI_HANDLE, self.__config.service_tag) self.__config.wallclock_accuracy = kwargs.get(WALLCLOCK_ACCURACY) self.__config.wallclock_handle = kwargs.get(WALLCLOCK_HANDLE) self.__config.wallclock_offset = kwargs.get(WALLCLOCK_OFFSET) self.__config.next_slot_time = kwargs.get(NEXT_SLOT_TIME) self.__config.role = kwargs.get(ROLE) self.__config.air_compression_factor = kwargs.get(AIR_COMPRESSION_FACTOR) self.__config.air_buffer_size = kwargs.get(AIR_BUFFER_SIZE) self.__config.air_packet_length = kwargs.get(AIR_PACKET_LENGTH) self.__config.tesco = kwargs.get(TESCO) self.__config.wesco = kwargs.get(WESCO) self.__config.slot_occupancy = kwargs.get(SLOT_OCCUPANCY) # calculate/update other parameters self.__config.wallclock_period = \ WALLCLOCK_UPDATE_PERIOD * (1 + self.__config.wallclock_accuracy / 1e6) if self.__config.role == ROLE_SLAVE: self.__config.to_air_latency = (self.__config.wesco + 1) * \ TIMESLOT_DURATION_US + TIMESLOT_FRACTION self.__config.from_air_latency = -125 else: self.__config.to_air_latency = -125 self.__config.from_air_latency = (self.__config.wesco + 1) * \ TIMESLOT_DURATION_US + TIMESLOT_FRACTION self.__data = argparse.Namespace() # data values self.__data.started = False # service has not been started self.__data.channel_ready = [False, False] # none of the possible channels are ready yet self.__data.bt_clock = 0 # bluetooth wallclock (2*slot) self.__data.wallclock_remain = 0 # remainder for bluetooth clock (usec units) self.__data.wallclock_timer_id = None self.__data.to_air_read_handle = None self.__data.to_air_write_handle = None self.__data.to_air_aux_handle = None self.__data.from_air_read_handle = None self.__data.from_air_write_handle = None self.__data.from_air_aux_handle = None self.__data.msg_handler = self.__helper.hydra_prot.install_message_handler( self._message_received) if kwargs: self._log.warning('unknown kwargs:%s', str(kwargs))
def __init__(self, kalcmd): inherit_docstring(self) self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log self._log.info('init kalcmd:%s', kalcmd) self._timer = Timer(kalcmd) self._message = Message(kalcmd) self._io = IO(kalcmd) self._kalcmd = kalcmd super(CrescendoUut, self).__init__(kalcmd)
def __init__(self, stream_type, **kwargs): self._log = logging.getLogger(__name__) if not hasattr(self, '_log') else self._log inherit_docstring(self) self._kalcmd = get_instance('kalcmd') # initialise default values self.__parameters = {} for entry in self.__param_schema: if entry in kwargs or self.__param_schema[entry][PARAM_DEFAULT] is not None: self.__parameters[entry] = kwargs.pop(entry, self.__param_schema[entry][PARAM_DEFAULT]) super(StreamHydra, self).__init__(stream_type, **kwargs)
def __init__(self, filename, mode=MODE_DEFAULT, *args, **kwargs): inherit_docstring(self) self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log self._filename = filename self._mode = mode self._data_read = False self._param = argparse.Namespace() self._param.channels = None self._param.sample_rate = None self._param.sample_width = None self._param.frames = 0 self._audio = [[]] if mode == MODE_READ: self._read_header() super(AudioWav, self).__init__(filename, mode=mode, *args, **kwargs)
def __init__(self, kymera, endpoint_type, *args, **kwargs): self._log = logging.getLogger(__name__) if not hasattr(self, '_log') else self._log inherit_docstring(self) kwargs = map_endpoint(self.interface, endpoint_type, kwargs) self._instance = kwargs.pop('instance', 0) self._channel = kwargs.pop('channel', 0) # initialise values self.__args = [] for entry in args: if not isinstance(entry, list): raise RuntimeError('arg %s invalid should be a list' % (entry)) elif len(entry) != 2: raise RuntimeError('arg %s invalid should be list of 2 elements' % (entry)) self.__args.append(entry) self.__args += list(kwargs.items()) super(EndpointPcmHydra, self).__init__(kymera, endpoint_type)
def __init__(self, stream_type, **kwargs): self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log inherit_docstring(self) self._helper = argparse.Namespace() self._helper.uut = get_instance('uut') self._helper.hydra_prot = get_instance('hydra_protocol') self._helper.audio_hydra = None self._msg_handler = None self._total_samples = None self._sent_samples = None # initialise default values self.__parameters = {} for entry in self.__param_schema: if entry in kwargs or self.__param_schema[entry][ PARAM_DEFAULT] is not None: self.__parameters[entry] = kwargs.pop( entry, self.__param_schema[entry][PARAM_DEFAULT]) self._hydra_kwargs = kwargs self._hydra_kwargs.update({ HYDRA_TYPE: HYDRA_TYPE_SUBSYSTEM, HYDRA_BAC_HANDLE: 0, # we will modify this when we know the handle STREAM_FLOW_CONTROL_BLOCK_SIZE: 1, }) # only if the external packetiser is not used then we can handle backing and control drive if not self.__parameters[EXTERNAL_PACKETISER]: self._hydra_kwargs.update({ STREAM_FLOW_CONTROL_DRIVE: STREAM_FLOW_CONTROL_DRIVE_KALCMD, STREAM_BACKING: STREAM_BACKING_FILE, }) super(StreamHydraAudio, self).__init__(stream_type, **self._hydra_kwargs)
def __init__(self, stream_type, **kwargs): self._log = logging.getLogger(__name__) if not hasattr( self, '_log') else self._log inherit_docstring(self) DefaultValidatingDraft4Validator(PARAM_SCHEMA).validate(kwargs) self.__helper = argparse.Namespace() # helper modules self.__helper.uut = get_instance('uut') self.__helper.hydra_prot = get_instance('hydra_protocol') self.__config = argparse.Namespace() # configuration values self.__config.backing = kwargs.pop(BACKING) self.__config.callback_data_received = None # backing=data sink stream callback self.__config.delay = None self.__config.kick_enable = kwargs.pop(KICK_ENABLE, KICK_ENABLE_DEFAULT) self.__config.device_type = kwargs.pop(DEVICE_TYPE, DEVICE_TYPE_DEFAULT) self.__config.service_tag = kwargs.pop(SERVICE_TAG, SERVICE_TAG_DEFAULT) self.__config.data_buffer_size = kwargs.pop(DATA_BUFFER_SIZE, DATA_BUFFER_SIZE_DEFAULT) self.__config.metadata_enable = kwargs.pop(METADATA_ENABLE, METADATA_ENABLE_DEFAULT) self.__config.metadata_format = kwargs.pop(METADATA_FORMAT, METADATA_FORMAT_DEFAULT) # self.__config.metadata_channel = kwargs.pop(METADATA_CHANNEL, METADATA_CHANNEL_DEFAULT) self.__config.metadata_buffer_size = kwargs.pop( METADATA_BUFFER_SIZE, METADATA_BUFFER_SIZE_DEFAULT) self.__config.ttp_delay = kwargs.pop(TTP_DELAY, TTP_DELAY_DEFAULT) self.__data = argparse.Namespace() self.__data.loop_timer_id = None # timer when looping self.__data.loop = 1 self.__data.source_packetiser = None # source with packet based streaming self.__data.source_metadata = None self.__data.source_timer_id = None self.__data.sink_timer_id = None # sink manual streaming timer id self.__data.sink_timer_remain = 0.0 # sink manual timer remainder self.__data.sink_audio_buffer = None # sink manual streaming audio data buffer self.__data.stream2 = None self.__data.total_samples = 0 self.__data.sent_samples = 0 if self.__config.backing == BACKING_FILE: self.__config.filename = kwargs.pop(FILENAME) if stream_type == STREAM_TYPE_SOURCE: self.__config.delay = kwargs.pop(DELAY, DELAY_DEFAULT) else: self.__config.delay = None self.__config.loop = kwargs.pop(LOOP, LOOP_DEFAULT) self.__config.user_callback_eof = kwargs.get( CALLBACK_EOF, lambda *args, **kwargs: None) params = getattr(self, '_init_%s_file' % (stream_type))(kwargs) params[CALLBACK_EOF] = self.__eof # required for loop else: # BACKING_DATA self.__config.sample_width = kwargs.pop(SAMPLE_WIDTH) if stream_type == STREAM_TYPE_SINK: self.__config.frame_size = kwargs.pop(FRAME_SIZE) self.__config.callback_consume = kwargs.pop( CALLBACK_CONSUME, None) else: self.__config.frame_size = None self.__config.loop = 1 params = get_user_stream_config(self.__config.sample_width) self.__parameters = {} self.__parameters[HYDRA_TYPE] = HYDRA_TYPE_SUBSYSTEM self.__parameters[ HYDRA_BAC_HANDLE] = 0 # we will modify this when we know the handle if self.__config.metadata_enable: kwargs2 = get_user_stream_config(8) kwargs2[HYDRA_TYPE] = HYDRA_TYPE_SUBSYSTEM kwargs2[ HYDRA_BAC_HANDLE] = 0 # we will modify this when we know the handle self.__data.stream2 = StreamHydra(stream_type, **kwargs2) if kwargs: self._log.warning('unknown kwargs:%s', str(kwargs)) super(StreamHydraAudioData, self).__init__(stream_type, **params)
def __init__(self, kymera, endpoint_type, endpoint_id): self._log = logging.getLogger(__name__) if not hasattr(self, '_log') else self._log inherit_docstring(self) self.__endpoint_id = endpoint_id super(EndpointStatic, self).__init__(kymera, endpoint_type)