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)
