page.title=Audio Framework CTS Verifier
@jd:body

<!--
    Copyright 2016 The Android Open Source Project

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->
<div id="qv-wrapper">
  <div id="qv">
    <h2>In this document</h2>
    <ol id="auto-toc">
    </ol>
  </div>
</div>

<p>This new suite of tests requires human intervention and some external hardware
including a <a href="#loopback_latency">Loopback Plug</a>, a <a
href="#audio_frequency_speaker_test">USB reference microphone</a> and <a
href="#audio_frequency_microphone_test">external speakers</a>. For devices without 3.5
mm (⅛”) headset port, the user will be able to skip the test and mark it as
successful. See the sections below for details.</p>

<h2 id=loopback_latency>Loopback plug latency test</h2>

<p><a
href="{@docRoot}devices/audio/latency_measure.html#measuringRoundTrip">Round
trip latency</a> in audio is defined as the time it takes an audio signal to be
recorded, processed and output back.</p>

<p>To measure round-trip latency using CTS Verifier, connect a loopback
plug to the 3.5 mm (⅛”) headset connector.  (If you don’t have a loopback plug,
you can easily make one following the <a
href="{@docRoot}devices/audio/loopback.html">Audio Loopback Dongle</a>
instructions.</p>

<table>
 <tr>
    <td width="50%">Start CTS Verifier Loopback Test</td>
    <td width="50%"><img src="images/audio-framework0.png" alt="audio latency loopback" width="300"
        id="audio_latency_loopback" /></td>
 </tr>
 <tr>
    <td>Summary of instructions is displayed</td>
    <td><img src="images/audio-framework1.png" alt="summary of instructions" width="300"
        id="loopback_instructions" /></td>
 </tr>
 <tr>
    <td>Report if the device has a headset port:<br>
        <strong>YES</strong> if the device under test has a physical headset port<br>
        <strong>NO</strong> if there is no headset port</td>
    <td><img src="images/audio-framework-port.png" alt="audio loopback latency" width="300"
        id="port_check" /></td>
 </tr>
 <tr>
    <td>If the answer was <strong>NO</strong> in the previous step, press
        <strong>Pass</strong> (green check) on the bottom of the test and finish</td>
    <td><img src="images/audio-framework-pass.png" alt="audio pass button" width="300"
        id="port_pass" /></td>
 </tr>
 <tr>
     <td>If the answer was <strong>YES</strong> in the previous step, continue
         to connect loopback plug.<br>
         Connect a loopback plug to the headset port<br>
         Press the <strong>Loopback Plug Ready</strong> button
    <td><img src="images/audio-framework2.png" alt="audio pass button" width="300"
        id="port_pass" /></td>
 </tr>
 <tr>
    <td>Move the slider until the signal level is greater than 60%<br>
        Press <strong>TEST</strong></td>
    <td><img src="images/audio-framework3.png" alt="audio level 1" width="300"
        id="audio_level1" />
        <img src="images/audio-framework4.png" alt="audio level 2" width="300"
        id="audio_level2"></td>
 </tr>
 <tr>
    <td>Wait several seconds while the latency test is performed</td>
    <td><img src="images/audio-framework5.png" alt="test running" width="300"
        id="test_running" /></td>
 </tr>
 <tr>
    <td>When the test is finished, results are shown<br>
        The minimum confidence level for a test to succeed is 0.6<br>
        Lower latency numbers are preferred, but no number is enforced</td>
    <td><img src="images/audio-framework6.png"  alt="test finished" width="300"
        id="test_finished" />
</td>
 </tr>
 <tr>
    <td>Press the <strong>Pass</strong> (green, only available if successful) or
<strong>Failed</strong> (red) button to record the results.</td>
    <td><img src="images/audio-framework7.png" alt="Pass button" width="300"
        id="pass_button" /><br>
        <img src="images/audio-framework8.png" alt="Failed button" width="300"
        id="failed_button" /></td>
 </tr>
</table>

<h2 id=audio_frequency_line_test>Audio frequency line test</h2>

<p>Using a loopback plug, this test will characterize the left/right line audio
output and use the mic feedback from the plug to capture audio and compute a
frequency response for each channel.</p>

<p>A simple criterion for minimum energy expected in each band (out of four) is
applied per channel.</p>
<table>
 <tr>
    <td width="50%">Start CTS Audio Frequency Line Test</td>
    <td width="50%"><img src="images/audio-framework9.png" alt="start frequency line" width="300"
        id="start_line_test" /></td>
 </tr>
 <tr>
    <td>Summary of instructions is displayed</td>
    <td><img src="images/audio-framework10.png" alt="instructions" width="300"
        id="summary_instructions" /></td>
 </tr>
 <tr>
    <td>Report if the device has a headset port:<br>
        <strong>YES</strong> if the device under test has a physical headset port<br>
        <strong>NO</strong> if there is no headset port</td>
    <td><img src="images/audio-framework-line-port.png" alt="audio frequency line" width="300"
        id="line_port_check" /></td>
 </tr>
 <tr>
    <td>If the answer was <strong>NO</strong> in the previous step, press
        <strong>Pass</strong> (green check) on the bottom of the test and finish</td>
    <td><img src="images/audio-framework-pass.png" alt="audio pass button" width="300"
        id="port_pass" /></td>
 </tr>
 <tr>
     <td>If the answer was <strong>YES</strong> in the previous step, continue
         to connect loopback plug<br>
	 Connect a Loopback Plug to the headset connector (see <a
         href="#loopback_latency">Loopback plug latency test</a>)<br>
         Press the <strong>Loopback Plug Ready</strong> button
    <td><img src="images/audio-framework11.png" alt="loopback plug ready" width="300"
        id="port_pass" /></td>
 </tr>
    <td>Press <strong>TEST</strong></td>
    <td><img src="images/audio-framework12.png" alt="loopback plug test" width="300"
        id="loopback_plug_test" /></td>
 </tr>
 <tr>
    <td>Wait several seconds while the frequency tests are performed</td>
    <td><img src="images/audio-framework13.png" alt="testing left capture" width="300"
        id="left_capture" /></td>
 </tr>
 <tr>
    <td>When the test is finished, results are shown</td>
    <td><img src="images/audio-framework14.png" alt="testing complete" width="300"
        id="test_complete" /></td>
 </tr>
    <td>Press the <strong>Pass</strong> (only available if successful) or
        <strong>Failed</strong> button to record the results</td>
    <td><img src="images/audio-framework15.png" alt="Pass button" width="300"
        id="pass_button" /><br>
        <img src="images/audio-framework16.png" alt="Failed button" width="300"
        id="failed_button" /></td>
 </tr>
</table>

<h2 id=audio_frequency_speaker_test>Audio frequency speaker test</h2>

<p>This test uses the signal captured by an external USB reference microphone to
assess the frequency response of left (and right, if it exists) loudspeakers.</p>

<p>A reference microphone is defined as that one that delivers flat, uncolored
response. They are often used for analysis and measurement equipment.  </p>

<p>There are some inexpensive USB Reference microphones (e.g., <a
href="https://minidsp.com/products/acoustic-measurement/umik-1">miniDSP USB
Measurement calibrated microphone</a>, <a
href="http://www.daytonaudio.com/index.php/umm-6-usb-measurement-microphone.html">Dayton
Audio UMM-6 USB Measurement Microphone</a>), mostly used for the home theater
enthusiasts to calibrate their setups.</p>

<p>Minimum recommended reference microphone characteristics:<br>
Flat Frequency response on range 100 Hz - 20 kHz:  +/- 2 dB<br>
 S/N ration 70 dB (A-weighted)<br>
 THD Ratio @ 1000 Hz less than 1 % at 127 dB SPL<p>

<table>
 <tr>
    <td width="50%">Start CTS Audio Frequency Speaker Test</td>
    <td width="50%"><img src="images/audio-framework17.png" alt="start speaker test" width="300"
        id="start_speaker" /></td>
 </tr>
 <tr>
    <td>Summary of instructions is displayed</td>
    <td><img src="images/audio-framework18.png" alt="instructions" width="300"
        id="summary_instructions" /></td>
 </tr>
 <tr>
    <td>Connect a USB reference microphone (see <a
        href="#audio_frequency_speaker_test">Audio frequency speaker test</a>)<br>
        Press <strong>USB REFERENCE MICROPHONE READY</strong></td>
    <td><img src="images/audio-framework19.png"  alt="mic ready" width="300"
        id="mic_ready" /></td>
 </tr>
 <tr>
    <td>Set up DUT (Device Under Test) in a quiet room and USB microphone 20cms
perpendicular to center of screen</td>
    <td><img src="images/audio-framework20.png" alt="device under test" width="300"
        id="dut" /></td>
 </tr>
 <tr>
    <td>Press <strong>TEST</strong></td>
    <td><img src="images/audio-framework21.png" alt="click test" width="300"
        id="click_test" /></td>
 </tr>
 <tr>
    <td>Wait several seconds while the frequency tests are performed</td>
    <td><img src="images/audio-framework22.png" alt="test underway" width="300"
        id="right_capture" /></td>
 </tr>
 <tr>
    <td>When the test is finished, results are shown</td>
    <td><img src="images/audio-framework23.png" alt="test complete" width="300"
        id="test_complete" /></td>
 </tr>
 </tr>
    <td>Press the <strong>Pass</strong> (only available if successful) or
        <strong>Failed</strong> button to record the results</td>
    <td><img src="images/audio-framework24.png" alt="Pass button" width="300"
        id="pass_button" /><br>
        <img src="images/audio-framework25.png" alt="Failed button" width="300"
        id="failed_button" /></td>
 </tr>
</table>

<h2 id=audio_frequency_microphone_test>Audio frequency microphone test</h2>

<p>This test is more involved than the previous ones. It requires the use of both:
External speakers for a white noise sound source, and a USB reference
microphone to use as a reference for the sound.  Although this process is more
involved, it can be performed with affordable, easy to get, hardware</p>

<p>External speakers positioned 40cm from the device are used to deliver a white
noise sound source.  These speakers don’t need to have a “Flat” frequency
response, but need good coverage from low frequencies (100 hz) to high
frequencies (20khz) is expected which is usually met by portable or medium size
self powered speakers (e.g. Sony SRS-X5 portable speakers) </p>

<p>The key element here is that a step for calibration (using the USB reference
microphone) is performed, to estimate the actual response of the speakers, thus
have a solid reference to compare the built in microphone against.</p>
<table>
 <tr>
    <td width="50%">Start CTS Audio Frequency Microphone Test</td>
    <td width="50%"><img src="images/audio-framework26.png" alt="start mic test" width="300"
        id="start_mic_test" /></td>
 </tr>
 <tr>
    <td>Summary of instructions is displayed</td>
    <td><img src="images/audio-framework27.png" alt="instructions" width="300"
        id="summary_instructions" /></td>
 </tr>
 <tr>
    <td>Set up DUT in a quiet room<br>
        Position the speakers 40cm perpendicular to the center of the screen
        of the DUT (see <a href="#audio_frequency_microphone_test">Audio
        frequency microphone test </a>)</td>
    <td><img src="images/audio-framework28.png" alt="device under test" width="300"
        id="device_position" /></td>
 </tr>
 <tr>
    <td>Report if the device has a headset port:<br>
        <strong>YES</strong> if the device under test has a physical headset port<br>
        <strong>NO</strong> if there is no headset port</td>
    <td><img src="images/audio-framework-mic-port.png" alt="audio microphone test" width="300"
        id="mic_port_check" /></td>
 </tr>
 <tr>
    <td>If the answer was <strong>NO</strong> in the previous step, press
        <strong>Pass</strong> (green check) on the bottom of the test and finish</td>
    <td><img src="images/audio-framework-pass.png" alt="mic headset pass button" width="300"
        id="mic_port_pass" /></td>
 </tr>
 <tr>
    <td>If the answer was <strong>YES</strong> in the previous step, continue
        to connect external speakers.<br>
        Connect external speakers using the headphone/line out connector
        (remember to unplug any USB microphone)<br>
        Press <strong>EXTERNAL SPEAKERS READY</strong></td>
    <td><img src="images/audio-framework29.png" alt="external speakers ready" width="300"
        id="speakers_ready" /></td>
 </tr>
 <tr>
    <td>Press <strong>TEST 1</strong></td>
    <td><img src="images/audio-framework30.png" alt="no USB device" width="300"
        id="no_usb_device" /></td>
 </tr>
 <tr>
    <td>Wait several seconds for test 1 to complete.</td>
    <td><img src="images/audio-framework31.png" alt="testing underway" width="300"
        id="testing_incomplete" /></td>
 </tr>
 <tr>
    <td>When test 1 is completed, results for the built in microphone are shown.</td>
    <td><img src="images/audio-framework32.png" alt="test results" width="300"
        id="testing_complete" /></td>
 </tr>
 <tr>
    <td>Connect a USB Reference microphone (see <a
        href="#audio_frequency_speaker_test">Audio frequency speaker test
        </a>)<br>
        Press <strong>USB REFERENCE MICROPHONE READY</strong></td>
    <td><img src="images/audio-framework33.png" alt="microphone ready" width="300"
        id="mic_ready" /></td>
 </tr>
 <tr>
    <td>Position USB microphone right next to built-in microphone in DUT,
        pointing towards external speakers</td>
    <td><img src="images/audio-framework34.jpg" alt="device position" width="300"
        id="device_position" /><br>
        <img src="images/audio-framework35.png" alt="mic position" width="300"
        id="mic-position" /></td>
 </tr>
 <tr>
    <td>Press <strong>TEST 2</strong></td>
    <td><img src="images/audio-framework36.png" alt="USB detected" width="300"
        id="usb-detected" /></td>
 </tr>
 <tr>
    <td>Wait several seconds while the test 2 runs</td>
    <td><img src="images/audio-framework37.png" alt="test running" width="132"
        id="test_running" /></td>
 </tr>
 <tr>
    <td>When test 2 is completed, results for the USB reference microphone are
        shown.</td>
    <td><img src="images/audio-framework38.png" alt="testing completed" width="300"
        id="testing_completed" /></td>
 </tr>
 <tr>
    <td>Press the <strong>Pass</strong> (only available if successful) or
<strong>Failed</strong> button to record the results.</td>
    <td><img src="images/audio-framework39.png" alt="Pass button" width="300"
        id="pass_button" /><br>
        <img src="images/audio-framework40.png" alt="Failed button" width="300"
        id="failed_button" /></td>
 </tr>
</table>
