| # Copyright 2016 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import json |
| import logging |
| import os |
| import struct |
| import tempfile |
| import time |
| |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.common_lib import file_utils |
| from autotest_lib.client.common_lib.cros import arc_common |
| from autotest_lib.client.cros import constants |
| from autotest_lib.client.cros.chameleon import audio_test_utils |
| from autotest_lib.client.cros.chameleon import chameleon_port_finder |
| from autotest_lib.client.cros.multimedia import arc_resource_common |
| from autotest_lib.server import autotest |
| from autotest_lib.server import test |
| from autotest_lib.server.cros.multimedia import remote_facade_factory |
| |
| |
| class audiovideo_AVSync(test.test): |
| """ Server side HDMI audio/video sync quality measurement |
| |
| This test talks to a Chameleon board and a Cros device to measure the |
| audio/video sync quality under playing a 1080p 60fps video. |
| """ |
| version = 1 |
| |
| AUDIO_CAPTURE_RATE = 48000 |
| VIDEO_CAPTURE_RATE = 60 |
| |
| BEEP_THRESHOLD = 10 ** 9 |
| |
| DELAY_BEFORE_CAPTURING = 2 |
| DELAY_BEFORE_PLAYBACK = 2 |
| DELAY_AFTER_PLAYBACK = 2 |
| |
| DEFAULT_VIDEO_URL = ('http://commondatastorage.googleapis.com/' |
| 'chromiumos-test-assets-public/chameleon/' |
| 'audiovideo_AVSync/1080p_60fps.mp4') |
| |
| WAIT_CLIENT_READY_TIMEOUT_SECS = 120 |
| |
| def compute_audio_keypoint(self, data): |
| """Compute audio keypoints. Audio keypoints are the starting times of |
| beeps. |
| |
| @param data: Raw captured audio data in S32LE, 8 channels, 48000 Hz. |
| |
| @returns: Key points of captured data put in a list. |
| """ |
| keypoints = [] |
| sample_no = 0 |
| last_beep_no = -100 |
| for i in xrange(0, len(data), 32): |
| values = struct.unpack('<8i', data[i:i+32]) |
| if values[0] > self.BEEP_THRESHOLD: |
| if sample_no - last_beep_no >= 100: |
| keypoints.append(sample_no / float(self.AUDIO_CAPTURE_RATE)) |
| last_beep_no = sample_no |
| sample_no += 1 |
| return keypoints |
| |
| |
| def compute_video_keypoint(self, checksum): |
| """Compute video keypoints. Video keypoints are the times when the |
| checksum changes. |
| |
| @param checksum: Checksums of frames put in a list. |
| |
| @returns: Key points of captured video data put in a list. |
| """ |
| return [i / float(self.VIDEO_CAPTURE_RATE) |
| for i in xrange(1, len(checksum)) |
| if checksum[i] != checksum[i - 1]] |
| |
| |
| def log_result(self, prefix, key_audio, key_video, dropped_frame_count): |
| """Log the test result to result.json and the dashboard. |
| |
| @param prefix: A string distinguishes between subtests. |
| @param key_audio: Key points of captured audio data put in a list. |
| @param key_video: Key points of captured video data put in a list. |
| @param dropped_frame_count: Number of dropped frames. |
| """ |
| log_path = os.path.join(self.resultsdir, 'result.json') |
| diff = map(lambda x: x[0] - x[1], zip(key_audio, key_video)) |
| diff_range = max(diff) - min(diff) |
| result = dict( |
| key_audio=key_audio, |
| key_video=key_video, |
| av_diff=diff, |
| diff_range=diff_range |
| ) |
| if dropped_frame_count is not None: |
| result['dropped_frame_count'] = dropped_frame_count |
| |
| result = json.dumps(result, indent=2) |
| with open(log_path, 'w') as f: |
| f.write(result) |
| logging.info(str(result)) |
| |
| dashboard_result = dict( |
| diff_range=[diff_range, 'seconds'], |
| max_diff=[max(diff), 'seconds'], |
| min_diff=[min(diff), 'seconds'], |
| average_diff=[sum(diff) / len(diff), 'seconds'] |
| ) |
| if dropped_frame_count is not None: |
| dashboard_result['dropped_frame_count'] = [ |
| dropped_frame_count, 'frames'] |
| |
| for key, value in dashboard_result.iteritems(): |
| self.output_perf_value(description=prefix+key, value=value[0], |
| units=value[1], higher_is_better=False) |
| |
| |
| 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) |
| |
| |
| def run_client_side_test(self): |
| """Runs a client side test on Cros device in background.""" |
| self.client_at = autotest.Autotest(self.host) |
| logging.info('Start running client side test %s', |
| arc_resource_common.PlayVideoProps.TEST_NAME) |
| self.client_at.run_test( |
| arc_resource_common.PlayVideoProps.TEST_NAME, |
| background=True) |
| |
| |
| def setup_video_app(self): |
| """Setups Play Video app on Cros device. |
| |
| Runs a client side test on Cros device to start Chrome and ARC and |
| install Play Video app. |
| Wait for it to be ready. |
| |
| """ |
| # Removes ready tag that server side test should wait for later. |
| self.remove_ready_tag() |
| |
| # Runs the client side test. |
| self.run_client_side_test() |
| |
| logging.info('Waiting for client side Play Video app to be ready') |
| |
| # Waits for ready tag to be posted by client side test. |
| utils.poll_for_condition(condition=self.ready_tag_exists, |
| timeout=self.WAIT_CLIENT_READY_TIMEOUT_SECS, |
| desc='Wait for client side test being ready', |
| sleep_interval=1) |
| |
| logging.info('Client side Play Video app is ready') |
| |
| |
| def cleanup(self): |
| """Cleanup of the test.""" |
| self.touch_exit_tag() |
| super(audiovideo_AVSync, self).cleanup() |
| |
| |
| def remove_ready_tag(self): |
| """Removes ready tag on Cros device.""" |
| if self.ready_tag_exists(): |
| self.host.run(command='rm %s' % ( |
| arc_resource_common.PlayVideoProps.READY_TAG_FILE)) |
| |
| |
| def touch_exit_tag(self): |
| """Touches exit tag on Cros device to stop client side test.""" |
| self.host.run(command='touch %s' % ( |
| arc_resource_common.PlayVideoProps.EXIT_TAG_FILE)) |
| |
| |
| def ready_tag_exists(self): |
| """Checks if ready tag exists. |
| |
| @returns: True if the tag file exists. False otherwise. |
| |
| """ |
| return self.host.path_exists( |
| arc_resource_common.PlayVideoProps.READY_TAG_FILE) |
