--- /dev/null
+/*
+ * Copyright (C) 2010 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.audioquality;
+
+import android.content.Context;
+import android.media.AudioFormat;
+import android.media.AudioTrack;
+import android.os.Environment;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * File and data utilities for the Audio Verifier.
+ */
+public class Utils {
+ public static final String TAG = "AudioQualityVerifier";
+ public static final ByteOrder BYTE_ORDER = ByteOrder.LITTLE_ENDIAN;
+
+ /**
+ * Time delay.
+ *
+ * @param ms time in milliseconds to pause for
+ */
+ public static void delay(int ms) {
+ try {
+ Thread.sleep(ms);
+ } catch (InterruptedException e) {}
+ }
+
+ public static String getExternalDir(Context context, Object exp) {
+ checkExternalStorageAvailable();
+ // API level 8:
+ // return context.getExternalFilesDir(null).getAbsolutePath();
+ // API level < 8:
+ String dir = Environment.getExternalStorageDirectory().getAbsolutePath();
+ dir += "/Android/data/" + exp.getClass().getPackage().getName() + "/files";
+ checkMakeDir(dir);
+ return dir;
+ }
+
+ private static void checkExternalStorageAvailable() {
+ String state = Environment.getExternalStorageState();
+ if (!Environment.MEDIA_MOUNTED.equals(state)) {
+ // TODO: Raise a Toast and supply internal storage instead
+ }
+ }
+
+ private static void checkMakeDir(String dir) {
+ File f = new File(dir);
+ if (!f.exists()) {
+ f.mkdirs();
+ }
+ }
+
+ /**
+ * Convert a string (e.g. the name of an experiment) to something more suitable
+ * for use as a filename.
+ *
+ * @param s the string to be cleaned
+ * @return a string which is similar (not necessarily unique) and safe for filename use
+ */
+ public static String cleanString(String s) {
+ StringBuilder sb = new StringBuilder();
+ for (char c : s.toCharArray()) {
+ if (Character.isWhitespace(c)) sb.append('_');
+ else if (Character.isLetterOrDigit(c)) sb.append(c);
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Convert a sub-array from bytes to shorts.
+ *
+ * @param data array of bytes to be converted
+ * @param start first index to convert (should be even)
+ * @param len number of bytes to convert (should be even)
+ * @return an array of half the length, containing shorts
+ */
+ public static short[] byteToShortArray(byte[] data, int start, int len) {
+ short[] samples = new short[len / 2];
+ ByteBuffer bb = ByteBuffer.wrap(data, start, len);
+ bb.order(BYTE_ORDER);
+ for (int i = 0; i < len / 2; i++) {
+ samples[i] = bb.getShort();
+ }
+ return samples;
+ }
+
+ /**
+ * Convert a byte array to an array of shorts (suitable for the phone test
+ * native library's audio sample data).
+ *
+ * @param data array of bytes to be converted
+ * @return an array of half the length, containing shorts
+ */
+ public static short[] byteToShortArray(byte[] data) {
+ int len = data.length / 2;
+ short[] samples = new short[len];
+ ByteBuffer bb = ByteBuffer.wrap(data);
+ bb.order(BYTE_ORDER);
+ for (int i = 0; i < len; i++) {
+ samples[i] = bb.getShort();
+ }
+ return samples;
+ }
+
+ /**
+ * Convert a short array (as returned by the phone test native library)
+ * to an array of bytes.
+ *
+ * @param samples array of shorts to be converted
+ * @return an array of twice the length, broken out into bytes
+ */
+ public static byte[] shortToByteArray(short[] samples) {
+ int len = samples.length;
+ byte[] data = new byte[len * 2];
+ ByteBuffer bb = ByteBuffer.wrap(data);
+ bb.order(BYTE_ORDER);
+ for (int i = 0; i < len; i++) {
+ bb.putShort(samples[i]);
+ }
+ return data;
+ }
+
+ /**
+ * Scale the amplitude of an array of samples.
+ *
+ * @param samples to be scaled
+ * @param db decibels to scale up by (may be negative)
+ * @return the scaled samples
+ */
+ public static short[] scale(short[] samples, float db) {
+ short[] scaled = new short[samples.length];
+ // Convert decibels to a linear ratio:
+ double ratio = Math.pow(10.0, db / 20.0);
+ for (int i = 0; i < samples.length; i++) {
+ scaled[i] = (short) (samples[i] * ratio);
+ }
+ return scaled;
+ }
+
+ /**
+ * Read an entire file into memory.
+ *
+ * @param filename to be opened
+ * @return the file data, or null in case of error
+ */
+ private static byte[] readFile(String filename) {
+ FileInputStream fis;
+ try {
+ fis = new FileInputStream(filename);
+ } catch (FileNotFoundException e1) {
+ return null;
+ }
+
+ File file = new File(filename);
+ int len = (int) file.length();
+ byte[] data = new byte[len];
+
+ int pos = 0;
+ int bytes = 0;
+ int count;
+ while (pos < len) {
+ try {
+ count = fis.read(data, pos, len - pos);
+ } catch (IOException e) {
+ return null;
+ }
+ if (count < 1) return null;
+ pos += count;
+ }
+
+ try {
+ fis.close();
+ } catch (IOException e) {}
+ return data;
+ }
+
+ /**
+ * Read an entire file from an InputStream.
+ * Useful as AssetManager returns these.
+ *
+ * @param stream to read file contents from
+ * @return file data
+ */
+ public static byte[] readFile(InputStream stream) {
+ final int CHUNK_SIZE = 10000;
+ ByteArrayBuilder bab = new ByteArrayBuilder();
+ byte[] buf = new byte[CHUNK_SIZE];
+ int count;
+ while (true) {
+ try {
+ count = stream.read(buf, 0, CHUNK_SIZE);
+ } catch (IOException e) {
+ return null;
+ }
+ if (count == -1) break; // EOF
+ bab.append(buf, count);
+ }
+ return bab.toByteArray();
+ }
+
+ /**
+ * Save binary (audio) data to a file.
+ *
+ * @param filename to be written
+ * @param data contents
+ */
+ public static void saveFile(String filename, byte[] data) {
+ try {
+ FileOutputStream fos = new FileOutputStream(filename);
+ fos.write(data);
+ fos.close();
+ } catch (IOException e) {
+ Log.e(TAG, "Error writing to file " + filename);
+ }
+ }
+
+ /**
+ * Push an entire array of audio data to an AudioTrack.
+ *
+ * @param at destination
+ * @param data to be written
+ * @return true if successful, or false on error
+ */
+ public static boolean writeAudio(AudioTrack at, byte[] data) {
+ int pos = 0;
+ int len = data.length;
+ int count;
+
+ while (pos < len) {
+ count = at.write(data, pos, len - pos);
+ if (count < 0) return false;
+ pos += count;
+ }
+ at.flush();
+ return true;
+ }
+
+ /**
+ * Determine the number of audio samples in a file
+ *
+ * @param filename file containing audio data
+ * @return number of samples in file, or 0 if file does not exist
+ */
+ public static int duration(String filename) {
+ File file = new File(filename);
+ int len = (int) file.length();
+ return len / AudioQualityVerifierActivity.BYTES_PER_SAMPLE;
+ }
+
+ /**
+ * Determine the number of audio samples in a stimulus asset
+ *
+ * @param context to look up stimulus
+ * @param stimNum index number of this stimulus
+ * @return number of samples in stimulus
+ */
+ public static int duration(Context context, int stimNum) {
+ byte[] data = AudioAssets.getStim(context, stimNum);
+ return data.length / AudioQualityVerifierActivity.BYTES_PER_SAMPLE;
+ }
+
+ public static void playRawFile(String filename) {
+ byte[] data = readFile(filename);
+ if (data == null) {
+ Log.e(TAG, "Cannot read " + filename);
+ return;
+ }
+ playRaw(data);
+ }
+
+ public static void playStim(Context context, int stimNum) {
+ Utils.playRaw(getStim(context, stimNum));
+ }
+
+ public static byte[] getStim(Context context, int stimNum) {
+ return AudioAssets.getStim(context, stimNum);
+ }
+
+ public static byte[] getPinkNoise(Context context, int ampl, int duration) {
+ return AudioAssets.getPinkNoise(context, ampl, duration);
+ }
+
+ public static void playRaw(byte[] data) {
+ Log.i(TAG, "Playing " + data.length + " bytes of pre-recorded audio");
+ AudioTrack at = new AudioTrack(AudioQualityVerifierActivity.PLAYBACK_STREAM, AudioQualityVerifierActivity.SAMPLE_RATE,
+ AudioFormat.CHANNEL_OUT_MONO, AudioQualityVerifierActivity.AUDIO_FORMAT,
+ data.length, AudioTrack.MODE_STREAM);
+ writeAudio(at, data);
+ at.play();
+ }
+
+ /**
+ * The equivalent of a simplified StringBuilder, but for bytes.
+ */
+ public static class ByteArrayBuilder {
+ private byte[] buf;
+ private int capacity, size;
+
+ public ByteArrayBuilder() {
+ capacity = 100;
+ size = 0;
+ buf = new byte[capacity];
+ }
+
+ public void append(byte[] b, int nBytes) {
+ if (nBytes < 1) return;
+ if (size + nBytes > capacity) expandCapacity(size + nBytes);
+ System.arraycopy(b, 0, buf, size, nBytes);
+ size += nBytes;
+ }
+
+ public byte[] toByteArray() {
+ byte[] result = new byte[size];
+ System.arraycopy(buf, 0, result, 0, size);
+ return result;
+ }
+
+ private void expandCapacity(int min) {
+ capacity *= 2;
+ if (capacity < min) capacity = min;
+ byte[] expanded = new byte[capacity];
+ System.arraycopy(buf, 0, expanded, 0, size);
+ buf = expanded;
+ }
+ }
+}
OSDN Git Service
