def get_sampling_rate(self):
in_rate = AvcConnection.get_plug_signal_format(self.unit.fcp, 'input',
0)
out_rate = AvcConnection.get_plug_signal_format(
self.unit.fcp, 'output', 0)
if in_rate != out_rate:
raise OSError('Unexpected state of the unit: {0}!={1}'.format(
in_rate, out_rate))
return in_rate
def get_sampling_rate_labels(self):
rates = []
for rate in AvcConnection.SAMPLING_RATES:
if not AvcConnection.ask_plug_signal_format(
self.unit.fcp, 'input', 0, rate):
continue
if not AvcConnection.ask_plug_signal_format(
self.unit.fcp, 'output', 0, rate):
continue
rates.append(rate)
return rates
def set_sampling_rate(self, rate):
if self.unit.get_property('streaming'):
raise ValueError('Packet streaming already runs.')
if rate not in self.get_sampling_rate_labels():
raise ValueError('Invalid argument for sampling rate')
old_timeout = self.unit.fcp.get_property('timeout')
# The unit tends to respond with larger interval from these requests.
self.unit.fcp.set_property('timeout', 500)
AvcConnection.set_plug_signal_format(self.unit.fcp, 'input', 0, rate)
AvcConnection.set_plug_signal_format(self.unit.fcp, 'output', 0, rate)
self.unit.fcp.set_property('timeout', old_timeout)
def set_sampling_rate(self, rate):
if self.get_property('streaming'):
raise OSError('Packet streaming starts')
curr_rate = AvcConnection.get_plug_signal_format(self.fcp, 'input', 0)
for mode, rates in self._RATE_MODES.items():
if curr_rate in rates:
break
else:
raise OSError('Invalid state for sampling rate.')
if rate not in rates:
raise ValueError('Invalid argument for sampling rate.')
AvcConnection.set_plug_signal_format(self.fcp, 'input', 0, rate)
AvcConnection.set_plug_signal_format(self.fcp, 'output', 0, rate)
def get_subunit_plug_info(cls, fcp):
subunits = {}
for page in range(AvcGeneral.MAXIMUM_SUBUNIT_PAGE + 1):
try:
info = AvcGeneral.get_subunit_info(fcp, page)
except Exception:
break
for entry in info:
subunit_type = entry['type']
maximum_id = entry['maximum-id']
for subunit_id in range(maximum_id + 1):
try:
data = AvcConnection.get_subunit_plug_info(
fcp, subunit_type, subunit_id)
except Exception:
continue
id = (subunit_type, subunit_id)
if id not in subunits:
subunits[id] = {}
for direction, count in data.items():
subunits[id][direction] = count
return subunits
def set_16bit_mode(self, target):
if target != 'none':
rate = AvcConnection.get_plug_signal_format(self.fcp, 'output', 0)
if rate not in (44100, 48000):
raise ValueError('Sampling rate should be 44100 or 48000.')
HwCmd.set_16bit_mode(self.__cache, self.fcp, target)
self.__save_cache()
def __parse_subunit_plugs(self):
subunit_plugs = {}
for page in range(AvcGeneral.MAXIMUM_SUBUNIT_PAGE + 1):
try:
subunits = AvcGeneral.get_subunit_info(self.fcp, page)
except:
break
for entry in subunits:
type = entry['type']
maximum_id = entry['maximum-id']
if type not in subunit_plugs:
subunit_plugs[type] = {}
for id in range(maximum_id + 1):
if id not in subunit_plugs[type]:
subunit_plugs[type][id] = {}
subunit_plugs[type][id]['output'] = {}
subunit_plugs[type][id]['input'] = {}
info = AvcConnection.get_subunit_plug_info(self.fcp, type, 0)
for dir, num in info.items():
for i in range(num):
plug = self.__parse_subunit_plug(dir, type, 0, i)
subunit_plugs[type][id][dir][i] = plug
return subunit_plugs
def get_supported_sampling_rates(self):
rate = AvcConnection.get_plug_signal_format(self.fcp, 'input', 0)
for mode, rates in self._RATE_MODES.items():
if rate in rates and mode in self._caps['rate-modes']:
break
else:
raise OSError('Invalid state for sampling rate.')
return rates
def _parse_supported_sampling_rates(self):
sampling_rates = {}
playback = []
capture = []
# Assume that PCM playback is available for all of models.
for rate in AvcConnection.SAMPLING_RATES:
if AvcConnection.ask_plug_signal_format(self.fcp, 'input', 0, rate):
playback.append(rate)
sleep(0.02)
# PCM capture is not always available depending on models.
for rate in AvcConnection.SAMPLING_RATES:
if AvcConnection.ask_plug_signal_format(self.fcp, 'output', 0, rate):
capture.append(rate)
self._playback_only = (len(capture) == 0)
for rate in AvcConnection.SAMPLING_RATES:
if rate in playback or rate in capture:
sampling_rates[rate] = True
return sampling_rates
def set_cd_mode(self, enable):
if enable:
if self.__cache['hw']['16bit'] != 'spdif-coax-out-1/2':
raise ValueError('16bit-mode should be spdif-coax-out-1/2.')
rate = AvcConnection.get_plug_signal_format(self.fcp, 'output', 0)
if rate != 44100:
raise ValueError('Sampling rate should be 44100.')
HwCmd.set_cd_mode(self.__cache, self.fcp, enable)
self.__save_cache()
def set_stream_formats(self, playback, capture):
if playback not in self.supported_stream_formats['playback']:
raise ValueError('Invalid argument for playback stream format')
if capture:
if self._playback_only:
raise ValueError('This unit is playback only')
if capture not in self.supported_stream_formats['capture']:
raise ValueError('Invalid argument for capture stream format')
if playback['sampling-rate'] != capture['sampling-rate']:
raise ValueError(
'Sampling rate mis-match between playback and capture')
if self._assumed:
rate = playback['sampling-rate']
AvcConnection.set_plug_signal_format(self.fcp, 'output', 0, rate)
AvcConnection.set_plug_signal_format(self.fcp, 'input', 0, rate)
else:
AvcStreamFormatInfo.set_format(self.fcp, 'input', 0, playback)
if not self._playback_only:
AvcStreamFormatInfo.set_format(self.fcp, 'output', 0, capture)
def __get_clock_plugs(self):
plugs = {}
info = AvcConnection.get_subunit_plug_info(self.fcp, 'music', 0)
for direction in ('input', 'output'):
for i in range(info[direction]):
addr = BcoPlugInfo.get_subunit_addr(direction, 'music', 0, i)
plug_type = BcoPlugInfo.get_plug_type(self.fcp, addr)
if plug_type == 'Sync':
plugs[direction] = \
AvcCcm.get_subunit_signal_addr('music', 0, i)
break
else:
raise OSError('Unexpected state of device for clock source.')
return plugs
def _parse_unit_plugs(self):
unit_plugs = {}
info = AvcConnection.get_unit_plug_info(self.fcp)
for type, params in info.items():
if type not in unit_plugs:
unit_plugs[type] = {}
unit_plugs[type]['output'] = {}
unit_plugs[type]['input'] = {}
for dir, num in params.items():
for i in range(num + 1):
try:
plug = self._parse_unit_plug(dir, type, i)
unit_plugs[type][dir][i] = plug
except:
continue
return unit_plugs
def parse_unit_plugs(cls, fcp):
unit_plugs = {}
info = AvcConnection.get_unit_plug_info(fcp)
for type, params in info.items():
if type not in unit_plugs:
unit_plugs[type] = {}
unit_plugs[type]['output'] = {}
unit_plugs[type]['input'] = {}
for dir, num in params.items():
for i in range(num + 1):
try:
plug = cls.parse_unit_plug(fcp, dir, type, i)
unit_plugs[type][dir][i] = plug
except Exception:
continue
return unit_plugs
def _parse_subunit_plugs(self):
subunit_plugs = {}
subunits = BcoSubunitInfo.get_subunits(self.fcp)
for subunit in subunits:
type = subunit['type']
id = subunit['id']
if type not in subunit_plugs:
subunit_plugs[type] = {}
if id not in subunit_plugs[type]:
subunit_plugs[type][id] = {}
subunit_plugs[type][id]['output'] = {}
subunit_plugs[type][id]['input'] = {}
info = AvcConnection.get_subunit_plug_info(self.fcp, type, 0)
for dir, num in info.items():
for i in range(num):
plug = self._parse_subunit_plug(dir, type, 0, i)
subunit_plugs[type][id][dir][i] = plug
return subunit_plugs
def get_unit_plug_list(cls, fcp):
plugs = {}
seqid = 0
units = AvcConnection.get_unit_plug_info(fcp)
for type, data in units.items():
for direction, count in data.items():
for plug_id in range(count):
# Use the same format as Plug Input/Output Specific Data
# to keep enough informaton.
plug_info = {
'dir': direction,
'mode': 'unit',
'data': {
'unit-type': type,
'plug': plug_id,
},
}
plugs['unit_{0}'.format(seqid)] = plug_info
seqid += 1
return plugs
def get_sampling_rate(self):
in_rate = AvcConnection.get_plug_signal_format(self.fcp, 'input', 0)
out_rate = AvcConnection.get_plug_signal_format(self.fcp, 'output', 0)
if in_rate != out_rate:
raise OSError('Sampling rate mismatch: ', in_rate, out_rate)
return in_rate
def get_sampling_rate(self):
return AvcConnection.get_plug_signal_format(self.fcp, 'output', 0)
def get_sampling_rate(self):
# Current rate is correctly returned from a plug 0 for output direction
# only.
return AvcConnection.get_plug_signal_format(self.unit.fcp, 'output', 0)
def set_sampling_rate(self, rate):
if rate not in self.__SUPPORTED_SAMPLING_RATES:
raise ValueError('Invalid argument for sampling rate')
AvcConnection.set_plug_signal_format(self.fcp, 'input', 0, rate)
AvcConnection.set_plug_signal_format(self.fcp, 'output', 0, rate)
