def play_and_record(self, source_widget, recorder_widget=None):
"""Plays and records (if needed) audio.
@param source_widget: widget to do the playback
@param recorder_widget: widget to do the recording
None to skip recording.
"""
self.check_correct_audio_node_selected()
# Play, wait for some time, and then start recording if needed.
source_widget.set_playback_data(self.golden_file)
logging.debug('Start playing %s', self.golden_file.path)
source_widget.start_playback()
if recorder_widget != None:
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.debug('Start recording.')
recorder_widget.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder_widget.stop_recording()
logging.debug('Stopped recording.')
audio_test_utils.dump_cros_audio_logs(
self.host, self.audio_facade, self.resultsdir,
'after_recording')
recorder_widget.read_recorded_binary()
else:
time.sleep(self.RECORD_SECONDS)
def play_and_record(self, source_widget, recorder_widget):
"""Plays and records audio
@param source_widget: widget to do the playback
@param recorder_widget: widget to do the recording
"""
audio_test_utils.dump_cros_audio_logs(self.host, self.audio_facade,
self.resultsdir,
'before_playback')
self.check_correct_audio_node_selected()
# Play, wait for some time, and then start recording.
# This is to avoid artifact caused by codec initialization.
source_widget.set_playback_data(self.golden_file)
logging.debug('Start playing %s', self.golden_file.path)
source_widget.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.debug('Start recording.')
recorder_widget.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder_widget.stop_recording()
logging.debug('Stopped recording.')
audio_test_utils.dump_cros_audio_logs(self.host, self.audio_facade,
self.resultsdir,
'after_recording')
recorder_widget.read_recorded_binary()
def playback_record(tag):
"""Playback and record.
@param tag: file name tag.
"""
logging.info('Start recording from Chameleon.')
recorder.start_recording()
logging.info('Start playing %s on Cros device',
golden_file.path)
source.start_playback()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir,
'after_recording_' + 'tag')
source.stop_playback()
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(
self.resultsdir, "recorded_%s.raw" % tag)
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
recorder.remove_head(0.5)
def run_once(self, host):
chameleon_board = host.chameleon
factory = self.create_remote_facade_factory(host)
audio_facade = factory.create_audio_facade()
chameleon_board.reset()
jack_plugger = chameleon_board.get_audio_board().get_jack_plugger()
expected_plugged_nodes_without_audio_jack = ([], [
'POST_DSP_LOOPBACK', 'POST_MIX_LOOPBACK'
])
expected_plugged_nodes_with_audio_jack = (['HEADPHONE'], [
'MIC', 'POST_DSP_LOOPBACK', 'POST_MIX_LOOPBACK'
])
if audio_test_utils.has_internal_speaker(host):
expected_plugged_nodes_without_audio_jack[0].append(
'INTERNAL_SPEAKER')
expected_plugged_nodes_with_audio_jack[0].append(
'INTERNAL_SPEAKER')
if audio_test_utils.has_internal_microphone(host):
expected_plugged_nodes_without_audio_jack[1].append('INTERNAL_MIC')
expected_plugged_nodes_with_audio_jack[1].append('INTERNAL_MIC')
# Modify expected nodes for special boards.
board_name = host.get_board().split(':')[1]
if board_name == 'link':
expected_plugged_nodes_without_audio_jack[1].append('KEYBOARD_MIC')
expected_plugged_nodes_with_audio_jack[1].append('KEYBOARD_MIC')
if board_name == 'samus':
expected_plugged_nodes_without_audio_jack[1].append('AOKR')
expected_plugged_nodes_with_audio_jack[1].append('AOKR')
audio_test_utils.check_plugged_nodes(
audio_facade, expected_plugged_nodes_without_audio_jack)
try:
jack_plugger.plug()
time.sleep(self.DELAY_AFTER_PLUGGING)
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir)
audio_test_utils.check_plugged_nodes(
audio_facade, expected_plugged_nodes_with_audio_jack)
finally:
jack_plugger.unplug()
time.sleep(self.DELAY_AFTER_UNPLUGGING)
audio_test_utils.check_plugged_nodes(
audio_facade, expected_plugged_nodes_without_audio_jack)
def play_and_record(self, recorder_widget):
"""Plays and records audio
@param recorder_widget: widget to do the recording
"""
audio_test_utils.dump_cros_audio_logs(
self.host, self.audio_facade, self.resultsdir,
'before_playback')
self.check_correct_audio_node_selected()
browser_facade = self.factory.create_browser_facade()
host_file = os.path.join('/tmp',
os.path.basename(self.test_playback_file))
with tempfile.NamedTemporaryFile() as tmpfile:
file_utils.download_file(self.test_playback_file, tmpfile.name)
os.chmod(tmpfile.name, 0444)
self.host.send_file(tmpfile.name, host_file)
logging.debug('Copied the file on the DUT at %s', host_file)
# Play, wait for some time, and then start recording.
# This is to avoid artifact caused by codec initialization.
browser_facade.new_tab('file://' + host_file)
logging.info('Start playing %s on Cros device', host_file)
time.sleep(self.SHORT_WAIT)
logging.debug('Suspend.')
self.suspend_resume()
logging.debug('Resume.')
time.sleep(self.SHORT_WAIT)
logging.debug('Start recording.')
recorder_widget.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder_widget.stop_recording()
logging.debug('Stopped recording.')
audio_test_utils.dump_cros_audio_logs(
self.host, self.audio_facade, self.resultsdir,
'after_recording')
recorder_widget.read_recorded_binary()
def run_once(self, host, suspend=False, disable=False, disconnect=False):
"""Runs bluetooth audio connection test."""
self.host = host
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
self.audio_facade = factory.create_audio_facade()
chameleon_board = host.chameleon
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.BLUETOOTH_HEADPHONE)
bluetooth_widget = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.BLUETOOTH_DATA_RX)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEIN)
binder = widget_factory.create_binder(source, bluetooth_widget,
recorder)
with chameleon_audio_helper.bind_widgets(binder):
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir,
'after_binding')
if audio_test_utils.has_internal_microphone(host):
self.audio_facade.set_chrome_active_node_type(
None, 'BLUETOOTH')
audio_test_utils.check_audio_nodes(self.audio_facade,
(['BLUETOOTH'], ['BLUETOOTH']))
# Monitors there is no node change in this time period.
with audio_test_utils.monitor_no_nodes_changed(
self.audio_facade, self.dump_logs_after_nodes_changed):
logging.debug('Monitoring NodesChanged signal for %s seconds',
self.CONNECTION_TEST_TIME_SECS)
time.sleep(self.CONNECTION_TEST_TIME_SECS)
def play_reboot_play_and_record(self, source_widget, recorder_widget):
"""Play audio, then reboot, and play and record.
@param source_widget: source widget to play with
@param recorder_widget: recorder widget to record with
"""
self.play_and_record(source_widget)
# Disconnecs audio bus so Cros device can detects plugger correctly
# when the test involes plugger.
# For case where audio bus is used but no plugger is used, it is no
# harm to disconnect audio bus and reconnect it.
if self.use_audio_bus:
logging.info('Disconnecting audio bus before reboot')
self.widget_link.disconnect_audio_bus()
self.host.reboot()
utils.poll_for_condition(
condition=self.factory.ready,
timeout=self.PRC_RECONNECT_TIMEOUT,
)
logging.debug('After reboot')
audio_test_utils.dump_cros_audio_logs(self.host, self.audio_facade,
self.resultsdir, 'after_reboot')
self.check_correct_audio_node_selected()
if self.use_audio_bus:
logging.info('Reconnecting audio bus after reboot before playback')
self.widget_link.reconnect_audio_bus()
audio_test_utils.dump_cros_audio_logs(self.host, self.audio_facade,
self.resultsdir,
'after_bus_reconnect')
self.play_and_record(source_widget, recorder_widget)
def dump_logs_after_nodes_changed(self):
"""Dumps the log after unexpected NodesChanged signal happens."""
audio_test_utils.dump_cros_audio_logs(
self.host, self.audio_facade, self.resultsdir,
'after_nodes_changed')
def run_once(self, host, suspend=False,
disable=False, disconnect=False, check_quality=False):
"""Running Bluetooth basic audio tests
@param host: device under test host
@param suspend: suspend flag to enable suspend before play/record
@param disable: disable flag to disable BT module before play/record
@param disconnect: disconnect flag to disconnect BT module
before play/record
@param check_quality: flag to check audio quality.
"""
self.host = host
golden_file = audio_test_data.FREQUENCY_TEST_FILE
factory = self.create_remote_facade_factory(host)
self.audio_facade = factory.create_audio_facade()
chameleon_board = host.chameleon
chameleon_board.reset()
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.BLUETOOTH_HEADPHONE)
bluetooth_widget = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.BLUETOOTH_DATA_RX)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEIN)
binder = widget_factory.create_binder(
source, bluetooth_widget, recorder)
with chameleon_audio_helper.bind_widgets(binder):
audio_test_utils.dump_cros_audio_logs(
host, self.audio_facade, self.resultsdir, 'after_binding')
# Checks the node selected by Cras is correct.
audio_test_utils.check_audio_nodes(self.audio_facade,
(['BLUETOOTH'], None))
self.audio_facade.set_selected_output_volume(80)
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by codec initialization.
source.set_playback_data(golden_file)
# Create link to control BT adapter.
link = binder.get_binders()[0].get_link()
if disable:
self.disable_enable_bt(link)
if disconnect:
self.disconnect_connect_bt(link)
if suspend:
audio_test_utils.suspend_resume(host, self.SUSPEND_SECONDS)
utils.poll_for_condition(condition=factory.ready,
timeout=self.PRC_RECONNECT_TIMEOUT,
desc='multimedia server reconnect')
if disable or disconnect or suspend:
audio_test_utils.dump_cros_audio_logs(
host, self.audio_facade, self.resultsdir,
'after_action')
# Gives DUT some time to auto-reconnect bluetooth after resume.
if suspend:
utils.poll_for_condition(
condition=self.bluetooth_nodes_plugged,
timeout=self.BLUETOOTH_RECONNECT_TIMEOUT_SECS,
desc='bluetooth node auto-reconnect after suspend')
# Delay some time for A2DP to be reconnected.
# Normally this happens several seconds after HSP is
# reconnected. However, there is no event what we can wait for,
# so just wait some time.
time.sleep(self.DELAY_FOR_A2DP_RECONNECT_AFTER_SUSPEND)
with audio_test_utils.monitor_no_nodes_changed(
self.audio_facade, self.dump_logs_after_nodes_changed):
# Checks the node selected by Cras is correct again.
audio_test_utils.check_audio_nodes(self.audio_facade,
(['BLUETOOTH'], None))
logging.info('Start playing %s on Cros device',
golden_file.path)
source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Chameleon.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(
host, self.audio_facade, self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Chameleon codec initialization in the beginning of
# recording.
recorder.remove_head(0.5)
recorded_file = os.path.join(self.resultsdir, "recorded_clipped.raw")
logging.info('Saving clipped data to %s', recorded_file)
recorder.save_file(recorded_file)
# Compares data by frequency. Audio signal recorded by microphone has
# gone through analog processing and through the air.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(
golden_file, recorder, check_anomaly=check_quality)
def run_once(self, host, check_quality=False):
"""Running basic headphone audio tests.
@param host: device under test host
@param check_quality: flag to check audio quality.
"""
if not audio_test_utils.has_headphone(host):
return
golden_file = audio_test_data.FREQUENCY_TEST_FILE
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.HEADPHONE)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEIN)
binder = widget_factory.create_binder(source, recorder)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
audio_test_utils.check_audio_nodes(audio_facade,
(['HEADPHONE'], None))
logging.info('Setting playback data on Cros device')
source.set_playback_data(golden_file)
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by codec initialization.
logging.info('Start playing %s on Cros device', golden_file.path)
source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Chameleon.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
if check_quality:
# Add a silence while recording to detect audio
# spikes after playback.
time.sleep(self.SILENCE_WAIT)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Chameleon codec initialization in the beginning of
# recording.
recorder.remove_head(0.5)
recorded_file = os.path.join(self.resultsdir, "recorded_clipped.raw")
logging.info('Saving clipped data to %s', recorded_file)
recorder.save_file(recorded_file)
# Compares data by frequency. Headphone audio signal has gone through
# analog processing. This suffers from codec artifacts and noise on the
# path. Comparing data by frequency is more robust than comparing by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(
golden_file, recorder, check_artifacts=check_quality)
def play_and_record(self, host, player, channel):
"""Play file using given details and record playback.
The recording is accessible through the recorder object and doesn't
need to be returned explicitly.
@param host: The DUT.
@param player: String name of audio player we intend to use.
@param channel: Either 'left' or 'right'
"""
#audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir,
'before_recording_' + channel)
# Verify that output node is correct.
output_nodes, _ = self.audio_facade.get_selected_node_types()
if output_nodes != ['INTERNAL_SPEAKER']:
raise error.TestFail(
'%s rather than internal speaker is selected on Cros '
'device' % output_nodes)
self.audio_facade.set_selected_output_volume(80)
if player == 'native':
data_format = dict(file_type='raw',
sample_format='S16_LE',
channel=2,
rate=48000)
if channel == 'left':
frequencies = [440, 0]
else:
frequencies = [0, 440]
sound_file = audio_test_data.GenerateAudioTestData(
data_format=data_format,
path=os.path.join(self.bindir, '440_half.raw'),
duration_secs=10,
frequencies=frequencies)
logging.info('Going to use cras_test_client on CrOS')
logging.info('Playing the file %s', sound_file)
self.sound_source.set_playback_data(sound_file)
self.sound_source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
self.sound_recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
self.sound_recorder.stop_recording()
self.sound_source.stop_playback()
sound_file.delete()
logging.info('Recording finished. Was done in format %s',
self.sound_recorder.data_format)
elif player == 'browser':
if channel == 'left':
sound_file = self.LEFT_WAV_FILE_URL
else:
sound_file = self.RIGHT_WAV_FILE_URL
tab_descriptor = self.browser_facade.new_tab(sound_file)
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Chameleon.')
self.sound_recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
self.sound_recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
self.browser_facade.close_tab(tab_descriptor)
else:
raise error.TestFail('%s is not in list of accepted audio players',
player)
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir,
'after_recording_' + channel)
def run_once(self, host):
if not audio_test_utils.has_internal_microphone(host):
return
golden_file = audio_test_data.SIMPLE_FREQUENCY_TEST_FILE
chameleon_board = host.chameleon
factory = self.create_remote_facade_factory(host)
chameleon_board.reset()
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEOUT)
sink = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.SPEAKER)
binder = widget_factory.create_binder(source, sink)
recorder = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.INTERNAL_MIC)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_binding')
_, input_nodes = audio_facade.get_selected_node_types()
if input_nodes != ['INTERNAL_MIC']:
raise error.TestFail(
'%s rather than internal mic is selected on Cros '
'device' % input_nodes)
logging.info('Setting playback data on Chameleon')
source.set_playback_data(golden_file)
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by chameleon codec initialization
# in the beginning of playback.
logging.info('Start playing %s from Chameleon',
golden_file.path)
source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Cros device.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Cros device.')
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Cros device.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Cros device codec initialization in the beginning of
# recording.
recorder.remove_head(1.0)
# Removes noise by a lowpass filter.
recorder.lowpass_filter(1500)
recorded_file = os.path.join(self.resultsdir, "recorded_filtered.raw")
logging.info('Saving filtered data to %s', recorded_file)
recorder.save_file(recorded_file)
# Cros device only records one channel data. Here we set the channel map
# of the recorder to compare the recorded data with left channel of the
# test data. This is fine as left and right channel of test data are
# identical.
recorder.channel_map = [0]
# Compares data by frequency. Audio signal from Chameleon Line-Out to
# speaker and finally recorded on Cros device using internal microphone
# has gone through analog processing and through the air.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing them by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(golden_file, recorder,
second_peak_ratio=0.2)
def run_once(self, host, suspend=False, while_playback=False):
"""Running basic HDMI audio tests.
@param host: device under test host
@param suspend: whether to suspend
@param while_playback: whether to suspend while audio playback
"""
golden_file = audio_test_data.SWEEP_TEST_FILE
self.host = host
# Dump audio diagnostics data for debugging.
chameleon_board = host.chameleon
self.factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
# For DUTs with permanently connected audio jack cable
# connecting HDMI won't switch automatically the node. Adding
# audio_jack_plugged flag to select HDMI node after binding.
audio_facade = self.factory.create_audio_facade()
output_nodes, _ = audio_facade.get_selected_node_types()
audio_jack_plugged = False
if output_nodes == ['HEADPHONE']:
audio_jack_plugged = True
logging.debug('Found audio jack plugged!')
self._system_facade = self.factory.create_system_facade()
self.set_high_performance_mode()
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
self.factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.HDMI)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.HDMI)
binder = widget_factory.create_binder(source, recorder)
with chameleon_audio_helper.bind_widgets(binder):
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_binding')
# HDMI node needs to be selected, when audio jack is plugged
if audio_jack_plugged:
audio_facade.set_chrome_active_node_type('HDMI', None)
audio_test_utils.check_audio_nodes(audio_facade,
(['HDMI'], None))
# Suspend after playing audio (if directed) and resume
# before the HDMI audio test.
if suspend:
self.playback_and_suspend(audio_facade, while_playback)
source.set_playback_data(golden_file)
logging.info('Start recording from Chameleon.')
recorder.start_recording()
time.sleep(self.DELAY_BEFORE_PLAYBACK)
logging.info('Start playing %s on Cros device',
golden_file.path)
source.start_playback(blocking=True)
logging.info('Stopped playing %s on Cros device',
golden_file.path)
time.sleep(self.DELAY_AFTER_PLAYBACK)
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_recording')
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
recorder.read_recorded_binary()
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
audio_test_utils.compare_recorded_correlation(golden_file, recorder)
def run_once(self, host, audio_test_file):
chameleon_board = host.chameleon
factory = self.create_remote_facade_factory(host)
chameleon_board.reset()
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.HEADPHONE)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEIN)
binder = widget_factory.create_binder(source, recorder)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_binding')
output_nodes, _ = audio_facade.get_selected_node_types()
if output_nodes != ['HEADPHONE']:
raise error.TestFail(
'%s rather than headphone is selected on Cros '
'device' % output_nodes)
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by codec initialization.
logging.info('Start playing %s on Cros device',
audio_test_file)
browser_facade = factory.create_browser_facade()
tab_descriptor = browser_facade.new_tab(audio_test_file)
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Chameleon.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
browser_facade.close_tab(tab_descriptor)
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(self.resultsdir, 'recorded.raw')
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Chameleon codec initialization in the beginning of
# recording.
recorder.remove_head(0.5)
# Removes noise by a lowpass filter.
recorder.lowpass_filter(4000)
recorded_file = os.path.join(self.resultsdir, 'recorded_filtered.raw')
logging.info('Saving filtered data to %s', recorded_file)
recorder.save_file(recorded_file)
# Compares data by frequency. Headphone audio signal has gone through
# analog processing. This suffers from codec artifacts and noise on the
# path. Comparing data by frequency is more robust than comparing by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(
audio_test_data.MEDIA_HEADPHONE_TEST_FILE,
recorder, check_anomaly=True)
def run_once(self, host, cfm_speaker=False):
"""Runs Basic Audio Microphone test.
@param host: device under test CrosHost
@param cfm_speaker: whether cfm_speaker's audio is tested which is an
external USB speaker on CFM (ChromeBox For Meetings) devices.
"""
if (not cfm_speaker
and not audio_test_utils.has_internal_microphone(host)):
return
golden_file = audio_test_data.SIMPLE_FREQUENCY_TEST_1330_FILE
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEOUT)
sink = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.SPEAKER)
binder = widget_factory.create_binder(source, sink)
recorder = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.INTERNAL_MIC)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
expected_internal_mic_node = cras_configs.get_internal_mic_node(
audio_test_utils.get_board_name(host), host.get_platform())
if not cfm_speaker:
audio_test_utils.check_audio_nodes(
audio_facade, (None, [expected_internal_mic_node]))
else:
audio_test_utils.check_audio_nodes(audio_facade,
(None, ['USB']))
logging.info('Setting playback data on Chameleon')
source.set_playback_data(golden_file)
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by chameleon codec initialization
# in the beginning of playback.
logging.info('Start playing %s from Chameleon', golden_file.path)
source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Cros device.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Cros device.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Cros device.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Cros device codec initialization in the beginning of
# recording.
recorder.remove_head(1.0)
# Removes noise by a lowpass filter.
recorder.lowpass_filter(1500)
recorded_file = os.path.join(self.resultsdir, "recorded_filtered.raw")
logging.info('Saving filtered data to %s', recorded_file)
recorder.save_file(recorded_file)
# Cros device only records one channel data. Here we set the channel map
# of the recorder to compare the recorded data with left channel of the
# test data. This is fine as left and right channel of test data are
# identical.
recorder.channel_map = [0]
# Compares data by frequency. Audio signal from Chameleon Line-Out to
# speaker and finally recorded on Cros device using internal microphone
# has gone through analog processing and through the air.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing them by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(golden_file,
recorder,
second_peak_ratio=0.2)
def run_once(self,
host,
source_id,
sink_id,
recorder_id,
golden_file,
switch_hsp=False):
"""Runs record test through ARC on Cros device.
@param host: device under test, a CrosHost.
@param source_id: An ID defined in chameleon_audio_ids for source.
@param sink_id: An ID defined in chameleon_audio_ids for sink if needed.
Currently this is only used on bluetooth.
@param recorder_id: An ID defined in chameleon_audio_ids for recording.
@param golden_file: A test file defined in audio_test_data.
@param switch_hsp: Run a recording process on Cros device. This is
to trigger Cros switching from A2DP to HSP.
"""
self.host = host
if (source_id == chameleon_audio_ids.CrosIds.INTERNAL_MIC
and not audio_test_utils.has_internal_microphone(host)):
return
self.client_at = None
# Runs a client side test to start Chrome and install microphone app.
self.setup_microphone_app()
# Do not start Chrome because client side test had started it.
# Do not install autotest because client side test had installed it.
factory = remote_facade_factory.RemoteFacadeFactory(
host,
no_chrome=True,
install_autotest=False,
results_dir=self.resultsdir)
# Setup Chameleon and create widgets.
host.chameleon.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(source_id)
recorder = widget_factory.create_widget(recorder_id, use_arc=True)
# Chameleon Mic does not need binding.
binding = (recorder_id != chameleon_audio_ids.ChameleonIds.MIC)
binder = None
if binding:
if sink_id:
sink = widget_factory.create_widget(sink_id)
binder = widget_factory.create_binder(source, sink, recorder)
else:
binder = widget_factory.create_binder(source, recorder)
# Second peak ratio is determined by quality of audio path.
second_peak_ratio = audio_test_utils.get_second_peak_ratio(
source_id=source_id, recorder_id=recorder_id, is_hsp=switch_hsp)
# Wait this duration of time before stop recording.
wait_rec_secs = (arc_resource_common.MicrophoneProps.RECORD_SECS +
arc_resource_common.MicrophoneProps.RECORD_FUZZ_SECS)
with chameleon_audio_helper.bind_widgets(binder):
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
# Checks the node selected by CRAS is correct.
audio_test_utils.check_input_port(audio_facade, recorder.port_id)
if switch_hsp:
audio_test_utils.switch_to_hsp(audio_facade)
logging.info('Setting playback data on Chameleon')
source.set_playback_data(golden_file)
logging.info('Start recording from Cros device.')
recorder.start_recording()
logging.info('Start playing %s on Chameleon', golden_file.path)
source.start_playback()
time.sleep(wait_rec_secs)
recorder.stop_recording()
logging.info('Stopped recording from Cros device.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Cros.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
audio_test_utils.check_recorded_frequency(
golden_file, recorder, second_peak_ratio=second_peak_ratio)
def run_once(self, host, suspend=False):
golden_file = audio_test_data.SWEEP_TEST_FILE
chameleon_board = host.chameleon
factory = self.create_remote_facade_factory(host)
chameleon_board.reset()
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
playback_source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.USBOUT)
playback_recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.USBIN)
playback_binder = widget_factory.create_binder(playback_source,
playback_recorder)
record_source = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.USBOUT)
record_recorder = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.USBIN)
record_binder = widget_factory.create_binder(record_source,
record_recorder)
with chameleon_audio_helper.bind_widgets(playback_binder):
with chameleon_audio_helper.bind_widgets(record_binder):
# Checks the node selected by cras is correct.
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
audio_test_utils.check_audio_nodes(audio_facade,
(['USB'], ['USB']))
logging.info('Setting playback data on Cros device')
audio_facade.set_selected_output_volume(70)
playback_source.set_playback_data(golden_file)
record_source.set_playback_data(golden_file)
if suspend:
audio_test_utils.suspend_resume(host, self.SUSPEND_SECONDS)
utils.poll_for_condition(
condition=factory.ready,
timeout=self.RPC_RECONNECT_TIMEOUT,
desc='multimedia server reconnect')
audio_test_utils.check_audio_nodes(audio_facade,
(['USB'], ['USB']))
logging.info('Start recording from Chameleon.')
playback_recorder.start_recording()
logging.info('Start recording from Cros device.')
record_recorder.start_recording()
logging.info('Start playing %s on Cros device',
golden_file.path)
playback_source.start_playback()
logging.info('Start playing %s on Chameleon', golden_file.path)
record_source.start_playback()
time.sleep(self.RECORD_SECONDS)
playback_recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
record_recorder.stop_recording()
logging.info('Stopped recording from Cros device.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
playback_recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
record_recorder.read_recorded_binary()
logging.info('Read recorded binary from Cros device.')
playback_recorded_file = os.path.join(self.resultsdir,
"playback_recorded.raw")
logging.info('Saving Cros playback recorded data to %s',
playback_recorded_file)
playback_recorder.save_file(playback_recorded_file)
record_recorded_file = os.path.join(self.resultsdir,
"record_recorded.raw")
logging.info('Saving Cros record recorded data to %s',
record_recorded_file)
record_recorder.save_file(record_recorded_file)
error_messages = ''
if not chameleon_audio_helper.compare_recorded_result(
golden_file, playback_recorder, 'correlation'):
error_messages += ('Record: Recorded file does not match'
' playback file.')
if not chameleon_audio_helper.compare_recorded_result(
golden_file, record_recorder, 'correlation'):
error_messages += ('Playback: Recorded file does not match'
' playback file.')
if error_messages:
raise error.TestFail(error_messages)
def run_once(self, host):
edid_path = os.path.join(self.bindir,
'test_data/edids/HDMI_DELL_U2410.txt')
golden_file = audio_test_data.SWEEP_TEST_FILE
# Dump audio diagnostics data for debugging.
chameleon_board = host.chameleon
factory = self.create_remote_facade_factory(host)
self._system_facade = factory.create_system_facade()
self.set_high_performance_mode()
chameleon_board.reset()
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(chameleon_audio_ids.CrosIds.HDMI)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.HDMI)
binder = widget_factory.create_binder(source, recorder)
display_facade = factory.create_display_facade()
finder = chameleon_port_finder.ChameleonVideoInputFinder(
chameleon_board, display_facade)
hdmi_port = finder.find_port('HDMI')
if not hdmi_port:
raise error.TestFail(
'Can not find HDMI port, perhaps HDMI is not connected?')
with hdmi_port.use_edid_file(edid_path):
# TODO(cychiang) remove this when issue crbug.com/450101 is fixed.
audio_test_utils.correction_plug_unplug_for_audio(host, hdmi_port)
with chameleon_audio_helper.bind_widgets(binder):
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
output_nodes, _ = audio_facade.get_selected_node_types()
if output_nodes != ['HDMI']:
raise error.TestFail(
'%s rather than HDMI is selected on Cros device' %
output_nodes)
# Transfer the data to Cros device first because it takes
# several seconds.
source.set_playback_data(golden_file)
logging.info('Start recording from Chameleon.')
recorder.start_recording()
time.sleep(self.DELAY_BEFORE_PLAYBACK)
logging.info('Start playing %s on Cros device',
golden_file.path)
source.start_playback(blocking=True)
logging.info('Stopped playing %s on Cros device',
golden_file.path)
time.sleep(self.DELAY_AFTER_PLAYBACK)
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
recorder.read_recorded_binary()
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
if not chameleon_audio_helper.compare_recorded_result(
golden_file, recorder, 'correlation'):
raise error.TestFail(
'Recorded file does not match playback file')
def run_once(self, host, jack_node=False, hdmi_node=False, usb_node=False):
self.host = host
chameleon_board = host.chameleon
audio_board = chameleon_board.get_audio_board()
factory = self.create_remote_facade_factory(host)
chameleon_board.reset()
self.audio_facade = factory.create_audio_facade()
self.display_facade = factory.create_display_facade()
self.check_default_nodes()
nodes = []
if audio_test_utils.has_internal_speaker(self.host):
self.set_active_volume_to_node_volume('INTERNAL_SPEAKER')
nodes.append('INTERNAL_SPEAKER')
self.switch_nodes_and_check_volume(nodes)
if hdmi_node:
edid_path = os.path.join(self.bindir,
'test_data/edids/HDMI_DELL_U2410.txt')
finder = chameleon_port_finder.ChameleonVideoInputFinder(
chameleon_board, self.display_facade)
hdmi_port = finder.find_port('HDMI')
hdmi_port.apply_edid(edid_lib.Edid.from_file(edid_path))
time.sleep(self._APPLY_EDID_DELAY)
hdmi_port.set_plug(True)
time.sleep(self._PLUG_DELAY)
audio_test_utils.check_audio_nodes(self.audio_facade,
(['HDMI'], None))
self.set_active_volume_to_node_volume('HDMI')
nodes.append('HDMI')
self.switch_nodes_and_check_volume(nodes)
if jack_node:
jack_plugger = audio_board.get_jack_plugger()
jack_plugger.plug()
time.sleep(self._PLUG_DELAY)
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir)
audio_test_utils.check_audio_nodes(self.audio_facade,
(['HEADPHONE'], ['MIC']))
self.set_active_volume_to_node_volume('HEADPHONE')
nodes.append('HEADPHONE')
self.switch_nodes_and_check_volume(nodes)
if usb_node:
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.USBOUT)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.USBIN)
binder = widget_factory.create_binder(source, recorder)
with chameleon_audio_helper.bind_widgets(binder):
time.sleep(self._PLUG_DELAY)
audio_test_utils.check_audio_nodes(self.audio_facade,
(['USB'], ['USB']))
self.set_active_volume_to_node_volume('USB')
nodes.append('USB')
self.switch_nodes_and_check_volume(nodes)
time.sleep(self._PLUG_DELAY)
nodes.remove('USB')
self.switch_nodes_and_check_volume(nodes)
if jack_node:
if usb_node:
audio_test_utils.check_audio_nodes(self.audio_facade,
(['HEADPHONE'], ['MIC']))
jack_plugger.unplug()
time.sleep(self._PLUG_DELAY)
nodes.remove('HEADPHONE')
self.switch_nodes_and_check_volume(nodes)
if hdmi_node:
if usb_node or jack_node :
audio_test_utils.check_audio_nodes(self.audio_facade,
(['HDMI'], None))
hdmi_port.set_plug(False)
time.sleep(self._PLUG_DELAY)
nodes.remove('HDMI')
self.switch_nodes_and_check_volume(nodes)
self.check_default_nodes()
def run_once(self, host, suspend=False,
disable=False, disconnect=False, check_quality=False):
"""Running Bluetooth basic audio tests
@param host: device under test host
@param suspend: suspend flag to enable suspend before play/record
@param disable: disable flag to disable BT module before play/record
@param disconnect: disconnect flag to disconnect BT module
before play/record
@param check_quality: flag to check audio quality.
"""
self.host = host
# Bluetooth HSP/HFP profile only supports one channel
# playback/recording. So we should use simple frequency
# test file which contains identical sine waves in two
# channels.
golden_file = audio_test_data.SIMPLE_FREQUENCY_TEST_FILE
factory = self.create_remote_facade_factory(host)
self.audio_facade = factory.create_audio_facade()
chameleon_board = host.chameleon
chameleon_board.reset()
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
playback_source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.BLUETOOTH_HEADPHONE)
playback_bluetooth_widget = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.BLUETOOTH_DATA_RX)
playback_recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEIN)
playback_binder = widget_factory.create_binder(
playback_source, playback_bluetooth_widget, playback_recorder)
record_source = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEOUT)
record_bluetooth_widget = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.BLUETOOTH_DATA_TX)
record_recorder = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.BLUETOOTH_MIC)
record_binder = widget_factory.create_binder(
record_source, record_bluetooth_widget, record_recorder)
with chameleon_audio_helper.bind_widgets(playback_binder):
with chameleon_audio_helper.bind_widgets(record_binder):
audio_test_utils.dump_cros_audio_logs(
host, self.audio_facade, self.resultsdir,
'after_binding')
# Checks the input node selected by Cras is internal microphone.
# Checks crbug.com/495537 for the reason to lower bluetooth
# microphone priority.
if audio_test_utils.has_internal_microphone(host):
audio_test_utils.check_audio_nodes(self.audio_facade,
(None, ['INTERNAL_MIC']))
self.audio_facade.set_selected_output_volume(80)
# Selecting input nodes needs to be after setting volume because
# after setting volume, Cras notifies Chrome there is changes
# in nodes, and Chrome selects the output/input nodes based
# on its preference again. See crbug.com/535643.
# Selects bluetooth mic to be the active input node.
if audio_test_utils.has_internal_microphone(host):
self.audio_facade.set_chrome_active_node_type(
None, 'BLUETOOTH')
# Checks the node selected by Cras is correct.
audio_test_utils.check_audio_nodes(self.audio_facade,
(['BLUETOOTH'],
['BLUETOOTH']))
# Setup the playback data. This step is time consuming.
playback_source.set_playback_data(golden_file)
record_source.set_playback_data(golden_file)
# Create links to control disconnect and off/on BT adapter.
link = playback_binder.get_binders()[0].get_link()
if disable:
self.disable_enable_bt(link)
if disconnect:
self.disconnect_connect_bt(link)
if suspend:
audio_test_utils.suspend_resume(host, self.SUSPEND_SECONDS)
if disable or disconnect or suspend:
audio_test_utils.dump_cros_audio_logs(
host, self.audio_facade, self.resultsdir,
'after_action')
utils.poll_for_condition(condition=factory.ready,
timeout=self.PRC_RECONNECT_TIMEOUT,
desc='multimedia server reconnect')
# Gives DUT some time to auto-reconnect bluetooth after resume.
if suspend:
utils.poll_for_condition(
condition=self.bluetooth_nodes_plugged,
timeout=self.BLUETOOTH_RECONNECT_TIMEOUT_SECS,
desc='bluetooth node auto-reconnect after suspend')
if audio_test_utils.has_internal_microphone(host):
# Select again BT input, as default input node is
# INTERNAL_MIC.
self.audio_facade.set_chrome_active_node_type(
None, 'BLUETOOTH')
with audio_test_utils.monitor_no_nodes_changed(
self.audio_facade, self.dump_logs_after_nodes_changed):
# Checks the node selected by Cras is correct again.
audio_test_utils.check_audio_nodes(self.audio_facade,
(['BLUETOOTH'],
['BLUETOOTH']))
# Starts playing, waits for some time, and then starts
# recording. This is to avoid artifact caused by codec
# initialization.
logging.info('Start playing %s on Cros device',
golden_file.path)
playback_source.start_playback()
logging.info('Start playing %s on Chameleon device',
golden_file.path)
record_source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Chameleon.')
playback_recorder.start_recording()
logging.info('Start recording from Cros device.')
record_recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
playback_recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
record_recorder.stop_recording()
logging.info('Stopped recording from Cros device.')
audio_test_utils.dump_cros_audio_logs(
host, self.audio_facade, self.resultsdir,
'after_recording')
# Sleeps until playback data ends to prevent audio from
# going to internal speaker.
time.sleep(self.SLEEP_AFTER_RECORD_SECONDS)
# Gets the recorded data. This step is time consuming.
playback_recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
record_recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(
self.resultsdir, "playback_recorded.raw")
logging.info('Playback: Saving recorded data to %s',
recorded_file)
playback_recorder.save_file(recorded_file)
recorded_file = os.path.join(
self.resultsdir, "record_recorded.raw")
logging.info('Record: Saving recorded data to %s',
recorded_file)
record_recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Chameleon codec initialization in the beginning of
# recording.
playback_recorder.remove_head(0.5)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by bluetooth module initialization in the beginning of
# its playback.
record_recorder.remove_head(0.5)
recorded_file = os.path.join(self.resultsdir, "playback_clipped.raw")
logging.info('Saving clipped data to %s', recorded_file)
playback_recorder.save_file(recorded_file)
recorded_file = os.path.join(self.resultsdir, "record_clipped.raw")
logging.info('Saving clipped data to %s', recorded_file)
record_recorder.save_file(recorded_file)
# Compares data by frequency. Audio signal recorded by microphone has
# gone through analog processing and through the air.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
# Use a second peak ratio that can tolerate more noise because HSP
# is low-quality.
second_peak_ratio = audio_test_utils.HSP_SECOND_PEAK_RATIO
error_messages = ''
try:
audio_test_utils.check_recorded_frequency(
golden_file, playback_recorder, check_anomaly=check_quality,
second_peak_ratio=second_peak_ratio)
except error.TestFail, e:
error_messages += str(e)
def run_once(self, host, source_id, sink_id, recorder_id,
golden_file, switch_hsp=False,
mute_duration_in_secs=None,
volume_changes=None,
record_secs=None):
"""Running audio volume test.
mute_duration_in_secs and volume_changes couldn't be both not None.
@param host: device under test CrosHost
@param source_id: An ID defined in chameleon_audio_ids for source.
@param sink_id: An ID defined in chameleon_audio_ids for sink if needed.
Currently this is only used on bluetooth.
@param recorder: An ID defined in chameleon_audio_ids for recording.
@param golden_file: A test file defined in audio_test_data.
@param switch_hsp: Run a recording process on Cros device. This is
to trigger Cros switching from A2DP to HSP.
@param mute_duration_in_secs: List of each duration of mute. For example,
[0.4, 0.6] will have two delays, each
duration will be 0.4 secs and 0.6 secs.
And, between delays, there will be
KEEP_VOLUME_SECONDS secs sine wave.
@param volume_changes: List consisting of -1 and +1, where -1 denoting
decreasing volume, +1 denoting increasing volume.
Between each changes, the volume will be kept for
KEEP_VOLUME_SECONDS secs.
@param record_secs: The duration of recording in seconds. If it is not
set, duration of the test data will be used. If
duration of test data is not set either, default
RECORD_SECONDS will be used.
"""
if (source_id == chameleon_audio_ids.CrosIds.SPEAKER and
not audio_test_utils.has_internal_speaker(host)):
return
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(source_id)
recorder = widget_factory.create_widget(recorder_id)
# Chameleon Mic does not need binding.
binding = (recorder_id != chameleon_audio_ids.ChameleonIds.MIC)
binder = None
if binding:
if sink_id:
sink = widget_factory.create_widget(sink_id)
binder = widget_factory.create_binder(source, sink, recorder)
else:
binder = widget_factory.create_binder(source, recorder)
start_volume, low_volume, high_volume = 75, 50, 100
if not record_secs:
if golden_file.duration_secs:
record_secs = golden_file.duration_secs
else:
record_secs = self.RECORD_SECONDS
logging.debug('Record duration: %f seconds', record_secs)
# Checks if the file is local or is served on web.
file_url = getattr(golden_file, 'url', None)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_binding')
audio_facade.set_chrome_active_volume(start_volume)
audio_test_utils.check_output_port(audio_facade, source.port_id)
if switch_hsp:
audio_test_utils.switch_to_hsp(audio_facade)
if not file_url:
logging.info('Setting playback data on Cros device')
source.set_playback_data(golden_file)
logging.info('Start recording from Chameleon.')
recorder.start_recording()
if not file_url:
logging.info('Start playing %s on Cros device',
golden_file.path)
source.start_playback()
else:
logging.info('Start playing %s on Cros device using browser',
file_url)
browser_facade = factory.create_browser_facade()
tab_descriptor = browser_facade.new_tab(file_url)
if volume_changes:
time.sleep(self.START_PLAYBACK_SECONDS)
for x in volume_changes:
if x == -1:
audio_facade.set_chrome_active_volume(low_volume)
if x == +1:
audio_facade.set_chrome_active_volume(high_volume)
time.sleep(self.KEEP_VOLUME_SECONDS)
passed_time_secs = self.START_PLAYBACK_SECONDS
passed_time_secs += len(volume_changes) * self.KEEP_VOLUME_SECONDS
rest = max(0, record_secs - passed_time_secs)
time.sleep(rest)
elif mute_duration_in_secs:
time.sleep(self.START_PLAYBACK_SECONDS)
passed_time_seconds = self.START_PLAYBACK_SECONDS
for mute_secs in mute_duration_in_secs:
audio_facade.set_chrome_active_volume(0)
time.sleep(mute_secs)
audio_facade.set_chrome_active_volume(start_volume)
time.sleep(self.KEEP_VOLUME_SECONDS)
passed_time_seconds += mute_secs + self.KEEP_VOLUME_SECONDS
rest = max(0, record_secs - passed_time_seconds)
time.sleep(rest)
else:
time.sleep(record_secs)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir,
'after_recording')
if file_url:
browser_facade.close_tab(tab_descriptor)
else:
source.stop_playback()
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(
self.resultsdir, "recorded.raw" )
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
audio_test_utils.check_recorded_frequency(
golden_file, recorder,
check_artifacts=True,
mute_durations=mute_duration_in_secs,
volume_changes=volume_changes)
def run_once(self, host, suspend=False):
"""Runs Basic Audio Hotwording test.
@param host: device under test CrosHost
@param suspend: True for suspend the device before playing hotword.
False for hotwording test suspend.
"""
if (not audio_test_utils.has_hotwording(host)):
return
hotword_file = audio_test_data.HOTWORD_TEST_FILE
golden_file = audio_test_data.SIMPLE_FREQUENCY_TEST_1330_FILE
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEOUT)
sink = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.SPEAKER)
binder = widget_factory.create_binder(source, sink)
listener = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.HOTWORDING)
with chameleon_audio_helper.bind_widgets(binder):
time.sleep(self.DELAY_AFTER_BINDING_SECS)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_binding')
logging.info('Start listening from Cros device.')
listener.start_listening()
time.sleep(self.DELAY_AFTER_START_LISTENING_SECS)
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir,
'after_start_listening')
if suspend:
def suspend_host():
logging.info('Suspend the DUT for %d secs',
self.SUSPEND_SECONDS)
host.suspend(suspend_time=self.SUSPEND_SECONDS,
allow_early_resume=True)
# Folk a thread to suspend the host
boot_id = host.get_boot_id()
thread = threading.Thread(target=suspend_host)
thread.start()
suspend_start_time = time.time()
time.sleep(self.DELAY_AFTER_SUSPEND_SECS)
# Starts playing hotword and golden file.
# Sleep for 5s for DUT to detect and record the sounds
logging.info('Setting hotword playback data on Chameleon')
remote_hotword_file_path = source.set_playback_data(hotword_file)
logging.info('Setting golden playback data on Chameleon')
remote_golden_file_path = source.set_playback_data(golden_file)
logging.info('Start playing %s from Chameleon',
hotword_file.path)
source.start_playback_with_path(remote_hotword_file_path)
time.sleep(hotword_file.duration_secs)
logging.info('Start playing %s from Chameleon',
golden_file.path)
source.start_playback_with_path(remote_golden_file_path)
time.sleep(self.RECORD_SECONDS)
# If the DUT suspended, the server will reconnect to DUT
if suspend:
host.test_wait_for_resume(boot_id, self.RESUME_TIMEOUT_SECS)
real_suspend_time = time.time() - suspend_start_time
logging.info('Suspend for %f time.', real_suspend_time)
# Check the if real suspend time is less than SUSPEND_SECOND
if real_suspend_time < self.SUSPEND_SECONDS:
logging.info('Real suspend time is less than '
'SUSPEND_SECONDS. Hotwording succeeded.')
else:
logging.error('Real suspend time is larger than or equal to'
'SUSPEND_SECONDS. Hostwording failed.')
listener.stop_listening()
logging.info('Stopped listening from Cros device.')
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_listening')
listener.read_recorded_binary()
logging.info('Read recorded binary from Cros device.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
listener.save_file(recorded_file)
# Removes the first 5s of recorded data, which included hotword and
# the data before hotword.
listener.remove_head(5.0)
short_recorded_file = os.path.join(self.resultsdir,
"short_recorded.raw")
listener.save_file(short_recorded_file)
# Cros device only records one channel data. Here we set the channel map
# of the recorder to compare the recorded data with left channel of the
# test data. This is fine as left and right channel of test data are
# identical.
listener.channel_map = [0]
# Compares data by frequency. Audio signal from Chameleon Line-Out to
# speaker and finally recorded on Cros device using hotwording chip
# has gone through analog processing and through the air.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing them by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(golden_file, listener,
second_peak_ratio=0.2)
def run_once(self, host, suspend=False):
golden_file = audio_test_data.SWEEP_TEST_FILE
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.USBOUT)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.USBIN)
binder = widget_factory.create_binder(source, recorder)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
audio_test_utils.check_and_set_chrome_active_node_types(
audio_facade, 'USB', None)
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_select')
audio_test_utils.check_audio_nodes(audio_facade, (['USB'], None))
logging.info('Setting playback data on Cros device')
audio_facade.set_selected_output_volume(70)
source.set_playback_data(golden_file)
if suspend:
audio_test_utils.suspend_resume(host, self.SUSPEND_SECONDS)
utils.poll_for_condition(condition=factory.ready,
timeout=self.RPC_RECONNECT_TIMEOUT,
desc='multimedia server reconnect')
audio_test_utils.check_audio_nodes(audio_facade,
(['USB'], None))
# Starts recording from Chameleon, waits for some time, and then
# starts playing from Cros device.
logging.info('Start recording from Chameleon.')
recorder.start_recording()
logging.info('Start playing %s on Cros device', golden_file.path)
source.start_playback()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
audio_test_utils.compare_recorded_correlation(golden_file, recorder)
def run_once(self,
host,
suspend=False,
disable=False,
disconnect=False,
check_quality=False):
"""Running Bluetooth basic audio tests
@param host: device under test host
@param suspend: suspend flag to enable suspend before play/record
@param disable: disable flag to disable BT module before play/record
@param disconnect: disconnect flag to disconnect BT module
before play/record
@param check_quality: flag to check audio quality.
"""
self.host = host
golden_file = audio_test_data.SIMPLE_FREQUENCY_TEST_FILE
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
self.audio_facade = factory.create_audio_facade()
chameleon_board = host.chameleon
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEOUT)
bluetooth_widget = widget_factory.create_widget(
chameleon_audio_ids.PeripheralIds.BLUETOOTH_DATA_TX)
recorder = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.BLUETOOTH_MIC)
binder = widget_factory.create_binder(source, bluetooth_widget,
recorder)
second_peak_ratio = audio_test_utils.get_second_peak_ratio(
source_id=source.port_id,
recorder_id=recorder.port_id,
is_hsp=True)
with chameleon_audio_helper.bind_widgets(binder):
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir,
'after_binding')
# For DUTs with permanently connected audio jack cable
# Bluetooth output node should be selected explicitly.
output_nodes, _ = self.audio_facade.get_plugged_node_types()
audio_jack_plugged = False
if 'HEADPHONE' in output_nodes or 'LINEOUT' in output_nodes:
audio_jack_plugged = True
audio_test_utils.check_audio_nodes(self.audio_facade,
(None, ['MIC']))
elif audio_test_utils.has_internal_microphone(host):
# Checks the input node selected by Cras is internal microphone.
# Checks crbug.com/495537 for the reason to lower bluetooth
# microphone priority.
audio_test_utils.check_audio_nodes(self.audio_facade,
(None, ['INTERNAL_MIC']))
# Selects bluetooth mic to be the active input node.
if (audio_test_utils.has_internal_microphone(host)
or audio_jack_plugged):
self.audio_facade.set_chrome_active_node_type(
None, 'BLUETOOTH')
# Checks the node selected by Cras is correct again.
audio_test_utils.check_audio_nodes(self.audio_facade,
(None, ['BLUETOOTH']))
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by codec initialization.
source.set_playback_data(golden_file)
# Create link to control BT adapter.
link = binder.get_binders()[1].get_link()
if disable:
self.disable_enable_bt(link)
if disconnect:
self.disconnect_connect_bt(link)
if suspend:
audio_test_utils.suspend_resume(host, self.SUSPEND_SECONDS)
utils.poll_for_condition(condition=factory.ready,
timeout=self.PRC_RECONNECT_TIMEOUT,
desc='multimedia server reconnect')
if disable or disconnect or suspend:
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir,
'after_action')
# Gives DUT some time to auto-reconnect bluetooth after resume.
if suspend:
utils.poll_for_condition(
condition=self.bluetooth_nodes_plugged,
timeout=self.BLUETOOTH_RECONNECT_TIMEOUT_SECS,
desc='bluetooth node auto-reconnect after suspend')
if audio_test_utils.has_internal_microphone(host):
# Select again BT input as default input node is INTERNAL_MIC
self.audio_facade.set_chrome_active_node_type(
None, 'BLUETOOTH')
with audio_test_utils.monitor_no_nodes_changed(
self.audio_facade, self.dump_logs_after_nodes_changed):
audio_test_utils.check_audio_nodes(self.audio_facade,
(None, ['BLUETOOTH']))
logging.info('Start playing %s on Chameleon', golden_file.path)
source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Cros device.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Cros device.')
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by bluetooth module initialization in the beginning of
# its playback.
recorder.remove_head(0.5)
recorded_file = os.path.join(self.resultsdir, "recorded_clipped.raw")
logging.info('Saving clipped data to %s', recorded_file)
recorder.save_file(recorded_file)
# Compares data by frequency. Audio signal recorded by microphone has
# gone through analog processing and through the air.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(
golden_file,
recorder,
check_anomaly=check_quality,
second_peak_ratio=second_peak_ratio)
def run_once(self, host, source_id, sink_id, recorder_id, volume_spec,
golden_file, switch_hsp=False):
"""Running audio volume test.
@param host: device under test CrosHost
@param source_id: An ID defined in chameleon_audio_ids for source.
@param sink_id: An ID defined in chameleon_audio_ids for sink if needed.
Currently this is only used on bluetooth.
@param recorder: An ID defined in chameleon_audio_ids for recording.
@param volume_spec: A tuple (low_volume, high_volume, highest_ratio).
Low volume and high volume specifies the two volumes
used in the test, and highest_ratio speficies the
highest acceptable value for
recorded_volume_low / recorded_volume_high.
For example, (50, 100, 0.2) asserts that
(recorded magnitude at volume 50) should be lower
than (recorded magnitude at volume 100) * 0.2.
@param golden_file: A test file defined in audio_test_data.
@param switch_hsp: Run a recording process on Cros device. This is
to trigger Cros switching from A2DP to HSP.
"""
if (source_id == chameleon_audio_ids.CrosIds.SPEAKER and
not audio_test_utils.has_internal_speaker(host)):
return
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(source_id)
recorder = widget_factory.create_widget(recorder_id)
# Chameleon Mic does not need binding.
binding = (recorder_id != chameleon_audio_ids.ChameleonIds.MIC)
binder = None
if binding:
if sink_id:
sink = widget_factory.create_widget(sink_id)
binder = widget_factory.create_binder(source, sink, recorder)
else:
binder = widget_factory.create_binder(source, recorder)
low_volume, high_volume, highest_ratio = volume_spec
ignore_frequencies = [50, 60]
second_peak_ratio = audio_test_utils.get_second_peak_ratio(
source_id=source_id,
recorder_id=recorder_id,
is_hsp=switch_hsp)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir, 'after_binding')
audio_test_utils.check_output_port(audio_facade, source.port_id)
if switch_hsp:
audio_test_utils.switch_to_hsp(audio_facade)
logging.info('Setting playback data on Cros device')
source.set_playback_data(golden_file)
def playback_record(tag):
"""Playback and record.
@param tag: file name tag.
"""
logging.info('Start recording from Chameleon.')
recorder.start_recording()
logging.info('Start playing %s on Cros device',
golden_file.path)
source.start_playback()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(
host, audio_facade, self.resultsdir,
'after_recording_' + 'tag')
source.stop_playback()
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(
self.resultsdir, "recorded_%s.raw" % tag)
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
recorder.remove_head(0.5)
audio_facade.set_chrome_active_volume(low_volume)
playback_record('low')
low_dominant_spectrals = audio_test_utils.check_recorded_frequency(
golden_file, recorder,
second_peak_ratio=second_peak_ratio,
ignore_frequencies=ignore_frequencies)
audio_facade.set_chrome_active_volume(high_volume)
playback_record('high')
high_dominant_spectrals = audio_test_utils.check_recorded_frequency(
golden_file, recorder,
second_peak_ratio=second_peak_ratio,
ignore_frequencies=ignore_frequencies)
error_messages = []
logging.info('low_dominant_spectrals: %s', low_dominant_spectrals)
logging.info('high_dominant_spectrals: %s', high_dominant_spectrals)
for channel in xrange(len(low_dominant_spectrals)):
_, low_coeff = low_dominant_spectrals[channel]
_, high_coeff = high_dominant_spectrals[channel]
ratio = low_coeff / high_coeff
logging.info('Channel %d volume(at %f) / volume(at %f) = %f',
channel, low_volume, high_volume, ratio)
if ratio > highest_ratio:
error_messages.append(
'Channel %d volume ratio: %f is incorrect.' % (
channel, ratio))
if error_messages:
raise error.TestFail(
'Failed volume check: %s' % ' '.join(error_messages))
def run_once(self, host):
if not audio_test_utils.has_internal_speaker(host):
return
golden_file = audio_test_data.SIMPLE_FREQUENCY_SPEAKER_TEST_FILE
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.SPEAKER)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.MIC)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir, 'start')
# Checks the node selected by cras is correct.
output_nodes, _ = audio_facade.get_selected_node_types()
if output_nodes != ['INTERNAL_SPEAKER']:
raise error.TestFail(
'%s rather than internal speaker is selected on Cros '
'device' % output_nodes)
audio_facade.set_selected_output_volume(80)
logging.info('Setting playback data on Cros device')
source.set_playback_data(golden_file)
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by codec initialization.
logging.info('Start playing %s on Cros device', golden_file.path)
source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Chameleon.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Chameleon codec initialization in the beginning of
# recording.
recorder.remove_head(0.5)
# Removes noise by a lowpass filter.
recorder.lowpass_filter(1000)
recorded_file = os.path.join(self.resultsdir, "recorded_filtered.raw")
logging.info('Saving filtered data to %s', recorded_file)
recorder.save_file(recorded_file)
# Compares data by frequency. Audio signal recorded by microphone has
# gone through analog processing and through the air.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(golden_file,
recorder,
second_peak_ratio=0.1,
ignore_frequencies=[50, 60])
def run_once(self, host, check_quality=False):
"""Running basic headphone audio tests.
@param host: device under test host
@param check_quality: flag to check audio quality.
"""
golden_file = audio_test_data.SIMPLE_FREQUENCY_TEST_FILE
chameleon_board = host.chameleon
factory = self.create_remote_facade_factory(host)
chameleon_board.reset()
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEOUT)
recorder = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.EXTERNAL_MIC)
binder = widget_factory.create_binder(source, recorder)
with chameleon_audio_helper.bind_widgets(binder):
# Checks the node selected by cras is correct.
time.sleep(self.DELAY_AFTER_BINDING)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
_, input_nodes = audio_facade.get_selected_node_types()
if input_nodes != ['MIC']:
raise error.TestFail(
'%s rather than external mic is selected on Cros '
'device' % input_nodes)
logging.info('Setting playback data on Chameleon')
source.set_playback_data(golden_file)
# Starts playing, waits for some time, and then starts recording.
# This is to avoid artifact caused by chameleon codec initialization
# in the beginning of playback.
logging.info('Start playing %s from Chameleon', golden_file.path)
source.start_playback()
time.sleep(self.DELAY_BEFORE_RECORD_SECONDS)
logging.info('Start recording from Cros device.')
recorder.start_recording()
time.sleep(self.RECORD_SECONDS)
recorder.stop_recording()
logging.info('Stopped recording from Cros device.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
recorder.read_recorded_binary()
logging.info('Read recorded binary from Cros device.')
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
recorder.save_file(recorded_file)
# Removes the beginning of recorded data. This is to avoid artifact
# caused by Cros device codec initialization in the beginning of
# recording.
recorder.remove_head(1.5)
recorded_file = os.path.join(self.resultsdir, "recorded_clipped.raw")
logging.info('Saving clipped data to %s', recorded_file)
recorder.save_file(recorded_file)
# Compares data by frequency. Audio signal from Chameleon Line-Out to
# Cros device external microphone has gone through analog processing.
# This suffers from codec artifacts and noise on the path.
# Comparing data by frequency is more robust than comparing them by
# correlation, which is suitable for fully-digital audio path like USB
# and HDMI.
audio_test_utils.check_recorded_frequency(golden_file,
recorder,
check_anomaly=check_quality)
def run_once(self, host, check_quality=False, chrome_block_size=None):
"""Running basic headphone audio tests.
@param host: device under test host
@param check_quality: flag to check audio quality.
@param chrome_block_size: A number to be passed to Chrome
--audio-buffer-size argument to specify
block size.
"""
if not audio_test_utils.has_headphone(host):
logging.info('Skip the test because there is no headphone')
return
golden_file = audio_test_data.GenerateAudioTestData(
data_format=dict(file_type='wav',
sample_format='S16_LE',
channel=2,
rate=48000),
path=os.path.join(self.bindir, 'fix_660_16.wav'),
duration_secs=60,
frequencies=[660, 660])
chameleon_board = host.chameleon
# Checks if a block size is specified for Chrome.
extra_browser_args = None
if chrome_block_size:
extra_browser_args = ['--audio-buffer-size=%d' % chrome_block_size]
factory = remote_facade_factory.RemoteFacadeFactory(
host,
results_dir=self.resultsdir,
extra_browser_args=extra_browser_args)
chameleon_board.setup_and_reset(self.outputdir)
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
headphone = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.HEADPHONE)
linein = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.LINEIN)
headphone_linein_binder = widget_factory.create_binder(
headphone, linein)
usb_out = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.USBOUT)
usb_in = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.USBIN)
usb_binder = widget_factory.create_binder(usb_out, usb_in)
with chameleon_audio_helper.bind_widgets(headphone_linein_binder):
with chameleon_audio_helper.bind_widgets(usb_binder):
time.sleep(self.DELAY_AFTER_BINDING_SECONDS)
audio_facade = factory.create_audio_facade()
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_binding')
# Checks whether line-out or headphone is detected.
hp_jack_node_type = audio_test_utils.check_hp_or_lineout_plugged(
audio_facade)
# Checks headphone and USB nodes are plugged.
# Let Chrome select the proper I/O nodes.
# Input is USB, output is headphone.
audio_test_utils.check_and_set_chrome_active_node_types(
audio_facade=audio_facade,
output_type=hp_jack_node_type,
input_type='USB')
logging.info('Setting playback data on Chameleon')
usb_out.set_playback_data(golden_file)
browser_facade = factory.create_browser_facade()
apprtc = webrtc_utils.AppRTCController(browser_facade)
logging.info('Load AppRTC loopback webpage')
apprtc.new_apprtc_loopback_page()
logging.info('Start recording from Chameleon.')
linein.start_recording()
logging.info('Start playing %s on Cros device',
golden_file.path)
usb_out.start_playback()
time.sleep(self.RECORD_SECONDS)
linein.stop_recording()
logging.info('Stopped recording from Chameleon.')
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir,
'after_recording')
usb_out.stop_playback()
linein.read_recorded_binary()
logging.info('Read recorded binary from Chameleon.')
golden_file.delete()
recorded_file = os.path.join(self.resultsdir, "recorded.raw")
logging.info('Saving recorded data to %s', recorded_file)
linein.save_file(recorded_file)
diagnostic_path = os.path.join(
self.resultsdir, 'audio_diagnostics.txt.after_recording')
logging.info('Examine diagnostic file at %s', diagnostic_path)
diag_warning_msg = audio_test_utils.examine_audio_diagnostics(
diagnostic_path)
if diag_warning_msg:
logging.warning(diag_warning_msg)
# Raise error.TestFail if there is issue.
audio_test_utils.check_recorded_frequency(
golden_file, linein, check_artifacts=check_quality)
def run_once(self, host):
chameleon_board = host.chameleon
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
audio_facade = factory.create_audio_facade()
chameleon_board.setup_and_reset(self.outputdir)
jack_plugger = chameleon_board.get_audio_board().get_jack_plugger()
expected_plugged_nodes_without_audio_jack = ([], [
'POST_DSP_LOOPBACK', 'POST_MIX_LOOPBACK'
])
# 'Headphone' or 'LINEOUT' will be added to expected list after jack
# is plugged.
expected_plugged_nodes_with_audio_jack = ([], [
'MIC', 'POST_DSP_LOOPBACK', 'POST_MIX_LOOPBACK'
])
if audio_test_utils.has_internal_speaker(host):
expected_plugged_nodes_without_audio_jack[0].append(
'INTERNAL_SPEAKER')
expected_plugged_nodes_with_audio_jack[0].append(
'INTERNAL_SPEAKER')
if audio_test_utils.has_internal_microphone(host):
expected_plugged_nodes_without_audio_jack[1].append('INTERNAL_MIC')
expected_plugged_nodes_with_audio_jack[1].append('INTERNAL_MIC')
# Modify expected nodes for special boards.
board_name = host.get_board().split(':')[1]
if board_name == 'link':
expected_plugged_nodes_without_audio_jack[1].append('KEYBOARD_MIC')
expected_plugged_nodes_with_audio_jack[1].append('KEYBOARD_MIC')
if board_name in ['samus', 'kevin', 'eve', 'pyro']:
expected_plugged_nodes_without_audio_jack[1].append('HOTWORD')
expected_plugged_nodes_with_audio_jack[1].append('HOTWORD')
audio_test_utils.check_plugged_nodes(
audio_facade, expected_plugged_nodes_without_audio_jack)
try:
jack_plugger.plug()
time.sleep(self.DELAY_AFTER_PLUGGING)
audio_test_utils.dump_cros_audio_logs(host, audio_facade,
self.resultsdir)
# Checks whether line-out or headphone is detected.
hp_jack_node_type = audio_test_utils.check_hp_or_lineout_plugged(
audio_facade)
expected_plugged_nodes_with_audio_jack[0].append(hp_jack_node_type)
audio_test_utils.check_plugged_nodes(
audio_facade, expected_plugged_nodes_with_audio_jack)
finally:
jack_plugger.unplug()
time.sleep(self.DELAY_AFTER_UNPLUGGING)
audio_test_utils.check_plugged_nodes(
audio_facade, expected_plugged_nodes_without_audio_jack)
def run_once(self,
host,
jack_node=False,
hdmi_node=False,
usb_node=False,
play_audio=False):
self.host = host
chameleon_board = host.chameleon
audio_board = chameleon_board.get_audio_board()
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir)
chameleon_board.setup_and_reset(self.outputdir)
self.audio_facade = factory.create_audio_facade()
self.display_facade = factory.create_display_facade()
self.check_default_nodes()
nodes = []
if audio_test_utils.has_internal_speaker(self.host):
self.set_active_volume_to_node_volume('INTERNAL_SPEAKER')
nodes.append('INTERNAL_SPEAKER')
self.switch_nodes_and_check_volume(nodes)
if play_audio:
self.browser_facade = factory.create_browser_facade()
self.browser_facade.new_tab(URL)
time.sleep(self._WAIT_TO_LOAD_VIDEO)
if hdmi_node:
edid_path = os.path.join(self.bindir,
'test_data/edids/HDMI_DELL_U2410.txt')
finder = chameleon_port_finder.ChameleonVideoInputFinder(
chameleon_board, self.display_facade)
hdmi_port = finder.find_port('HDMI')
hdmi_port.apply_edid(edid_lib.Edid.from_file(edid_path))
time.sleep(self._APPLY_EDID_DELAY)
hdmi_port.set_plug(True)
time.sleep(self._PLUG_DELAY * 2)
audio_test_utils.check_audio_nodes(self.audio_facade,
(['HDMI'], None))
if play_audio:
self.audio_facade.check_audio_stream_at_selected_device()
self.set_active_volume_to_node_volume('HDMI')
nodes.append('HDMI')
self.switch_nodes_and_check_volume(nodes)
if jack_node:
jack_plugger = audio_board.get_jack_plugger()
jack_plugger.plug()
time.sleep(self._PLUG_DELAY)
audio_test_utils.dump_cros_audio_logs(host, self.audio_facade,
self.resultsdir)
# Checks whether line-out or headphone is detected.
hp_jack_node_type = audio_test_utils.check_hp_or_lineout_plugged(
self.audio_facade)
audio_test_utils.check_audio_nodes(self.audio_facade,
(None, ['MIC']))
self.set_active_volume_to_node_volume(hp_jack_node_type)
nodes.append(hp_jack_node_type)
self.switch_nodes_and_check_volume(nodes)
if usb_node:
widget_factory = chameleon_audio_helper.AudioWidgetFactory(
factory, host)
source = widget_factory.create_widget(
chameleon_audio_ids.CrosIds.USBOUT)
recorder = widget_factory.create_widget(
chameleon_audio_ids.ChameleonIds.USBIN)
binder = widget_factory.create_binder(source, recorder)
with chameleon_audio_helper.bind_widgets(binder):
time.sleep(self._PLUG_DELAY)
audio_test_utils.check_audio_nodes(self.audio_facade,
(['USB'], ['USB']))
self.set_active_volume_to_node_volume('USB')
nodes.append('USB')
self.switch_nodes_and_check_volume(nodes)
time.sleep(self._PLUG_DELAY)
nodes.remove('USB')
self.switch_nodes_and_check_volume(nodes)
if jack_node:
if usb_node:
audio_test_utils.check_audio_nodes(
self.audio_facade, ([hp_jack_node_type], ['MIC']))
jack_plugger.unplug()
time.sleep(self._PLUG_DELAY)
nodes.remove(hp_jack_node_type)
self.switch_nodes_and_check_volume(nodes)
if hdmi_node:
if usb_node or jack_node:
audio_test_utils.check_audio_nodes(self.audio_facade,
(['HDMI'], None))
hdmi_port.set_plug(False)
time.sleep(self._PLUG_DELAY)
nodes.remove('HDMI')
self.switch_nodes_and_check_volume(nodes)
self.check_default_nodes()
