1 /*
2 * Copyright 2016 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 #define LOG_TAG "AAudio"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20
21 #include <cutils/properties.h>
22 #include <stdint.h>
23 #include <sys/types.h>
24 #include <utils/Errors.h>
25
26 #include "aaudio/AAudio.h"
27 #include <aaudio/AAudioTesting.h>
28
29 #include "utility/AAudioUtilities.h"
30
31 using namespace android;
32
33 // This is 3 dB, (10^(3/20)), to match the maximum headroom in AudioTrack for float data.
34 // It is designed to allow occasional transient peaks.
35 #define MAX_HEADROOM (1.41253754f)
36 #define MIN_HEADROOM (0 - MAX_HEADROOM)
37
AAudioConvert_formatToSizeInBytes(aaudio_format_t format)38 int32_t AAudioConvert_formatToSizeInBytes(aaudio_format_t format) {
39 int32_t size = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
40 switch (format) {
41 case AAUDIO_FORMAT_PCM_I16:
42 size = sizeof(int16_t);
43 break;
44 case AAUDIO_FORMAT_PCM_FLOAT:
45 size = sizeof(float);
46 break;
47 default:
48 break;
49 }
50 return size;
51 }
52
53
54 // TODO expose and call clamp16_from_float function in primitives.h
clamp16_from_float(float f)55 static inline int16_t clamp16_from_float(float f) {
56 /* Offset is used to expand the valid range of [-1.0, 1.0) into the 16 lsbs of the
57 * floating point significand. The normal shift is 3<<22, but the -15 offset
58 * is used to multiply by 32768.
59 */
60 static const float offset = (float)(3 << (22 - 15));
61 /* zero = (0x10f << 22) = 0x43c00000 (not directly used) */
62 static const int32_t limneg = (0x10f << 22) /*zero*/ - 32768; /* 0x43bf8000 */
63 static const int32_t limpos = (0x10f << 22) /*zero*/ + 32767; /* 0x43c07fff */
64
65 union {
66 float f;
67 int32_t i;
68 } u;
69
70 u.f = f + offset; /* recenter valid range */
71 /* Now the valid range is represented as integers between [limneg, limpos].
72 * Clamp using the fact that float representation (as an integer) is an ordered set.
73 */
74 if (u.i < limneg)
75 u.i = -32768;
76 else if (u.i > limpos)
77 u.i = 32767;
78 return u.i; /* Return lower 16 bits, the part of interest in the significand. */
79 }
80
81 // Same but without clipping.
82 // Convert -1.0f to +1.0f to -32768 to +32767
floatToInt16(float f)83 static inline int16_t floatToInt16(float f) {
84 static const float offset = (float)(3 << (22 - 15));
85 union {
86 float f;
87 int32_t i;
88 } u;
89 u.f = f + offset; /* recenter valid range */
90 return u.i; /* Return lower 16 bits, the part of interest in the significand. */
91 }
92
clipAndClampFloatToPcm16(float sample,float scaler)93 static float clipAndClampFloatToPcm16(float sample, float scaler) {
94 // Clip to valid range of a float sample to prevent excessive volume.
95 if (sample > MAX_HEADROOM) sample = MAX_HEADROOM;
96 else if (sample < MIN_HEADROOM) sample = MIN_HEADROOM;
97
98 // Scale and convert to a short.
99 float fval = sample * scaler;
100 return clamp16_from_float(fval);
101 }
102
AAudioConvert_floatToPcm16(const float * source,int16_t * destination,int32_t numSamples,float amplitude)103 void AAudioConvert_floatToPcm16(const float *source,
104 int16_t *destination,
105 int32_t numSamples,
106 float amplitude) {
107 float scaler = amplitude;
108 for (int i = 0; i < numSamples; i++) {
109 float sample = *source++;
110 *destination++ = clipAndClampFloatToPcm16(sample, scaler);
111 }
112 }
113
AAudioConvert_floatToPcm16(const float * source,int16_t * destination,int32_t numFrames,int32_t samplesPerFrame,float amplitude1,float amplitude2)114 void AAudioConvert_floatToPcm16(const float *source,
115 int16_t *destination,
116 int32_t numFrames,
117 int32_t samplesPerFrame,
118 float amplitude1,
119 float amplitude2) {
120 float scaler = amplitude1;
121 // divide by numFrames so that we almost reach amplitude2
122 float delta = (amplitude2 - amplitude1) / numFrames;
123 for (int frameIndex = 0; frameIndex < numFrames; frameIndex++) {
124 for (int sampleIndex = 0; sampleIndex < samplesPerFrame; sampleIndex++) {
125 float sample = *source++;
126 *destination++ = clipAndClampFloatToPcm16(sample, scaler);
127 }
128 scaler += delta;
129 }
130 }
131
132 #define SHORT_SCALE 32768
133
AAudioConvert_pcm16ToFloat(const int16_t * source,float * destination,int32_t numSamples,float amplitude)134 void AAudioConvert_pcm16ToFloat(const int16_t *source,
135 float *destination,
136 int32_t numSamples,
137 float amplitude) {
138 float scaler = amplitude / SHORT_SCALE;
139 for (int i = 0; i < numSamples; i++) {
140 destination[i] = source[i] * scaler;
141 }
142 }
143
144 // This code assumes amplitude1 and amplitude2 are between 0.0 and 1.0
AAudioConvert_pcm16ToFloat(const int16_t * source,float * destination,int32_t numFrames,int32_t samplesPerFrame,float amplitude1,float amplitude2)145 void AAudioConvert_pcm16ToFloat(const int16_t *source,
146 float *destination,
147 int32_t numFrames,
148 int32_t samplesPerFrame,
149 float amplitude1,
150 float amplitude2) {
151 float scaler = amplitude1 / SHORT_SCALE;
152 float delta = (amplitude2 - amplitude1) / (SHORT_SCALE * (float) numFrames);
153 for (int frameIndex = 0; frameIndex < numFrames; frameIndex++) {
154 for (int sampleIndex = 0; sampleIndex < samplesPerFrame; sampleIndex++) {
155 *destination++ = *source++ * scaler;
156 }
157 scaler += delta;
158 }
159 }
160
161 // This code assumes amplitude1 and amplitude2 are between 0.0 and 1.0
AAudio_linearRamp(const float * source,float * destination,int32_t numFrames,int32_t samplesPerFrame,float amplitude1,float amplitude2)162 void AAudio_linearRamp(const float *source,
163 float *destination,
164 int32_t numFrames,
165 int32_t samplesPerFrame,
166 float amplitude1,
167 float amplitude2) {
168 float scaler = amplitude1;
169 float delta = (amplitude2 - amplitude1) / numFrames;
170 for (int frameIndex = 0; frameIndex < numFrames; frameIndex++) {
171 for (int sampleIndex = 0; sampleIndex < samplesPerFrame; sampleIndex++) {
172 float sample = *source++;
173
174 // Clip to valid range of a float sample to prevent excessive volume.
175 if (sample > MAX_HEADROOM) sample = MAX_HEADROOM;
176 else if (sample < MIN_HEADROOM) sample = MIN_HEADROOM;
177
178 *destination++ = sample * scaler;
179 }
180 scaler += delta;
181 }
182 }
183
184 // This code assumes amplitude1 and amplitude2 are between 0.0 and 1.0
AAudio_linearRamp(const int16_t * source,int16_t * destination,int32_t numFrames,int32_t samplesPerFrame,float amplitude1,float amplitude2)185 void AAudio_linearRamp(const int16_t *source,
186 int16_t *destination,
187 int32_t numFrames,
188 int32_t samplesPerFrame,
189 float amplitude1,
190 float amplitude2) {
191 float scaler = amplitude1 / SHORT_SCALE;
192 float delta = (amplitude2 - amplitude1) / (SHORT_SCALE * (float) numFrames);
193 for (int frameIndex = 0; frameIndex < numFrames; frameIndex++) {
194 for (int sampleIndex = 0; sampleIndex < samplesPerFrame; sampleIndex++) {
195 // No need to clip because int16_t range is inherently limited.
196 float sample = *source++ * scaler;
197 *destination++ = floatToInt16(sample);
198 }
199 scaler += delta;
200 }
201 }
202
AAudioConvert_aaudioToAndroidStatus(aaudio_result_t result)203 status_t AAudioConvert_aaudioToAndroidStatus(aaudio_result_t result) {
204 // This covers the case for AAUDIO_OK and for positive results.
205 if (result >= 0) {
206 return result;
207 }
208 status_t status;
209 switch (result) {
210 case AAUDIO_ERROR_DISCONNECTED:
211 case AAUDIO_ERROR_INVALID_HANDLE:
212 status = DEAD_OBJECT;
213 break;
214 case AAUDIO_ERROR_INVALID_STATE:
215 status = INVALID_OPERATION;
216 break;
217 case AAUDIO_ERROR_INVALID_RATE:
218 case AAUDIO_ERROR_INVALID_FORMAT:
219 case AAUDIO_ERROR_ILLEGAL_ARGUMENT:
220 case AAUDIO_ERROR_OUT_OF_RANGE:
221 status = BAD_VALUE;
222 break;
223 case AAUDIO_ERROR_WOULD_BLOCK:
224 status = WOULD_BLOCK;
225 break;
226 case AAUDIO_ERROR_NULL:
227 status = UNEXPECTED_NULL;
228 break;
229 // TODO translate these result codes
230 case AAUDIO_ERROR_INTERNAL:
231 case AAUDIO_ERROR_UNIMPLEMENTED:
232 case AAUDIO_ERROR_UNAVAILABLE:
233 case AAUDIO_ERROR_NO_FREE_HANDLES:
234 case AAUDIO_ERROR_NO_MEMORY:
235 case AAUDIO_ERROR_TIMEOUT:
236 case AAUDIO_ERROR_NO_SERVICE:
237 default:
238 status = UNKNOWN_ERROR;
239 break;
240 }
241 return status;
242 }
243
AAudioConvert_androidToAAudioResult(status_t status)244 aaudio_result_t AAudioConvert_androidToAAudioResult(status_t status) {
245 // This covers the case for OK and for positive result.
246 if (status >= 0) {
247 return status;
248 }
249 aaudio_result_t result;
250 switch (status) {
251 case BAD_TYPE:
252 result = AAUDIO_ERROR_INVALID_HANDLE;
253 break;
254 case DEAD_OBJECT:
255 result = AAUDIO_ERROR_NO_SERVICE;
256 break;
257 case INVALID_OPERATION:
258 result = AAUDIO_ERROR_INVALID_STATE;
259 break;
260 case UNEXPECTED_NULL:
261 result = AAUDIO_ERROR_NULL;
262 break;
263 case BAD_VALUE:
264 result = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
265 break;
266 case WOULD_BLOCK:
267 result = AAUDIO_ERROR_WOULD_BLOCK;
268 break;
269 default:
270 result = AAUDIO_ERROR_INTERNAL;
271 break;
272 }
273 return result;
274 }
275
AAudioConvert_aaudioToAndroidDataFormat(aaudio_format_t aaudioFormat)276 audio_format_t AAudioConvert_aaudioToAndroidDataFormat(aaudio_format_t aaudioFormat) {
277 audio_format_t androidFormat;
278 switch (aaudioFormat) {
279 case AAUDIO_FORMAT_PCM_I16:
280 androidFormat = AUDIO_FORMAT_PCM_16_BIT;
281 break;
282 case AAUDIO_FORMAT_PCM_FLOAT:
283 androidFormat = AUDIO_FORMAT_PCM_FLOAT;
284 break;
285 default:
286 androidFormat = AUDIO_FORMAT_DEFAULT;
287 ALOGE("AAudioConvert_aaudioToAndroidDataFormat 0x%08X unrecognized", aaudioFormat);
288 break;
289 }
290 return androidFormat;
291 }
292
AAudioConvert_androidToAAudioDataFormat(audio_format_t androidFormat)293 aaudio_format_t AAudioConvert_androidToAAudioDataFormat(audio_format_t androidFormat) {
294 aaudio_format_t aaudioFormat = AAUDIO_FORMAT_INVALID;
295 switch (androidFormat) {
296 case AUDIO_FORMAT_PCM_16_BIT:
297 aaudioFormat = AAUDIO_FORMAT_PCM_I16;
298 break;
299 case AUDIO_FORMAT_PCM_FLOAT:
300 aaudioFormat = AAUDIO_FORMAT_PCM_FLOAT;
301 break;
302 default:
303 aaudioFormat = AAUDIO_FORMAT_INVALID;
304 ALOGE("AAudioConvert_androidToAAudioDataFormat 0x%08X unrecognized", androidFormat);
305 break;
306 }
307 return aaudioFormat;
308 }
309
AAudioConvert_framesToBytes(int32_t numFrames,int32_t bytesPerFrame,int32_t * sizeInBytes)310 int32_t AAudioConvert_framesToBytes(int32_t numFrames,
311 int32_t bytesPerFrame,
312 int32_t *sizeInBytes) {
313 // TODO implement more elegantly
314 const int32_t maxChannels = 256; // ridiculously large
315 const int32_t maxBytesPerFrame = maxChannels * sizeof(float);
316 // Prevent overflow by limiting multiplicands.
317 if (bytesPerFrame > maxBytesPerFrame || numFrames > (0x3FFFFFFF / maxBytesPerFrame)) {
318 ALOGE("size overflow, numFrames = %d, frameSize = %zd", numFrames, bytesPerFrame);
319 return AAUDIO_ERROR_OUT_OF_RANGE;
320 }
321 *sizeInBytes = numFrames * bytesPerFrame;
322 return AAUDIO_OK;
323 }
324
AAudioProperty_getMMapProperty(const char * propName,int32_t defaultValue,const char * caller)325 static int32_t AAudioProperty_getMMapProperty(const char *propName,
326 int32_t defaultValue,
327 const char * caller) {
328 int32_t prop = property_get_int32(propName, defaultValue);
329 switch (prop) {
330 case AAUDIO_UNSPECIFIED:
331 case AAUDIO_POLICY_NEVER:
332 case AAUDIO_POLICY_ALWAYS:
333 case AAUDIO_POLICY_AUTO:
334 break;
335 default:
336 ALOGE("%s: invalid = %d", caller, prop);
337 prop = defaultValue;
338 break;
339 }
340 return prop;
341 }
342
AAudioProperty_getMMapPolicy()343 int32_t AAudioProperty_getMMapPolicy() {
344 return AAudioProperty_getMMapProperty(AAUDIO_PROP_MMAP_POLICY,
345 AAUDIO_UNSPECIFIED, __func__);
346 }
347
AAudioProperty_getMMapExclusivePolicy()348 int32_t AAudioProperty_getMMapExclusivePolicy() {
349 return AAudioProperty_getMMapProperty(AAUDIO_PROP_MMAP_EXCLUSIVE_POLICY,
350 AAUDIO_UNSPECIFIED, __func__);
351 }
352
AAudioProperty_getMixerBursts()353 int32_t AAudioProperty_getMixerBursts() {
354 const int32_t defaultBursts = 2; // arbitrary, use 2 for double buffered
355 const int32_t maxBursts = 1024; // arbitrary
356 int32_t prop = property_get_int32(AAUDIO_PROP_MIXER_BURSTS, defaultBursts);
357 if (prop < 1 || prop > maxBursts) {
358 ALOGE("AAudioProperty_getMixerBursts: invalid = %d", prop);
359 prop = defaultBursts;
360 }
361 return prop;
362 }
363
AAudioProperty_getHardwareBurstMinMicros()364 int32_t AAudioProperty_getHardwareBurstMinMicros() {
365 const int32_t defaultMicros = 1000; // arbitrary
366 const int32_t maxMicros = 1000 * 1000; // arbitrary
367 int32_t prop = property_get_int32(AAUDIO_PROP_HW_BURST_MIN_USEC, defaultMicros);
368 if (prop < 1 || prop > maxMicros) {
369 ALOGE("AAudioProperty_getHardwareBurstMinMicros: invalid = %d", prop);
370 prop = defaultMicros;
371 }
372 return prop;
373 }
374