def save_and_check_data(self, recorder_widget): """Saves and checks the data from the recorder. @param recorder_widget: recorder widget to save data from @raise error.TestFail: if comparison fails """ recorded_file = os.path.join(self.resultsdir, "recorded.raw") logging.debug('Saving recorded data to %s', recorded_file) recorder_widget.save_file(recorded_file) # Removes the beginning of recorded data. This is to avoid artifact # caused by codec initialization in the beginning of recording. recorder_widget.remove_head(2.0) # Removes noise by a lowpass filter. recorder_widget.lowpass_filter(self.low_pass_freq) recorded_file = os.path.join(self.resultsdir, "recorded_filtered.raw") logging.debug('Saving filtered data to %s', recorded_file) recorder_widget.save_file(recorded_file) # Compares data by frequency. audio_test_utils.check_recorded_frequency( self.golden_file, recorder_widget, second_peak_ratio=self.second_peak_ratio, ignore_frequencies=self.ignore_frequencies)
def save_and_check_data(self, recorder_widget): """Saves and checks the data from the recorder @param recorder_widget: recorder widget to save data from @returns (success, error_message): success is True if audio comparison is successful, False otherwise. error_message contains the error message. """ recorded_file = os.path.join(self.resultsdir, "recorded.raw") logging.debug('Saving recorded data to %s', recorded_file) recorder_widget.save_file(recorded_file) # Removes the beginning of recorded data. This is to avoid artifact # caused by codec initialization in the beginning of # recording. recorder_widget.remove_head(2.0) # Removes noise by a lowpass filter. recorder_widget.lowpass_filter(self.low_pass_freq) recorded_file = os.path.join(self.resultsdir, "recorded_filtered.raw") logging.debug('Saving filtered data to %s', recorded_file) recorder_widget.save_file(recorded_file) # Compares data by frequency and returns the result. try: audio_test_utils.check_recorded_frequency( self.golden_file, recorder_widget, second_peak_ratio=self.second_peak_ratio, ignore_frequencies=self.ignore_frequencies) except error.TestFail, e: return (False, e)
def save_and_check_data(self, recorder_widget): """Saves and checks the data from the recorder @param recorder_widget: recorder widget to save data from """ recorded_file = os.path.join(self.resultsdir, 'recorded.raw') logging.debug('Saving recorded data to %s', recorded_file) recorder_widget.save_file(recorded_file) # Removes the beginning of recorded data. This is to avoid artifact # caused by codec initialization in the beginning of # recording. recorder_widget.remove_head(2.0) # Removes noise by a lowpass filter. recorder_widget.lowpass_filter(self.lowpass_freq) recorded_file = os.path.join(self.resultsdir, 'recorded_filtered.raw') logging.debug('Saving filtered data to %s', recorded_file) recorder_widget.save_file(recorded_file) # Compares data by frequency and returns the result. audio_test_utils.check_recorded_frequency( self.audio_test_data, recorder_widget, second_peak_ratio=self.second_peak_ratio, ignore_frequencies=self.ignore_frequencies, check_anomaly=True)
def validate_recorded_data(self, channel): """Read processed data and validate by comparing to golden file. @param channel: 'left' or 'right'. """ # 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. logging.info('Validating recorded output for channel %s', channel) audio_test_utils.check_recorded_frequency( audio_test_data.SIMPLE_FREQUENCY_SPEAKER_TEST_FILE, self.sound_recorder, second_peak_ratio=0.1, ignore_frequencies=[50, 60])
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): 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, 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): 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, check_quality=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 @param check_quality: True to check quality. """ golden_file = audio_test_data.FREQUENCY_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'] or output_nodes == ['LINEOUT']: 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.check_recorded_frequency( golden_file, recorder, check_artifacts=check_quality)
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, 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 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, 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, 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, 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, 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, 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, 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)