def _find_port(self, interface):
"""Finds a Chameleon audio port by interface(port name).
@param interface: string, the interface. e.g: HDMI.
@returns: A ChameleonPort object.
@raises: ValueError if port is not connected.
"""
finder = chameleon_port_finder.ChameleonAudioInputFinder(
self._chameleon_board)
chameleon_port = finder.find_port(interface)
if not chameleon_port:
raise ValueError(
'Port %s is not connected to Chameleon' % interface)
return chameleon_port
def run_once(self,
host,
video_hardware_acceleration=True,
video_url=DEFAULT_VIDEO_URL,
arc=False):
"""Running audio/video synchronization quality measurement
@param host: A host object representing the DUT.
@param video_hardware_acceleration: Enables the hardware acceleration
for video decoding.
@param video_url: The ULR of the test video.
@param arc: Tests on ARC with an Android Video Player App.
"""
self.host = host
factory = remote_facade_factory.RemoteFacadeFactory(
host, results_dir=self.resultsdir, no_chrome=True)
chrome_args = {
'extension_paths':
[constants.AUDIO_TEST_EXTENSION, constants.DISPLAY_TEST_EXTENSION],
'extra_browser_args': [],
'arc_mode':
arc_common.ARC_MODE_DISABLED,
'autotest_ext':
True
}
if not video_hardware_acceleration:
chrome_args['extra_browser_args'].append(
'--disable-accelerated-video-decode')
if arc:
chrome_args['arc_mode'] = arc_common.ARC_MODE_ENABLED
browser_facade = factory.create_browser_facade()
browser_facade.start_custom_chrome(chrome_args)
logging.info("created chrome")
if arc:
self.setup_video_app()
chameleon_board = host.chameleon
audio_facade = factory.create_audio_facade()
display_facade = factory.create_display_facade()
video_facade = factory.create_video_facade()
audio_port_finder = chameleon_port_finder.ChameleonAudioInputFinder(
chameleon_board)
video_port_finder = chameleon_port_finder.ChameleonVideoInputFinder(
chameleon_board, display_facade)
audio_port = audio_port_finder.find_port('HDMI')
video_port = video_port_finder.find_port('HDMI')
chameleon_board.setup_and_reset(self.outputdir)
_, ext = os.path.splitext(video_url)
with tempfile.NamedTemporaryFile(prefix='playback_', suffix=ext) as f:
# The default permission is 0o600.
os.chmod(f.name, 0o644)
file_utils.download_file(video_url, f.name)
if arc:
video_facade.prepare_arc_playback(f.name)
else:
video_facade.prepare_playback(f.name)
edid_path = os.path.join(self.bindir,
'test_data/edids/HDMI_DELL_U2410.txt')
video_port.plug()
with video_port.use_edid_file(edid_path):
audio_facade.set_chrome_active_node_type('HDMI', None)
audio_facade.set_chrome_active_volume(100)
audio_test_utils.check_audio_nodes(audio_facade, (['HDMI'], None))
display_facade.set_mirrored(True)
video_port.start_monitoring_audio_video_capturing_delay()
time.sleep(self.DELAY_BEFORE_CAPTURING)
video_port.start_capturing_video((64, 64, 16, 16))
audio_port.start_capturing_audio()
time.sleep(self.DELAY_BEFORE_PLAYBACK)
if arc:
video_facade.start_arc_playback(blocking_secs=20)
else:
video_facade.start_playback(blocking=True)
time.sleep(self.DELAY_AFTER_PLAYBACK)
remote_path, _ = audio_port.stop_capturing_audio()
video_port.stop_capturing_video()
start_delay = video_port.get_audio_video_capturing_delay()
local_path = os.path.join(self.resultsdir, 'recorded.raw')
chameleon_board.host.get_file(remote_path, local_path)
audio_data = open(local_path).read()
video_data = video_port.get_captured_checksums()
logging.info("audio capture %d bytes, %f seconds", len(audio_data),
len(audio_data) / float(self.AUDIO_CAPTURE_RATE) / 32)
logging.info("video capture %d frames, %f seconds", len(video_data),
len(video_data) / float(self.VIDEO_CAPTURE_RATE))
key_audio = self.compute_audio_keypoint(audio_data)
key_video = self.compute_video_keypoint(video_data)
# Use the capturing delay to align A/V
key_video = map(lambda x: x + start_delay, key_video)
dropped_frame_count = None
if not arc:
video_facade.dropped_frame_count()
prefix = ''
if arc:
prefix = 'arc_'
elif video_hardware_acceleration:
prefix = 'hw_'
else:
prefix = 'sw_'
self.log_result(prefix, key_audio, key_video, dropped_frame_count)