| /* |
| * Copyright (C) 2015 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. |
| */ |
| |
| package com.android.cts.verifier.audio; |
| |
| import com.android.cts.verifier.PassFailButtons; |
| import com.android.cts.verifier.R; |
| import com.android.cts.verifier.audio.wavelib.*; |
| import com.android.compatibility.common.util.CddTest; |
| import com.android.compatibility.common.util.ReportLog; |
| import com.android.compatibility.common.util.ResultType; |
| import com.android.compatibility.common.util.ResultUnit; |
| |
| import android.content.Context; |
| import android.content.BroadcastReceiver; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.media.AudioDeviceCallback; |
| import android.media.AudioDeviceInfo; |
| import android.media.AudioFormat; |
| import android.media.AudioManager; |
| import android.media.AudioTrack; |
| import android.media.AudioRecord; |
| import android.media.MediaRecorder; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.util.Log; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.widget.Button; |
| import android.widget.TextView; |
| import android.widget.SeekBar; |
| import android.widget.LinearLayout; |
| import android.widget.ProgressBar; |
| |
| /** |
| * Tests Audio built in Microphone response for Unprocessed audio source feature. |
| */ |
| @CddTest(requirement="5.11/C-1-1,C-1-2,C-1-3,C-1-4,C-1-5,C-1-6") |
| public class AudioFrequencyUnprocessedActivity extends AudioFrequencyActivity implements Runnable, |
| AudioRecord.OnRecordPositionUpdateListener { |
| private static final String TAG = "AudioFrequencyUnprocessedActivity"; |
| |
| private static final int TEST_STARTED = 900; |
| private static final int TEST_MESSAGE = 903; |
| private static final int TEST_ENDED = 904; |
| private static final int TEST_ENDED_ERROR = 905; |
| private static final double MIN_FRACTION_POINTS_IN_BAND = 0.5; |
| |
| private static final double TONE_RMS_EXPECTED = -36.0; |
| private static final double TONE_RMS_MAX_ERROR = 3.0; |
| |
| private static final double MAX_VAL = Math.pow(2, 15); |
| private static final double CLIP_LEVEL = (MAX_VAL-10) / MAX_VAL; |
| |
| private static final int SOURCE_TONE = 0; |
| private static final int SOURCE_NOISE = 1; |
| |
| private static final int TEST_NONE = -1; |
| private static final int TEST_TONE = 0; |
| private static final int TEST_NOISE = 1; |
| private static final int TEST_USB_BACKGROUND = 2; |
| private static final int TEST_USB_NOISE = 3; |
| private static final int TEST_COUNT = 4; |
| private int mCurrentTest = TEST_NONE; |
| private boolean mTestsDone[] = new boolean[TEST_COUNT]; |
| |
| private static final int TEST_DURATION_DEFAULT = 2000; |
| private static final int TEST_DURATION_TONE = TEST_DURATION_DEFAULT; |
| private static final int TEST_DURATION_NOISE = TEST_DURATION_DEFAULT; |
| private static final int TEST_DURATION_USB_BACKGROUND = TEST_DURATION_DEFAULT; |
| private static final int TEST_DURATION_USB_NOISE = TEST_DURATION_DEFAULT; |
| |
| final OnBtnClickListener mBtnClickListener = new OnBtnClickListener(); |
| Context mContext; |
| |
| LinearLayout mLayoutTestTone; |
| Button mButtonTestTone; |
| ProgressBar mProgressTone; |
| TextView mResultTestTone; |
| Button mButtonPlayTone; |
| |
| LinearLayout mLayoutTestNoise; |
| Button mButtonTestNoise; |
| ProgressBar mProgressNoise; |
| TextView mResultTestNoise; |
| Button mButtonPlayNoise; |
| |
| LinearLayout mLayoutTestUsbBackground; |
| Button mButtonTestUsbBackground; |
| ProgressBar mProgressUsbBackground; |
| TextView mResultTestUsbBackground; |
| |
| LinearLayout mLayoutTestUsbNoise; |
| Button mButtonTestUsbNoise; |
| ProgressBar mProgressUsbNoise; |
| TextView mResultTestUsbNoise; |
| Button mButtonPlayUsbNoise; |
| |
| TextView mGlobalResultText; |
| TextView mTextViewUnprocessedStatus; |
| |
| private boolean mIsRecording = false; |
| private final Object mRecordingLock = new Object(); |
| private AudioRecord mRecorder; |
| private int mMinRecordBufferSizeInSamples = 0; |
| private short[] mAudioShortArray; |
| private short[] mAudioShortArray2; |
| |
| private final int mBlockSizeSamples = 4096; |
| private final int mSamplingRate = 48000; |
| private final int mSelectedRecordSource = MediaRecorder.AudioSource.UNPROCESSED; |
| private final int mChannelConfig = AudioFormat.CHANNEL_IN_MONO; |
| private final int mAudioFormat = AudioFormat.ENCODING_PCM_16BIT; |
| private Thread mRecordThread; |
| |
| PipeShort mPipe = new PipeShort(65536); |
| |
| SoundPlayerObject mSPlayer; |
| |
| private boolean mSupportsUnprocessed = false; |
| |
| private DspBufferComplex mC; |
| private DspBufferDouble mData; |
| |
| private DspWindow mWindow; |
| private DspFftServer mFftServer; |
| private VectorAverage mFreqAverageTone = new VectorAverage(); |
| private VectorAverage mFreqAverageNoise = new VectorAverage(); |
| private VectorAverage mFreqAverageUsbBackground = new VectorAverage(); |
| private VectorAverage mFreqAverageUsbNoise = new VectorAverage(); |
| |
| //RMS for tone: |
| private double mRMS; |
| private double mRMSMax; |
| |
| private double mRMSTone; |
| private double mRMSMaxTone; |
| |
| int mBands = 3; |
| int mBandsTone = 3; |
| int mBandsBack = 3; |
| AudioBandSpecs[] mBandSpecsMic = new AudioBandSpecs[mBands]; |
| AudioBandSpecs[] mBandSpecsTone = new AudioBandSpecs[mBandsTone]; |
| AudioBandSpecs[] mBandSpecsBack = new AudioBandSpecs[mBandsBack]; |
| private Results mResultsMic; |
| private Results mResultsTone; |
| private Results mResultsBack; |
| |
| @Override |
| protected void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| setContentView(R.layout.audio_frequency_unprocessed_activity); |
| mContext = this; |
| mTextViewUnprocessedStatus = (TextView) findViewById( |
| R.id.audio_frequency_unprocessed_defined); |
| //unprocessed test |
| mSupportsUnprocessed = supportsUnprocessed(); |
| if (mSupportsUnprocessed) { |
| mTextViewUnprocessedStatus.setText( |
| getResources().getText(R.string.audio_frequency_unprocessed_defined)); |
| } else { |
| mTextViewUnprocessedStatus.setText( |
| getResources().getText(R.string.audio_frequency_unprocessed_not_defined)); |
| } |
| |
| mSPlayer = new SoundPlayerObject(); |
| playerSetSource(SOURCE_TONE); |
| |
| // Test tone |
| mLayoutTestTone = (LinearLayout) findViewById(R.id.unprocessed_layout_test_tone); |
| mButtonTestTone = (Button) findViewById(R.id.unprocessed_test_tone_btn); |
| mButtonTestTone.setOnClickListener(mBtnClickListener); |
| mProgressTone = (ProgressBar) findViewById(R.id.unprocessed_test_tone_progress_bar); |
| mResultTestTone = (TextView) findViewById(R.id.unprocessed_test_tone_result); |
| mButtonPlayTone = (Button) findViewById(R.id.unprocessed_play_tone_btn); |
| mButtonPlayTone.setOnClickListener(mBtnClickListener); |
| showWait(mProgressTone, false); |
| |
| //Test Noise |
| mLayoutTestNoise = (LinearLayout) findViewById(R.id.unprocessed_layout_test_noise); |
| mButtonTestNoise = (Button) findViewById(R.id.unprocessed_test_noise_btn); |
| mButtonTestNoise.setOnClickListener(mBtnClickListener); |
| mProgressNoise = (ProgressBar) findViewById(R.id.unprocessed_test_noise_progress_bar); |
| mResultTestNoise = (TextView) findViewById(R.id.unprocessed_test_noise_result); |
| mButtonPlayNoise = (Button) findViewById(R.id.unprocessed_play_noise_btn); |
| mButtonPlayNoise.setOnClickListener(mBtnClickListener); |
| showWait(mProgressNoise, false); |
| |
| //USB Background |
| mLayoutTestUsbBackground = (LinearLayout) |
| findViewById(R.id.unprocessed_layout_test_usb_background); |
| mButtonTestUsbBackground = (Button) findViewById(R.id.unprocessed_test_usb_background_btn); |
| mButtonTestUsbBackground.setOnClickListener(mBtnClickListener); |
| mProgressUsbBackground = (ProgressBar) |
| findViewById(R.id.unprocessed_test_usb_background_progress_bar); |
| mResultTestUsbBackground = (TextView) |
| findViewById(R.id.unprocessed_test_usb_background_result); |
| showWait(mProgressUsbBackground, false); |
| |
| mLayoutTestUsbNoise = (LinearLayout) findViewById(R.id.unprocessed_layout_test_usb_noise); |
| mButtonTestUsbNoise = (Button) findViewById(R.id.unprocessed_test_usb_noise_btn); |
| mButtonTestUsbNoise.setOnClickListener(mBtnClickListener); |
| mProgressUsbNoise = (ProgressBar)findViewById(R.id.unprocessed_test_usb_noise_progress_bar); |
| mResultTestUsbNoise = (TextView) findViewById(R.id.unprocessed_test_usb_noise_result); |
| mButtonPlayUsbNoise = (Button) findViewById(R.id.unprocessed_play_usb_noise_btn); |
| mButtonPlayUsbNoise.setOnClickListener(mBtnClickListener); |
| showWait(mProgressUsbNoise, false); |
| |
| setButtonPlayStatus(-1); |
| mGlobalResultText = (TextView) findViewById(R.id.unprocessed_test_global_result); |
| |
| //Init FFT stuff |
| mAudioShortArray2 = new short[mBlockSizeSamples*2]; |
| mData = new DspBufferDouble(mBlockSizeSamples); |
| mC = new DspBufferComplex(mBlockSizeSamples); |
| mFftServer = new DspFftServer(mBlockSizeSamples); |
| |
| int overlap = mBlockSizeSamples / 2; |
| |
| mWindow = new DspWindow(DspWindow.WINDOW_HANNING, mBlockSizeSamples, overlap); |
| |
| setPassFailButtonClickListeners(); |
| getPassButton().setEnabled(false); |
| setInfoResources(R.string.audio_frequency_unprocessed_test, |
| R.string.audio_frequency_unprocessed_info, -1); |
| |
| //Init bands for Mic test |
| mBandSpecsMic[0] = new AudioBandSpecs( |
| 5, 100, /* frequency start,stop */ |
| 20.0, -20.0, /* start top,bottom value */ |
| 20.0, -20.0 /* stop top,bottom value */); |
| |
| mBandSpecsMic[1] = new AudioBandSpecs( |
| 100, 7000, /* frequency start,stop */ |
| 10.0, -10.0, /* start top,bottom value */ |
| 10.0, -10.0 /* stop top,bottom value */); |
| |
| mBandSpecsMic[2] = new AudioBandSpecs( |
| 7000, 20000, /* frequency start,stop */ |
| 30.0, -30.0, /* start top,bottom value */ |
| 30.0, -30.0 /* stop top,bottom value */); |
| |
| //Init bands for Tone test |
| mBandSpecsTone[0] = new AudioBandSpecs( |
| 5, 900, /* frequency start,stop */ |
| -10.0, -100.0, /* start top,bottom value */ |
| -10.0, -100.0 /* stop top,bottom value */); |
| |
| mBandSpecsTone[1] = new AudioBandSpecs( |
| 900, 1100, /* frequency start,stop */ |
| 10.0, -50.0, /* start top,bottom value */ |
| 10.0, -10.0 /* stop top,bottom value */); |
| |
| mBandSpecsTone[2] = new AudioBandSpecs( |
| 1100, 20000, /* frequency start,stop */ |
| -30.0, -120.0, /* start top,bottom value */ |
| -30.0, -120.0 /* stop top,bottom value */); |
| |
| //Init bands for Background test |
| mBandSpecsBack[0] = new AudioBandSpecs( |
| 5, 100, /* frequency start,stop */ |
| 10.0, -120.0, /* start top,bottom value */ |
| -10.0, -120.0 /* stop top,bottom value */); |
| |
| mBandSpecsBack[1] = new AudioBandSpecs( |
| 100, 7000, /* frequency start,stop */ |
| -10.0, -120.0, /* start top,bottom value */ |
| -50.0, -120.0 /* stop top,bottom value */); |
| |
| mBandSpecsBack[2] = new AudioBandSpecs( |
| 7000, 20000, /* frequency start,stop */ |
| -50.0, -120.0, /* start top,bottom value */ |
| -50.0, -120.0 /* stop top,bottom value */); |
| |
| mSupportsUnprocessed = supportsUnprocessed(); |
| Log.v(TAG, "Supports unprocessed: " + mSupportsUnprocessed); |
| |
| mResultsMic = new Results("mic_response", mBands); |
| mResultsTone = new Results("tone_response", mBandsTone); |
| mResultsBack = new Results("background_response", mBandsBack); |
| } |
| |
| private void playerToggleButton(int buttonId, int sourceId) { |
| if (playerIsPlaying()) { |
| playerStopAll(); |
| } else { |
| playerSetSource(sourceId); |
| playerTransport(true); |
| setButtonPlayStatus(buttonId); |
| } |
| } |
| |
| private class OnBtnClickListener implements OnClickListener { |
| @Override |
| public void onClick(View v) { |
| int id = v.getId(); |
| switch (id) { |
| case R.id.unprocessed_test_tone_btn: |
| startTest(TEST_TONE); |
| break; |
| case R.id.unprocessed_play_tone_btn: |
| playerToggleButton(id, SOURCE_TONE); |
| break; |
| case R.id.unprocessed_test_noise_btn: |
| startTest(TEST_NOISE); |
| break; |
| case R.id.unprocessed_play_noise_btn: |
| playerToggleButton(id, SOURCE_NOISE); |
| break; |
| case R.id.unprocessed_test_usb_background_btn: |
| startTest(TEST_USB_BACKGROUND); |
| break; |
| case R.id.unprocessed_test_usb_noise_btn: |
| startTest(TEST_USB_NOISE); |
| break; |
| case R.id.unprocessed_play_usb_noise_btn: |
| playerToggleButton(id, SOURCE_NOISE); |
| break; |
| } |
| } |
| } |
| |
| private void setButtonPlayStatus(int playResId) { |
| String play = getResources().getText(R.string.unprocessed_play).toString(); |
| String stop = getResources().getText(R.string.unprocessed_stop).toString(); |
| |
| mButtonPlayTone.setText(playResId == R.id.unprocessed_play_tone_btn ? stop : play); |
| mButtonPlayNoise.setText(playResId == R.id.unprocessed_play_noise_btn ? stop : play); |
| mButtonPlayUsbNoise.setText(playResId == |
| R.id.unprocessed_play_usb_noise_btn ? stop : play); |
| } |
| |
| private void playerSetSource(int sourceIndex) { |
| switch (sourceIndex) { |
| case SOURCE_TONE: |
| mSPlayer.setSoundWithResId(getApplicationContext(), R.raw.onekhztone); |
| break; |
| default: |
| case SOURCE_NOISE: |
| mSPlayer.setSoundWithResId(getApplicationContext(), |
| R.raw.stereo_mono_white_noise_48); |
| break; |
| } |
| } |
| |
| private void playerTransport(boolean play) { |
| if (!mSPlayer.isAlive()) { |
| mSPlayer.start(); |
| } |
| mSPlayer.play(play); |
| } |
| |
| private boolean playerIsPlaying() { |
| return mSPlayer.isPlaying(); |
| } |
| |
| private void playerStopAll() { |
| if (mSPlayer.isAlive() && mSPlayer.isPlaying()) { |
| mSPlayer.play(false); |
| setButtonPlayStatus(-1); |
| } |
| } |
| |
| /** |
| * enable test ui elements |
| */ |
| private void enableLayout(LinearLayout layout, boolean enable) { |
| for (int i = 0; i < layout.getChildCount(); i++) { |
| View view = layout.getChildAt(i); |
| view.setEnabled(enable); |
| } |
| } |
| |
| private void showWait(ProgressBar pb, boolean show) { |
| if (show) { |
| pb.setVisibility(View.VISIBLE); |
| } else { |
| pb.setVisibility(View.INVISIBLE); |
| } |
| } |
| |
| private String getTestString(int testId) { |
| String name = "undefined"; |
| switch(testId) { |
| case TEST_TONE: |
| name = "BuiltIn_tone"; |
| break; |
| case TEST_NOISE: |
| name = "BuiltIn_noise"; |
| break; |
| case TEST_USB_BACKGROUND: |
| name = "USB_background"; |
| break; |
| case TEST_USB_NOISE: |
| name = "USB_noise"; |
| break; |
| } |
| return name; |
| } |
| |
| private void showWait(int testId, boolean show) { |
| switch(testId) { |
| case TEST_TONE: |
| showWait(mProgressTone, show); |
| break; |
| case TEST_NOISE: |
| showWait(mProgressNoise, show); |
| break; |
| case TEST_USB_BACKGROUND: |
| showWait(mProgressUsbBackground, show); |
| break; |
| case TEST_USB_NOISE: |
| showWait(mProgressUsbNoise, show); |
| break; |
| } |
| } |
| |
| private void showMessage(int testId, String msg) { |
| if (msg != null && msg.length() > 0) { |
| switch(testId) { |
| case TEST_TONE: |
| mResultTestTone.setText(msg); |
| break; |
| case TEST_NOISE: |
| mResultTestNoise.setText(msg); |
| break; |
| case TEST_USB_BACKGROUND: |
| mResultTestUsbBackground.setText(msg); |
| break; |
| case TEST_USB_NOISE: |
| mResultTestUsbNoise.setText(msg); |
| break; |
| } |
| } |
| } |
| |
| private boolean supportsUnprocessed() { |
| boolean unprocessedSupport = false; |
| AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE); |
| String unprocessedSupportString = am.getProperty( |
| AudioManager.PROPERTY_SUPPORT_AUDIO_SOURCE_UNPROCESSED); |
| Log.v(TAG,"unprocessed support: " + unprocessedSupportString); |
| if (unprocessedSupportString == null || |
| unprocessedSupportString.equalsIgnoreCase(getResources().getString( |
| R.string.audio_general_default_false_string))) { |
| unprocessedSupport = false; |
| } else { |
| unprocessedSupport = true; |
| } |
| return unprocessedSupport; |
| } |
| |
| private void computeAllResults() { |
| StringBuilder sb = new StringBuilder(); |
| |
| boolean allDone = true; |
| |
| for (int i=0; i<TEST_COUNT; i++) { |
| allDone = allDone & mTestsDone[i]; |
| sb.append(String.format("%s : %s\n", getTestString(i), |
| mTestsDone[i] ? "DONE" :" NOT DONE")); |
| } |
| |
| if (allDone) { |
| sb.append(computeResults()); |
| } else { |
| sb.append("Please execute all tests for results\n"); |
| } |
| mGlobalResultText.setText(sb.toString()); |
| } |
| |
| private void processSpectrum(Results results, AudioBandSpecs[] bandsSpecs, int anchorBand) { |
| int points = results.mValuesLog.length; |
| int bandCount = bandsSpecs.length; |
| int currentBand = 0; |
| for (int i = 0; i < points; i++) { |
| double freq = (double)mSamplingRate * i / (double)mBlockSizeSamples; |
| if (freq > bandsSpecs[currentBand].mFreqStop) { |
| currentBand++; |
| if (currentBand >= bandCount) |
| break; |
| } |
| |
| if (freq >= bandsSpecs[currentBand].mFreqStart) { |
| results.mAverageEnergyPerBand[currentBand] += results.mValuesLog[i]; |
| results.mPointsPerBand[currentBand]++; |
| } |
| } |
| |
| for (int b = 0; b < bandCount; b++) { |
| if (results.mPointsPerBand[b] > 0) { |
| results.mAverageEnergyPerBand[b] = |
| results.mAverageEnergyPerBand[b] / results.mPointsPerBand[b]; |
| } |
| } |
| |
| //set offset relative to band anchor band level |
| for (int b = 0; b < bandCount; b++) { |
| if (anchorBand > -1 && anchorBand < bandCount) { |
| bandsSpecs[b].setOffset(results.mAverageEnergyPerBand[anchorBand]); |
| } else { |
| bandsSpecs[b].setOffset(0); |
| } |
| } |
| |
| //test points in band. |
| currentBand = 0; |
| for (int i = 0; i < points; i++) { |
| double freq = (double) mSamplingRate * i / (double) mBlockSizeSamples; |
| if (freq > bandsSpecs[currentBand].mFreqStop) { |
| currentBand++; |
| if (currentBand >= bandCount) |
| break; |
| } |
| |
| if (freq >= bandsSpecs[currentBand].mFreqStart) { |
| double value = results.mValuesLog[i]; |
| if (bandsSpecs[currentBand].isInBounds(freq, value)) { |
| results.mInBoundPointsPerBand[currentBand]++; |
| } |
| } |
| } |
| } |
| |
| private String computeResults() { |
| StringBuilder sb = new StringBuilder(); |
| |
| int points = mFreqAverageNoise.getSize(); |
| //mFreqAverageNoise size is determined by the latest data writen to it. |
| //Currently, this data is always mBlockSizeSamples/2. |
| if (points < 1) { |
| return "error: not enough points"; |
| } |
| |
| double[] tone = new double[points]; |
| double[] noise = new double[points]; |
| double[] reference = new double[points]; |
| double[] background = new double[points]; |
| |
| mFreqAverageTone.getData(tone, false); |
| mFreqAverageNoise.getData(noise, false); |
| mFreqAverageUsbNoise.getData(reference, false); |
| mFreqAverageUsbBackground.getData(background, false); |
| |
| //Convert to dB |
| double[] toneDb = new double[points]; |
| double[] noiseDb = new double[points]; |
| double[] referenceDb = new double[points]; |
| double[] backgroundDb = new double[points]; |
| |
| double[] compensatedNoiseDb = new double[points]; |
| |
| for (int i = 0; i < points; i++) { |
| toneDb[i] = 20 * Math.log10(tone[i]); |
| noiseDb[i] = 20 * Math.log10(noise[i]); |
| referenceDb[i] = 20 * Math.log10(reference[i]); |
| backgroundDb[i] = 20 * Math.log10(background[i]); |
| |
| compensatedNoiseDb[i] = noiseDb[i] - referenceDb[i]; |
| } |
| |
| mResultsMic.reset(); |
| mResultsTone.reset(); |
| mResultsBack.reset(); |
| |
| mResultsMic.mValuesLog = compensatedNoiseDb; |
| mResultsTone.mValuesLog = toneDb; |
| mResultsBack.mValuesLog = backgroundDb; |
| |
| processSpectrum(mResultsMic, mBandSpecsMic, 1); |
| processSpectrum(mResultsTone, mBandSpecsTone, 1); |
| processSpectrum(mResultsBack, mBandSpecsBack, -1); //no reference for offset |
| |
| //Tone test |
| boolean toneTestSuccess = true; |
| { |
| //rms level should be -36 dbfs +/- 3 db? |
| double rmsMaxDb = 20 * Math.log10(mRMSMaxTone); |
| sb.append(String.format("RMS level of tone: %.2f dBFS\n", rmsMaxDb)); |
| sb.append(String.format("Target RMS level: %.2f dBFS +/- %.2f dB\n", |
| TONE_RMS_EXPECTED, |
| TONE_RMS_MAX_ERROR)); |
| if (Math.abs(rmsMaxDb - TONE_RMS_EXPECTED) > TONE_RMS_MAX_ERROR) { |
| toneTestSuccess = false; |
| sb.append("RMS level test FAILED\n"); |
| } else { |
| sb.append(" RMS level test SUCCESSFUL\n"); |
| } |
| //check the spectrum is really a tone around 1 khz |
| } |
| |
| sb.append("\n"); |
| sb.append(mResultsTone.toString()); |
| if (mResultsTone.testAll()) { |
| sb.append(" 1 Khz Tone Frequency Response Test SUCCESSFUL\n"); |
| } else { |
| sb.append(" 1 Khz Tone Frequency Response Test FAILED\n"); |
| } |
| sb.append("\n"); |
| |
| sb.append("\n"); |
| sb.append(mResultsBack.toString()); |
| if (mResultsBack.testAll()) { |
| sb.append(" Background environment Test SUCCESSFUL\n"); |
| } else { |
| sb.append(" Background environment Test FAILED\n"); |
| } |
| |
| sb.append("\n"); |
| sb.append(mResultsMic.toString()); |
| if (mResultsMic.testAll()) { |
| sb.append(" Frequency Response Test SUCCESSFUL\n"); |
| } else { |
| sb.append(" Frequency Response Test FAILED\n"); |
| } |
| sb.append("\n"); |
| |
| recordTestResults(mResultsTone); |
| recordTestResults(mResultsMic); |
| |
| boolean allTestsPassed = false; |
| if (mResultsMic.testAll() && mResultsTone.testAll() && toneTestSuccess && |
| mResultsBack.testAll()) { |
| allTestsPassed = true; |
| String strSuccess = getResources().getString(R.string.audio_general_test_passed); |
| sb.append(strSuccess); |
| } else { |
| String strFailed = getResources().getString(R.string.audio_general_test_failed); |
| sb.append(strFailed); |
| } |
| |
| sb.append("\n"); |
| if (mSupportsUnprocessed) { //test is mandatory |
| sb.append(getResources().getText( |
| R.string.audio_frequency_unprocessed_defined).toString()); |
| if (allTestsPassed) { |
| getPassButton().setEnabled(true); |
| } else { |
| getPassButton().setEnabled(false); |
| } |
| } else { |
| //test optional |
| sb.append(getResources().getText( |
| R.string.audio_frequency_unprocessed_not_defined).toString()); |
| getPassButton().setEnabled(true); |
| } |
| return sb.toString(); |
| } |
| |
| Thread mTestThread; |
| private void startTest(int testId) { |
| if (mTestThread != null && !mTestThread.isAlive()) { |
| mTestThread = null; //kill it. |
| } |
| |
| if (mTestThread == null) { |
| mRMS = 0; |
| mRMSMax = 0; |
| Log.v(TAG,"Executing test Thread"); |
| switch(testId) { |
| case TEST_TONE: |
| mTestThread = new Thread(new TestRunnable(TEST_TONE) { |
| public void run() { |
| super.run(); |
| if (!mUsbMicConnected) { |
| sendMessage(mTestId, TEST_MESSAGE, |
| "Testing Built in Microphone: Tone"); |
| mRMSTone = 0; |
| mRMSMaxTone = 0; |
| mFreqAverageTone.reset(); |
| mFreqAverageTone.setCaptureType(VectorAverage.CAPTURE_TYPE_MAX); |
| record(TEST_DURATION_TONE); |
| sendMessage(mTestId, TEST_ENDED, "Testing Completed"); |
| mTestsDone[mTestId] = true; |
| } else { |
| sendMessage(mTestId, TEST_ENDED_ERROR, |
| "Please Unplug USB Microphone"); |
| mTestsDone[mTestId] = false; |
| } |
| } |
| }); |
| break; |
| case TEST_NOISE: |
| mTestThread = new Thread(new TestRunnable(TEST_NOISE) { |
| public void run() { |
| super.run(); |
| if (!mUsbMicConnected) { |
| sendMessage(mTestId, TEST_MESSAGE, |
| "Testing Built in Microphone: Noise"); |
| mFreqAverageNoise.reset(); |
| mFreqAverageNoise.setCaptureType(VectorAverage.CAPTURE_TYPE_MAX); |
| record(TEST_DURATION_NOISE); |
| sendMessage(mTestId, TEST_ENDED, "Testing Completed"); |
| mTestsDone[mTestId] = true; |
| } else { |
| sendMessage(mTestId, TEST_ENDED_ERROR, |
| "Please Unplug USB Microphone"); |
| mTestsDone[mTestId] = false; |
| } |
| } |
| }); |
| break; |
| case TEST_USB_BACKGROUND: |
| playerStopAll(); |
| mTestThread = new Thread(new TestRunnable(TEST_USB_BACKGROUND) { |
| public void run() { |
| super.run(); |
| if (mUsbMicConnected) { |
| sendMessage(mTestId, TEST_MESSAGE, |
| "Testing USB Microphone: background"); |
| mFreqAverageUsbBackground.reset(); |
| mFreqAverageUsbBackground.setCaptureType( |
| VectorAverage.CAPTURE_TYPE_AVERAGE); |
| record(TEST_DURATION_USB_BACKGROUND); |
| sendMessage(mTestId, TEST_ENDED, "Testing Completed"); |
| mTestsDone[mTestId] = true; |
| } else { |
| sendMessage(mTestId, TEST_ENDED_ERROR, |
| "USB Microphone not detected."); |
| mTestsDone[mTestId] = false; |
| } |
| } |
| }); |
| break; |
| case TEST_USB_NOISE: |
| mTestThread = new Thread(new TestRunnable(TEST_USB_NOISE) { |
| public void run() { |
| super.run(); |
| if (mUsbMicConnected) { |
| sendMessage(mTestId, TEST_MESSAGE, "Testing USB Microphone: Noise"); |
| mFreqAverageUsbNoise.reset(); |
| mFreqAverageUsbNoise.setCaptureType(VectorAverage.CAPTURE_TYPE_MAX); |
| record(TEST_DURATION_USB_NOISE); |
| sendMessage(mTestId, TEST_ENDED, "Testing Completed"); |
| mTestsDone[mTestId] = true; |
| } else { |
| sendMessage(mTestId, TEST_ENDED_ERROR, |
| "USB Microphone not detected."); |
| mTestsDone[mTestId] = false; |
| } |
| } |
| }); |
| break; |
| } |
| mTestThread.start(); |
| } else { |
| Log.v(TAG,"test Thread already running."); |
| } |
| } |
| public class TestRunnable implements Runnable { |
| public int mTestId; |
| public boolean mUsbMicConnected; |
| TestRunnable(int testId) { |
| Log.v(TAG,"New TestRunnable"); |
| mTestId = testId; |
| } |
| public void run() { |
| mCurrentTest = mTestId; |
| sendMessage(mTestId, TEST_STARTED,""); |
| mUsbMicConnected = |
| UsbMicrophoneTester.getIsMicrophoneConnected(getApplicationContext()); |
| }; |
| public void record(int durationMs) { |
| startRecording(); |
| try { |
| Thread.sleep(durationMs); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| //restore interrupted status |
| Thread.currentThread().interrupt(); |
| } |
| stopRecording(); |
| } |
| public void sendMessage(int testId, int msgType, String str) { |
| Message msg = Message.obtain(); |
| msg.what = msgType; |
| msg.obj = str; |
| msg.arg1 = testId; |
| mMessageHandler.sendMessage(msg); |
| } |
| } |
| |
| private Handler mMessageHandler = new Handler() { |
| public void handleMessage(Message msg) { |
| super.handleMessage(msg); |
| int testId = msg.arg1; //testId |
| String str = (String) msg.obj; |
| switch (msg.what) { |
| case TEST_STARTED: |
| showWait(testId, true); |
| // getPassButton().setEnabled(false); |
| break; |
| case TEST_MESSAGE: |
| showMessage(testId, str); |
| break; |
| case TEST_ENDED: |
| showWait(testId, false); |
| playerStopAll(); |
| showMessage(testId, str); |
| appendResultsToScreen(testId, "test finished"); |
| computeAllResults(); |
| break; |
| case TEST_ENDED_ERROR: |
| showWait(testId, false); |
| playerStopAll(); |
| showMessage(testId, str); |
| computeAllResults(); |
| default: |
| Log.e(TAG, String.format("Unknown message: %d", msg.what)); |
| } |
| } |
| }; |
| |
| private class Results { |
| private int mBandCount; |
| private String mLabel; |
| public double[] mValuesLog; |
| int[] mPointsPerBand; // = new int[mBands]; |
| double[] mAverageEnergyPerBand;// = new double[mBands]; |
| int[] mInBoundPointsPerBand;// = new int[mBands]; |
| public Results(String label, int bandCount) { |
| mLabel = label; |
| mBandCount = bandCount; |
| mPointsPerBand = new int[mBandCount]; |
| mAverageEnergyPerBand = new double[mBandCount]; |
| mInBoundPointsPerBand = new int[mBandCount]; |
| } |
| public void reset() { |
| for (int i = 0; i < mBandCount; i++) { |
| mPointsPerBand[i] = 0; |
| mAverageEnergyPerBand[i] = 0; |
| mInBoundPointsPerBand[i] = 0; |
| } |
| } |
| |
| //append results |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| sb.append(String.format("Channel %s\n", mLabel)); |
| for (int b = 0; b < mBandCount; b++) { |
| double percent = 0; |
| if (mPointsPerBand[b] > 0) { |
| percent = 100.0 * (double) mInBoundPointsPerBand[b] / mPointsPerBand[b]; |
| } |
| sb.append(String.format( |
| " Band %d: Av. Level: %.1f dB InBand: %d/%d (%.1f%%) %s\n", |
| b, mAverageEnergyPerBand[b], |
| mInBoundPointsPerBand[b], |
| mPointsPerBand[b], |
| percent, |
| (testInBand(b) ? "OK" : "Not Optimal"))); |
| } |
| return sb.toString(); |
| } |
| |
| public boolean testInBand(int b) { |
| if (b >= 0 && b < mBandCount && mPointsPerBand[b] > 0) { |
| if ((double) mInBoundPointsPerBand[b] / mPointsPerBand[b] > |
| MIN_FRACTION_POINTS_IN_BAND) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public boolean testAll() { |
| for (int b = 0; b < mBandCount; b++) { |
| if (!testInBand(b)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| } |
| |
| |
| // /** |
| // * compute test results |
| // */ |
| // private void computeTestResults(int testId) { |
| // String testName = getTestString(testId); |
| // appendResultsToScreen(testId, "test finished"); |
| // } |
| |
| //append results |
| private void appendResultsToScreen(String str, TextView text) { |
| String currentText = text.getText().toString(); |
| text.setText(currentText + "\n" + str); |
| } |
| |
| private void appendResultsToScreen(int testId, String str) { |
| switch(testId) { |
| case TEST_TONE: |
| appendResultsToScreen(str, mResultTestTone); |
| showToneRMS(); |
| break; |
| case TEST_NOISE: |
| appendResultsToScreen(str, mResultTestNoise); |
| break; |
| case TEST_USB_BACKGROUND: |
| appendResultsToScreen(str, mResultTestUsbBackground); |
| break; |
| case TEST_USB_NOISE: |
| appendResultsToScreen(str, mResultTestUsbNoise); |
| break; |
| } |
| } |
| |
| /** |
| * Store test results in log |
| */ |
| private void recordTestResults(Results results) { |
| String channelLabel = "channel_" + results.mLabel; |
| |
| for (int b = 0; b < mBands; b++) { |
| String bandLabel = String.format(channelLabel + "_%d", b); |
| getReportLog().addValue( |
| bandLabel + "_Level", |
| results.mAverageEnergyPerBand[b], |
| ResultType.HIGHER_BETTER, |
| ResultUnit.NONE); |
| |
| getReportLog().addValue( |
| bandLabel + "_pointsinbound", |
| results.mInBoundPointsPerBand[b], |
| ResultType.HIGHER_BETTER, |
| ResultUnit.COUNT); |
| |
| getReportLog().addValue( |
| bandLabel + "_pointstotal", |
| results.mPointsPerBand[b], |
| ResultType.NEUTRAL, |
| ResultUnit.COUNT); |
| } |
| |
| getReportLog().addValues(channelLabel + "_magnitudeSpectrumLog", |
| results.mValuesLog, |
| ResultType.NEUTRAL, |
| ResultUnit.NONE); |
| |
| Log.v(TAG, "Results Recorded"); |
| } |
| |
| private void recordHeasetPortFound(boolean found) { |
| getReportLog().addValue( |
| "User Reported Headset Port", |
| found ? 1.0 : 0, |
| ResultType.NEUTRAL, |
| ResultUnit.NONE); |
| } |
| |
| private void startRecording() { |
| synchronized (mRecordingLock) { |
| mIsRecording = true; |
| } |
| |
| boolean successful = initRecord(); |
| if (successful) { |
| startRecordingForReal(); |
| } else { |
| Log.v(TAG, "Recorder initialization error."); |
| synchronized (mRecordingLock) { |
| mIsRecording = false; |
| } |
| } |
| } |
| |
| private void startRecordingForReal() { |
| // start streaming |
| if (mRecordThread == null) { |
| mRecordThread = new Thread(AudioFrequencyUnprocessedActivity.this); |
| mRecordThread.setName("FrequencyAnalyzerThread"); |
| } |
| if (!mRecordThread.isAlive()) { |
| mRecordThread.start(); |
| } |
| |
| mPipe.flush(); |
| |
| long startTime = SystemClock.uptimeMillis(); |
| mRecorder.startRecording(); |
| if (mRecorder.getRecordingState() != AudioRecord.RECORDSTATE_RECORDING) { |
| stopRecording(); |
| return; |
| } |
| Log.v(TAG, "Start time: " + (long) (SystemClock.uptimeMillis() - startTime) + " ms"); |
| } |
| |
| private void stopRecording() { |
| synchronized (mRecordingLock) { |
| stopRecordingForReal(); |
| mIsRecording = false; |
| } |
| } |
| |
| private void stopRecordingForReal() { |
| |
| // stop streaming |
| Thread zeThread = mRecordThread; |
| mRecordThread = null; |
| if (zeThread != null) { |
| zeThread.interrupt(); |
| try { |
| zeThread.join(); |
| } catch(InterruptedException e) { |
| //restore interrupted status of recording thread |
| zeThread.interrupt(); |
| } |
| } |
| // release recording resources |
| if (mRecorder != null) { |
| mRecorder.stop(); |
| mRecorder.release(); |
| mRecorder = null; |
| } |
| } |
| |
| private boolean initRecord() { |
| int minRecordBuffSizeInBytes = AudioRecord.getMinBufferSize(mSamplingRate, |
| mChannelConfig, mAudioFormat); |
| Log.v(TAG,"FrequencyAnalyzer: min buff size = " + minRecordBuffSizeInBytes + " bytes"); |
| if (minRecordBuffSizeInBytes <= 0) { |
| return false; |
| } |
| |
| mMinRecordBufferSizeInSamples = minRecordBuffSizeInBytes / 2; |
| // allocate the byte array to read the audio data |
| |
| mAudioShortArray = new short[mMinRecordBufferSizeInSamples]; |
| |
| Log.v(TAG, "Initiating record:"); |
| Log.v(TAG, " using source " + mSelectedRecordSource); |
| Log.v(TAG, " at " + mSamplingRate + "Hz"); |
| |
| try { |
| mRecorder = new AudioRecord(mSelectedRecordSource, mSamplingRate, |
| mChannelConfig, mAudioFormat, 2 * minRecordBuffSizeInBytes); |
| } catch (IllegalArgumentException e) { |
| return false; |
| } |
| if (mRecorder.getState() != AudioRecord.STATE_INITIALIZED) { |
| mRecorder.release(); |
| mRecorder = null; |
| return false; |
| } |
| mRecorder.setRecordPositionUpdateListener(this); |
| mRecorder.setPositionNotificationPeriod(mBlockSizeSamples / 2); |
| return true; |
| } |
| private void showToneRMS() { |
| String str = String.format("RMS: %.3f dBFS. Max RMS: %.3f dBFS", |
| 20 * Math.log10(mRMSTone), |
| 20 * Math.log10(mRMSMaxTone)); |
| showMessage(TEST_TONE, str); |
| } |
| |
| // --------------------------------------------------------- |
| // Implementation of AudioRecord.OnPeriodicNotificationListener |
| // -------------------- |
| public void onPeriodicNotification(AudioRecord recorder) { |
| int samplesAvailable = mPipe.availableToRead(); |
| int samplesNeeded = mBlockSizeSamples; |
| if (samplesAvailable >= samplesNeeded) { |
| mPipe.read(mAudioShortArray2, 0, samplesNeeded); |
| |
| //compute stuff. |
| int clipcount = 0; |
| // double sum = 0; |
| double maxabs = 0; |
| int i; |
| double rmsTempSum = 0; |
| |
| for (i = 0; i < samplesNeeded; i++) { |
| double value = mAudioShortArray2[i] / MAX_VAL; |
| double valueabs = Math.abs(value); |
| |
| if (valueabs > maxabs) { |
| maxabs = valueabs; |
| } |
| |
| if (valueabs > CLIP_LEVEL) { |
| clipcount++; |
| } |
| |
| rmsTempSum += value * value; |
| //fft stuff |
| mData.mData[i] = value; |
| } |
| double rms = Math.sqrt(rmsTempSum / samplesNeeded); |
| |
| double alpha = 0.9; |
| double total_rms = rms * alpha + mRMS *(1-alpha); |
| mRMS = total_rms; |
| if (mRMS > mRMSMax) { |
| mRMSMax = mRMS; |
| } |
| |
| //for the current frame, compute FFT and send to the viewer. |
| |
| //apply window and pack as complex for now. |
| DspBufferMath.mult(mData, mData, mWindow.mBuffer); |
| DspBufferMath.set(mC, mData); |
| mFftServer.fft(mC, 1); |
| |
| double[] halfMagnitude = new double[mBlockSizeSamples / 2]; |
| for (i = 0; i < mBlockSizeSamples / 2; i++) { |
| halfMagnitude[i] = Math.sqrt(mC.mReal[i] * mC.mReal[i] + mC.mImag[i] * mC.mImag[i]); |
| } |
| |
| switch(mCurrentTest) { |
| case TEST_TONE: { |
| mFreqAverageTone.setData(halfMagnitude, false); |
| //Update realtime info on screen |
| mRMSTone = mRMS; |
| mRMSMaxTone = mRMSMax; |
| showToneRMS(); |
| } |
| break; |
| case TEST_NOISE: |
| mFreqAverageNoise.setData(halfMagnitude, false); |
| break; |
| case TEST_USB_BACKGROUND: |
| mFreqAverageUsbBackground.setData(halfMagnitude, false); |
| break; |
| case TEST_USB_NOISE: |
| mFreqAverageUsbNoise.setData(halfMagnitude, false); |
| break; |
| } |
| } |
| } |
| |
| public void onMarkerReached(AudioRecord track) { |
| } |
| |
| // --------------------------------------------------------- |
| // Implementation of Runnable for the audio recording + playback |
| // -------------------- |
| public void run() { |
| Thread thisThread = Thread.currentThread(); |
| while (!thisThread.isInterrupted()) { |
| // read from native recorder |
| int nSamplesRead = mRecorder.read(mAudioShortArray, 0, mMinRecordBufferSizeInSamples); |
| if (nSamplesRead > 0) { |
| mPipe.write(mAudioShortArray, 0, nSamplesRead); |
| } |
| } |
| } |
| } |
