1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.media.cts; 18 19 import android.annotation.IntDef; 20 import android.annotation.NonNull; 21 import android.util.Log; 22 23 import com.android.compatibility.common.util.CtsAndroidTestCase; 24 25 import java.lang.annotation.Retention; 26 import java.lang.annotation.RetentionPolicy; 27 28 public class AudioTrackNative { 29 // Must be kept in sync with C++ JNI audio-track-native (AudioTrackNative) WRITE_FLAG_* 30 public static final int WRITE_FLAG_BLOCKING = 1 << 0; 31 /** @hide */ 32 @IntDef(flag = true, 33 value = { 34 WRITE_FLAG_BLOCKING, 35 }) 36 @Retention(RetentionPolicy.SOURCE) 37 public @interface WriteFlags { } 38 39 public AudioTrackNative() { 40 mNativeTrackInJavaObj = nativeCreateTrack(); 41 } 42 43 // TODO: eventually accept AudioFormat 44 // numBuffers is the number of internal buffers before hitting the OpenSL ES. 45 // A value of 0 means that all writes are blocking. 46 public boolean open(int numChannels, int sampleRate, boolean useFloat, int numBuffers) { 47 return open(numChannels, 0, sampleRate, useFloat, numBuffers); 48 } 49 50 public boolean open(int numChannels, int channelMask, int sampleRate, 51 boolean useFloat, int numBuffers) { 52 if (nativeOpen(mNativeTrackInJavaObj, numChannels, channelMask, 53 sampleRate, useFloat, numBuffers) == STATUS_OK) { 54 mChannelCount = numChannels; 55 return true; 56 } 57 return false; 58 } 59 60 public void close() { 61 nativeClose(mNativeTrackInJavaObj); 62 } 63 64 public boolean start() { 65 return nativeStart(mNativeTrackInJavaObj) == STATUS_OK; 66 } 67 68 public boolean stop() { 69 return nativeStop(mNativeTrackInJavaObj) == STATUS_OK; 70 } 71 72 public boolean pause() { 73 return nativePause(mNativeTrackInJavaObj) == STATUS_OK; 74 } 75 76 public boolean flush() { 77 return nativeFlush(mNativeTrackInJavaObj) == STATUS_OK; 78 } 79 80 public long getPositionInMsec() { 81 long[] position = new long[1]; 82 if (nativeGetPositionInMsec(mNativeTrackInJavaObj, position) != STATUS_OK) { 83 throw new IllegalStateException(); 84 } 85 return position[0]; 86 } 87 88 public int getBuffersPending() { 89 return nativeGetBuffersPending(mNativeTrackInJavaObj); 90 } 91 92 /* returns number of samples written. 93 * 0 may be returned if !isBlocking. 94 * negative value indicates error. 95 */ 96 public int write(@NonNull byte[] byteArray, 97 int offsetInSamples, int sizeInSamples, @WriteFlags int writeFlags) { 98 return nativeWriteByteArray( 99 mNativeTrackInJavaObj, byteArray, offsetInSamples, sizeInSamples, writeFlags); 100 } 101 102 public int write(@NonNull short[] shortArray, 103 int offsetInSamples, int sizeInSamples, @WriteFlags int writeFlags) { 104 return nativeWriteShortArray( 105 mNativeTrackInJavaObj, shortArray, offsetInSamples, sizeInSamples, writeFlags); 106 } 107 108 public int write(@NonNull float[] floatArray, 109 int offsetInSamples, int sizeInSamples, @WriteFlags int writeFlags) { 110 return nativeWriteFloatArray( 111 mNativeTrackInJavaObj, floatArray, offsetInSamples, sizeInSamples, writeFlags); 112 } 113 114 public int getChannelCount() { 115 return mChannelCount; 116 } 117 118 public static boolean test(int numChannels, int sampleRate, boolean useFloat, 119 int msecPerBuffer, int numBuffers) { 120 return test(numChannels, 0, sampleRate, useFloat, msecPerBuffer, numBuffers); 121 } 122 123 public static boolean test(int numChannels, int channelMask, int sampleRate, boolean useFloat, 124 int msecPerBuffer, int numBuffers) { 125 return nativeTest(numChannels, channelMask, sampleRate, useFloat, msecPerBuffer, numBuffers) 126 == STATUS_OK; 127 } 128 129 @Override 130 protected void finalize() { 131 nativeClose(mNativeTrackInJavaObj); 132 nativeDestroyTrack(mNativeTrackInJavaObj); 133 } 134 135 static { 136 System.loadLibrary("audio_jni"); 137 } 138 139 private static final String TAG = "AudioTrackNative"; 140 private int mChannelCount; 141 private final long mNativeTrackInJavaObj; 142 private static final int STATUS_OK = 0; 143 144 // static native API. 145 // The native API uses a long "track handle" created by nativeCreateTrack. 146 // The handle must be destroyed after use by nativeDestroyTrack. 147 // 148 // Return codes from the native layer are status_t. 149 // Converted to Java booleans or exceptions at the public API layer. 150 private static native long nativeCreateTrack(); 151 private static native void nativeDestroyTrack(long track); 152 private static native int nativeOpen( 153 long track, int numChannels, int channelMask, 154 int sampleRate, boolean useFloat, int numBuffers); 155 private static native void nativeClose(long track); 156 private static native int nativeStart(long track); 157 private static native int nativeStop(long track); 158 private static native int nativePause(long track); 159 private static native int nativeFlush(long track); 160 private static native int nativeGetPositionInMsec(long track, @NonNull long[] position); 161 private static native int nativeGetBuffersPending(long track); 162 private static native int nativeWriteByteArray(long track, @NonNull byte[] byteArray, 163 int offsetInSamples, int sizeInSamples, @WriteFlags int writeFlags); 164 private static native int nativeWriteShortArray(long track, @NonNull short[] shortArray, 165 int offsetInSamples, int sizeInSamples, @WriteFlags int writeFlags); 166 private static native int nativeWriteFloatArray(long track, @NonNull float[] floatArray, 167 int offsetInSamples, int sizeInSamples, @WriteFlags int writeFlags); 168 169 // native interface for all-in-one testing, no track handle required. 170 private static native int nativeTest( 171 int numChannels, int channelMask, int sampleRate, 172 boolean useFloat, int msecPerBuffer, int numBuffers); 173 } 174