def run_once(self, host, player): """ Entry point for test case. @param host: A reference to the DUT. @param player: A string representing what audio player to use. Could be 'native' or 'browser'. """ if not audio_test_utils.has_internal_speaker(host): return host.chameleon.setup_and_reset(self.outputdir) facade_factory = remote_facade_factory.RemoteFacadeFactory( host, results_dir=self.resultsdir) self.audio_facade = facade_factory.create_audio_facade() self.browser_facade = facade_factory.create_browser_facade() widget_factory = chameleon_audio_helper.AudioWidgetFactory( facade_factory, host) self.sound_source = widget_factory.create_widget( chameleon_audio_ids.CrosIds.SPEAKER) self.sound_recorder = widget_factory.create_widget( chameleon_audio_ids.ChameleonIds.MIC) self.play_and_record(host, player, 'left') self.process_and_save_data(channel='left') self.validate_recorded_data(channel='left') self.play_and_record(host, player, 'right') self.process_and_save_data(channel='right') self.validate_recorded_data(channel='right')
def check_default_nodes(self): """Checks default audio nodes for devices with onboard audio support.""" if audio_test_utils.has_internal_microphone(self.host): audio_test_utils.check_audio_nodes(self.audio_facade, (None, ['INTERNAL_MIC'])) if audio_test_utils.has_internal_speaker(self.host): audio_test_utils.check_audio_nodes(self.audio_facade, (['INTERNAL_SPEAKER'], None))
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 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, 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, audio_nodes, golden_data, bind_from=None, bind_to=None, source=None, recorder=None, is_internal=False): """Runs the test main workflow @param host: A host object representing the DUT. @param audio_nodes: audio nodes supposed to be selected. @param golden_data: audio file and low pass filter frequency the audio file should be test data defined in audio_test_data @param bind_from: audio originating entity to be binded should be defined in chameleon_audio_ids @param bind_to: audio directed_to entity to be binded should be defined in chameleon_audio_ids @param source: source widget entity should be defined in chameleon_audio_ids @param recorder: recorder widget entity should be defined in chameleon_audio_ids @param is_internal: whether internal audio is tested flag """ if (recorder == chameleon_audio_ids.CrosIds.INTERNAL_MIC and not audio_test_utils.has_internal_microphone(host)): return if (source == chameleon_audio_ids.CrosIds.SPEAKER and not audio_test_utils.has_internal_speaker(host)): return self.host = host self.audio_nodes = audio_nodes self.is_internal = is_internal self.second_peak_ratio = audio_test_utils.DEFAULT_SECOND_PEAK_RATIO self.ignore_frequencies = None if source == chameleon_audio_ids.CrosIds.SPEAKER: self.second_peak_ratio = 0.1 self.ignore_frequencies = [50, 60] elif recorder == chameleon_audio_ids.CrosIds.INTERNAL_MIC: self.second_peak_ratio = 0.2 self.errors = [] self.golden_file, self.low_pass_freq = golden_data chameleon_board = self.host.chameleon self.factory = self.create_remote_facade_factory(self.host) self.audio_facade = self.factory.create_audio_facade() chameleon_board.reset() widget_factory = chameleon_audio_helper.AudioWidgetFactory( self.factory, host) # Two widgets are binded in the factory if necessary binder_widget = None bind_from_widget = None bind_to_widget = None if bind_from != None and bind_to != None: bind_from_widget = widget_factory.create_widget(bind_from) bind_to_widget = widget_factory.create_widget(bind_to) binder_widget = widget_factory.create_binder( bind_from_widget, bind_to_widget) # Additional widgets that could be part of the factory if source == None: source_widget = bind_from_widget else: source_widget = widget_factory.create_widget(source) if recorder == None: recorder_widget = bind_to_widget else: recorder_widget = widget_factory.create_widget(recorder) self.audio_board = chameleon_board.get_audio_board() # If there is no audio-board, test default state. if self.audio_board == None: plug_configs = [(True, True, True)] else: plug_configs = self.PLUG_CONFIGS test_index = 0 for (plugged_before_suspend, plugged_after_suspend, plugged_before_resume) in plug_configs: plugged_after_resume = True test_index += 1 # Reverse plugged states, when internal audio is tested if self.is_internal: plugged_after_resume = False plugged_before_suspend = not plugged_before_suspend plugged_after_suspend = not plugged_after_suspend plugged_before_resume = not plugged_before_resume test_case = ( 'TEST CASE %d: %s > suspend > %s > %s > resume > %s' % (test_index, 'PLUG' if plugged_before_suspend else 'UNPLUG', 'PLUG' if plugged_after_suspend else 'UNPLUG', 'PLUG' if plugged_before_resume else 'UNPLUG', 'PLUG' if plugged_after_resume else 'UNPLUG')) logging.info(test_case) # Plugged status before suspended self.action_plug_jack(plugged_before_suspend) self.suspend_resume(plugged_before_suspend, plugged_after_suspend, plugged_before_resume, test_case) # Active (plugged for external) state after resume self.action_plug_jack(plugged_after_resume) if binder_widget != None: with chameleon_audio_helper.bind_widgets(binder_widget): self.play_and_record(source_widget, recorder_widget) else: self.play_and_record(source_widget, recorder_widget) success, error_message = self.save_and_check_data(recorder_widget) if not success: self.errors.append('%s: Comparison failed: %s' % test_case, error_message) if self.errors: raise error.TestFail('; '.join(set(self.errors)))
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): 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, golden_data, audio_nodes, bind_from=None, bind_to=None, source=None, recorder=None, is_internal=False, cfm_speaker=False): """Runs the test main workflow. @param host: A host object representing the DUT. @param golden_data: audio file and low pass filter frequency the audio file should be test data defined in audio_test_data @param audio_nodes: audio nodes supposed to be selected @param bind_from: audio originating entity to be binded should be defined in chameleon_audio_ids @param bind_to: audio directed_to entity to be binded should be defined in chameleon_audio_ids @param source: source widget entity should be defined in chameleon_audio_ids @param recorder: recorder widget entity should be defined in chameleon_audio_ids @param is_internal: whether internal audio is tested flag @param cfm_speaker: whether cfm_speaker's audio is tested which is an external USB speaker on CFM (ChromeBox For Meetings) devices. """ if (recorder == chameleon_audio_ids.CrosIds.INTERNAL_MIC and (not cfm_speaker and not audio_test_utils.has_internal_microphone(host))): return if (source == chameleon_audio_ids.CrosIds.SPEAKER and (not cfm_speaker and not audio_test_utils.has_internal_speaker(host))): return self.host = host self.audio_nodes = audio_nodes self.golden_file, self.low_pass_freq = golden_data chameleon_board = self.host.chameleon self.factory = remote_facade_factory.RemoteFacadeFactory( self.host, results_dir=self.resultsdir) self.audio_facade = self.factory.create_audio_facade() chameleon_board.setup_and_reset(self.outputdir) widget_factory = chameleon_audio_helper.AudioWidgetFactory( self.factory, host) self.audio_board = chameleon_board.get_audio_board() self.widget_link = None self.use_audio_bus = False self.second_peak_ratio = audio_test_utils.get_second_peak_ratio( source_id=source, recorder_id=recorder) self.ignore_frequencies = None if source == chameleon_audio_ids.CrosIds.SPEAKER: self.ignore_frequencies = [50, 60] # Two widgets are binded in the factory if necessary binder_widget = None bind_from_widget = None bind_to_widget = None if bind_from != None and bind_to != None: bind_from_widget = widget_factory.create_widget(bind_from) bind_to_widget = widget_factory.create_widget(bind_to) binder_widget = widget_factory.create_binder(bind_from_widget, bind_to_widget) self.widget_link = binder_widget.get_link() if isinstance(self.widget_link, audio_widget_link.AudioBusLink): self.use_audio_bus = True # Additional widgets that could be part of the factory if source == None: source_widget = bind_from_widget else: source_widget = widget_factory.create_widget(source) if recorder == None: recorder_widget = bind_to_widget else: recorder_widget = widget_factory.create_widget(recorder) # Plug for external audio self.action_plug_jack(not is_internal) # Play only, reboot, then play and record. if binder_widget != None: with chameleon_audio_helper.bind_widgets(binder_widget): time.sleep(self.DELAY_AFTER_BINDING) self.play_reboot_play_and_record(source_widget, recorder_widget) else: self.play_reboot_play_and_record(source_widget, recorder_widget) self.save_and_check_data(recorder_widget)
def run_once(self, host, audio_nodes, audio_test_data, test_playback_file, lowpass_freq=None, bind_from=None, bind_to=None, source=None, recorder=None, tag=None): """Runs the test main workflow @param host: A host object representing the DUT. @param audio_nodes: audio nodes supposed to be selected. @param audio_test_data: audio test frequency defined in audio_test_data @param test_playback_file: audio media file(wav, mp3,...) to be used for testing @param lowpass_freq: frequency noise filter. @param bind_from: audio originating entity to be binded should be defined in chameleon_audio_ids @param bind_to: audio directed_to entity to be binded should be defined in chameleon_audio_ids @param source: source widget entity should be defined in chameleon_audio_ids @param recorder: recorder widget entity should be defined in chameleon_audio_ids """ self.host = host self.audio_nodes = audio_nodes if (not audio_test_utils.has_internal_speaker(host) and tag == "internal_speaker"): return self.second_peak_ratio = audio_test_utils.get_second_peak_ratio( source_id=source, recorder_id=recorder) self.ignore_frequencies = None if source == chameleon_audio_ids.CrosIds.SPEAKER: self.ignore_frequencies = [50, 60] self.audio_test_data = audio_test_data self.lowpass_freq = lowpass_freq self.test_playback_file = test_playback_file chameleon_board = self.host.chameleon self.factory = remote_facade_factory.RemoteFacadeFactory( self.host, results_dir=self.resultsdir) self.audio_facade = self.factory.create_audio_facade() chameleon_board.setup_and_reset(self.outputdir) widget_factory = chameleon_audio_helper.AudioWidgetFactory( self.factory, host) # Two widgets are binded in the factory if necessary. binder_widget = None source_widget = None recorder_widget = None if bind_from != None and bind_to != None: source_widget = widget_factory.create_widget(bind_from) recorder_widget = widget_factory.create_widget(bind_to) binder_widget = widget_factory.create_binder(source_widget, recorder_widget) elif source != None and recorder != None: source_widget = widget_factory.create_widget(source) recorder_widget = widget_factory.create_widget(recorder) else: raise error.TestError('Test configuration or setup problem.') self.audio_board = chameleon_board.get_audio_board() if binder_widget: # Headphone test which requires Chameleon LINEIN and DUT headphones # binding. with chameleon_audio_helper.bind_widgets(binder_widget): self.play_and_record(recorder_widget) else: # Internal speakers test. self.play_and_record(recorder_widget) self.save_and_check_data(recorder_widget)
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, 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()
def run_once(self, host, audio_nodes, golden_data, bind_from=None, bind_to=None, source=None, recorder=None, plug_status=None): """Runs the test main workflow @param host: A host object representing the DUT. @param audio_nodes: audio nodes supposed to be selected. @param golden_data: audio file and low pass filter frequency the audio file should be test data defined in audio_test_data @param bind_from: audio originating entity to be binded should be defined in chameleon_audio_ids @param bind_to: audio directed_to entity to be binded should be defined in chameleon_audio_ids @param source: source widget entity should be defined in chameleon_audio_ids @param recorder: recorder widget entity should be defined in chameleon_audio_ids @param plug_status: audio channel plug unplug sequence """ if (recorder == chameleon_audio_ids.CrosIds.INTERNAL_MIC and not audio_test_utils.has_internal_microphone(host)): return if (source == chameleon_audio_ids.CrosIds.SPEAKER and not audio_test_utils.has_internal_speaker(host)): return self.host = host self.audio_nodes = audio_nodes self.second_peak_ratio = audio_test_utils.get_second_peak_ratio( source_id=source, recorder_id=recorder) self.ignore_frequencies = None if source == chameleon_audio_ids.CrosIds.SPEAKER: self.ignore_frequencies = [50, 60] self.errors = [] self.golden_file, self.low_pass_freq = golden_data chameleon_board = self.host.chameleon self.factory = remote_facade_factory.RemoteFacadeFactory( self.host, results_dir=self.resultsdir) self.audio_facade = self.factory.create_audio_facade() chameleon_board.setup_and_reset(self.outputdir) widget_factory = chameleon_audio_helper.AudioWidgetFactory( self.factory, host) # Two widgets are binded in the factory if necessary binder_widget = None bind_from_widget = None bind_to_widget = None if bind_from != None and bind_to != None: bind_from_widget = widget_factory.create_widget(bind_from) bind_to_widget = widget_factory.create_widget(bind_to) binder_widget = widget_factory.create_binder( bind_from_widget, bind_to_widget) # Additional widgets that could be part of the factory if source == None: source_widget = bind_from_widget else: source_widget = widget_factory.create_widget(source) if recorder == None: recorder_widget = bind_to_widget else: recorder_widget = widget_factory.create_widget(recorder) self.audio_board = chameleon_board.get_audio_board() test_index = 0 for (plugged_before_suspend, plugged_after_suspend, plugged_before_resume, plugged_after_resume) in plug_status: test_index += 1 test_case = ( 'TEST CASE %d: %s > suspend > %s > %s > resume > %s' % (test_index, 'PLUG' if plugged_before_suspend else 'UNPLUG', 'PLUG' if plugged_after_suspend else 'UNPLUG', 'PLUG' if plugged_before_resume else 'UNPLUG', 'PLUG' if plugged_after_resume else 'UNPLUG')) logging.info(test_case) # Plugged status before suspended self.action_plug_jack(plugged_before_suspend) self.suspend_resume(plugged_before_suspend, plugged_after_suspend, plugged_before_resume, test_case) # Active (plugged for external) state after resume self.action_plug_jack(plugged_after_resume) if binder_widget != None: with chameleon_audio_helper.bind_widgets(binder_widget): self.play_and_record(source_widget, recorder_widget) else: self.play_and_record(source_widget, recorder_widget) success, error_message = self.save_and_check_data(recorder_widget) if not success: self.errors.append('%s: Comparison failed: %s' % (test_case, error_message)) if self.errors: raise error.TestFail('; '.join(set(self.errors)))
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.SPEAKER and not audio_test_utils.has_internal_speaker(host)): return self.client_at = None # Runs a client side test to start Chrome and install Play Music app. self.setup_playmusic_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, use_arc=True) 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) # 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) 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_output_port(audio_facade, source.port_id) if switch_hsp: audio_test_utils.switch_to_hsp(audio_facade) logging.info('Setting playback file on Cros device') source.set_playback_data(golden_file) 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.WAIT_PLAYBACK_SECS) 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.check_recorded_frequency( golden_file, recorder, second_peak_ratio=second_peak_ratio)
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' ]) # Modify expected nodes for special boards. board_name = host.get_board().split(':')[1] model_name = host.get_platform() 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_internal_mics = cras_configs.get_plugged_internal_mics( board_name, model_name) expected_plugged_nodes_without_audio_jack[1].extend( expected_internal_mics) expected_plugged_nodes_with_audio_jack[1].extend( expected_internal_mics) 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 audio_spec.has_hotwording(board_name, model_name): expected_plugged_nodes_without_audio_jack[1].append('HOTWORD') expected_plugged_nodes_with_audio_jack[1].append('HOTWORD') # If there is no jack plugger, check the nodes without plugging. host_info = host.host_info_store.get() if jack_plugger is None: if 'audio_box' in host_info.labels: raise error.TestError("Failed to detect jack plugger.") 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) return 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)