AAudioUtilities.cpp revision 94e16458f4665d3c167d0e2c905a3f4ec9e7a3e7 
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
31using 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
38int32_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
55static 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
83static 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
93static 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
103void 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
114void 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
134void 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
145void 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
162void 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
185void 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
203status_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
244aaudio_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
276audio_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
293aaudio_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
310int32_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
325static 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
343int32_t AAudioProperty_getMMapPolicy() {
344    return AAudioProperty_getMMapProperty(AAUDIO_PROP_MMAP_POLICY,
345                                          AAUDIO_UNSPECIFIED, __func__);
346}
347
348int32_t AAudioProperty_getMMapExclusivePolicy() {
349    return AAudioProperty_getMMapProperty(AAUDIO_PROP_MMAP_EXCLUSIVE_POLICY,
350                                          AAUDIO_UNSPECIFIED, __func__);
351}
352
353int32_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
364int32_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