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 "core/AudioGlobal.h"
28 #include <aaudio/AAudioTesting.h>
29 #include <math.h>
30 #include <system/audio.h>
31 #include <assert.h>
32
33 #include "utility/AAudioUtilities.h"
34
35 using namespace android;
36
AAudioConvert_aaudioToAndroidStatus(aaudio_result_t result)37 status_t AAudioConvert_aaudioToAndroidStatus(aaudio_result_t result) {
38 // This covers the case for AAUDIO_OK and for positive results.
39 if (result >= 0) {
40 return result;
41 }
42 status_t status;
43 switch (result) {
44 case AAUDIO_ERROR_DISCONNECTED:
45 case AAUDIO_ERROR_NO_SERVICE:
46 status = DEAD_OBJECT;
47 break;
48 case AAUDIO_ERROR_INVALID_HANDLE:
49 status = BAD_TYPE;
50 break;
51 case AAUDIO_ERROR_INVALID_STATE:
52 status = INVALID_OPERATION;
53 break;
54 case AAUDIO_ERROR_INVALID_RATE:
55 case AAUDIO_ERROR_INVALID_FORMAT:
56 case AAUDIO_ERROR_ILLEGAL_ARGUMENT:
57 case AAUDIO_ERROR_OUT_OF_RANGE:
58 status = BAD_VALUE;
59 break;
60 case AAUDIO_ERROR_WOULD_BLOCK:
61 status = WOULD_BLOCK;
62 break;
63 case AAUDIO_ERROR_NULL:
64 status = UNEXPECTED_NULL;
65 break;
66 case AAUDIO_ERROR_UNAVAILABLE:
67 status = NOT_ENOUGH_DATA;
68 break;
69
70 // TODO translate these result codes
71 case AAUDIO_ERROR_INTERNAL:
72 case AAUDIO_ERROR_UNIMPLEMENTED:
73 case AAUDIO_ERROR_NO_FREE_HANDLES:
74 case AAUDIO_ERROR_NO_MEMORY:
75 case AAUDIO_ERROR_TIMEOUT:
76 default:
77 status = UNKNOWN_ERROR;
78 break;
79 }
80 return status;
81 }
82
AAudioConvert_androidToAAudioResult(status_t status)83 aaudio_result_t AAudioConvert_androidToAAudioResult(status_t status) {
84 // This covers the case for OK and for positive result.
85 if (status >= 0) {
86 return status;
87 }
88 aaudio_result_t result;
89 switch (status) {
90 case BAD_TYPE:
91 result = AAUDIO_ERROR_INVALID_HANDLE;
92 break;
93 case DEAD_OBJECT:
94 result = AAUDIO_ERROR_NO_SERVICE;
95 break;
96 case INVALID_OPERATION:
97 result = AAUDIO_ERROR_INVALID_STATE;
98 break;
99 case UNEXPECTED_NULL:
100 result = AAUDIO_ERROR_NULL;
101 break;
102 case BAD_VALUE:
103 result = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
104 break;
105 case WOULD_BLOCK:
106 result = AAUDIO_ERROR_WOULD_BLOCK;
107 break;
108 case NOT_ENOUGH_DATA:
109 result = AAUDIO_ERROR_UNAVAILABLE;
110 break;
111 default:
112 result = AAUDIO_ERROR_INTERNAL;
113 break;
114 }
115 return result;
116 }
117
AAudioConvert_aaudioToAndroidSessionId(aaudio_session_id_t sessionId)118 audio_session_t AAudioConvert_aaudioToAndroidSessionId(aaudio_session_id_t sessionId) {
119 // If not a regular sessionId then convert to a safe value of AUDIO_SESSION_ALLOCATE.
120 return (sessionId == AAUDIO_SESSION_ID_ALLOCATE || sessionId == AAUDIO_SESSION_ID_NONE)
121 ? AUDIO_SESSION_ALLOCATE
122 : (audio_session_t) sessionId;
123 }
124
AAudioConvert_aaudioToAndroidDataFormat(aaudio_format_t aaudioFormat)125 audio_format_t AAudioConvert_aaudioToAndroidDataFormat(aaudio_format_t aaudioFormat) {
126 audio_format_t androidFormat;
127 switch (aaudioFormat) {
128 case AAUDIO_FORMAT_UNSPECIFIED:
129 androidFormat = AUDIO_FORMAT_DEFAULT;
130 break;
131 case AAUDIO_FORMAT_PCM_I16:
132 androidFormat = AUDIO_FORMAT_PCM_16_BIT;
133 break;
134 case AAUDIO_FORMAT_PCM_FLOAT:
135 androidFormat = AUDIO_FORMAT_PCM_FLOAT;
136 break;
137 case AAUDIO_FORMAT_PCM_I24_PACKED:
138 androidFormat = AUDIO_FORMAT_PCM_24_BIT_PACKED;
139 break;
140 case AAUDIO_FORMAT_PCM_I32:
141 androidFormat = AUDIO_FORMAT_PCM_32_BIT;
142 break;
143 default:
144 androidFormat = AUDIO_FORMAT_INVALID;
145 ALOGE("%s() 0x%08X unrecognized", __func__, aaudioFormat);
146 break;
147 }
148 return androidFormat;
149 }
150
AAudioConvert_androidToAAudioDataFormat(audio_format_t androidFormat)151 aaudio_format_t AAudioConvert_androidToAAudioDataFormat(audio_format_t androidFormat) {
152 aaudio_format_t aaudioFormat;
153 switch (androidFormat) {
154 case AUDIO_FORMAT_DEFAULT:
155 aaudioFormat = AAUDIO_FORMAT_UNSPECIFIED;
156 break;
157 case AUDIO_FORMAT_PCM_16_BIT:
158 aaudioFormat = AAUDIO_FORMAT_PCM_I16;
159 break;
160 case AUDIO_FORMAT_PCM_FLOAT:
161 aaudioFormat = AAUDIO_FORMAT_PCM_FLOAT;
162 break;
163 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
164 aaudioFormat = AAUDIO_FORMAT_PCM_I24_PACKED;
165 break;
166 case AUDIO_FORMAT_PCM_32_BIT:
167 aaudioFormat = AAUDIO_FORMAT_PCM_I32;
168 break;
169 default:
170 aaudioFormat = AAUDIO_FORMAT_INVALID;
171 ALOGE("%s() 0x%08X unrecognized", __func__, androidFormat);
172 break;
173 }
174 return aaudioFormat;
175 }
176
177 // Make a message string from the condition.
178 #define STATIC_ASSERT(condition) static_assert(condition, #condition)
179
AAudioConvert_usageToInternal(aaudio_usage_t usage)180 audio_usage_t AAudioConvert_usageToInternal(aaudio_usage_t usage) {
181 // The public aaudio_content_type_t constants are supposed to have the same
182 // values as the internal audio_content_type_t values.
183 STATIC_ASSERT(AAUDIO_USAGE_MEDIA == AUDIO_USAGE_MEDIA);
184 STATIC_ASSERT(AAUDIO_USAGE_VOICE_COMMUNICATION == AUDIO_USAGE_VOICE_COMMUNICATION);
185 STATIC_ASSERT(AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING
186 == AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING);
187 STATIC_ASSERT(AAUDIO_USAGE_ALARM == AUDIO_USAGE_ALARM);
188 STATIC_ASSERT(AAUDIO_USAGE_NOTIFICATION == AUDIO_USAGE_NOTIFICATION);
189 STATIC_ASSERT(AAUDIO_USAGE_NOTIFICATION_RINGTONE
190 == AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE);
191 STATIC_ASSERT(AAUDIO_USAGE_NOTIFICATION_EVENT == AUDIO_USAGE_NOTIFICATION_EVENT);
192 STATIC_ASSERT(AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY == AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY);
193 STATIC_ASSERT(AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE
194 == AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE);
195 STATIC_ASSERT(AAUDIO_USAGE_ASSISTANCE_SONIFICATION == AUDIO_USAGE_ASSISTANCE_SONIFICATION);
196 STATIC_ASSERT(AAUDIO_USAGE_GAME == AUDIO_USAGE_GAME);
197 STATIC_ASSERT(AAUDIO_USAGE_ASSISTANT == AUDIO_USAGE_ASSISTANT);
198 STATIC_ASSERT(AAUDIO_SYSTEM_USAGE_EMERGENCY == AUDIO_USAGE_EMERGENCY);
199 STATIC_ASSERT(AAUDIO_SYSTEM_USAGE_SAFETY == AUDIO_USAGE_SAFETY);
200 STATIC_ASSERT(AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS == AUDIO_USAGE_VEHICLE_STATUS);
201 STATIC_ASSERT(AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT == AUDIO_USAGE_ANNOUNCEMENT);
202 if (usage == AAUDIO_UNSPECIFIED) {
203 usage = AAUDIO_USAGE_MEDIA;
204 }
205 return (audio_usage_t) usage; // same value
206 }
207
AAudioConvert_contentTypeToInternal(aaudio_content_type_t contentType)208 audio_content_type_t AAudioConvert_contentTypeToInternal(aaudio_content_type_t contentType) {
209 // The public aaudio_content_type_t constants are supposed to have the same
210 // values as the internal audio_content_type_t values.
211 STATIC_ASSERT(AAUDIO_CONTENT_TYPE_MUSIC == AUDIO_CONTENT_TYPE_MUSIC);
212 STATIC_ASSERT(AAUDIO_CONTENT_TYPE_SPEECH == AUDIO_CONTENT_TYPE_SPEECH);
213 STATIC_ASSERT(AAUDIO_CONTENT_TYPE_SONIFICATION == AUDIO_CONTENT_TYPE_SONIFICATION);
214 STATIC_ASSERT(AAUDIO_CONTENT_TYPE_MOVIE == AUDIO_CONTENT_TYPE_MOVIE);
215 if (contentType == AAUDIO_UNSPECIFIED) {
216 contentType = AAUDIO_CONTENT_TYPE_MUSIC;
217 }
218 return (audio_content_type_t) contentType; // same value
219 }
220
AAudioConvert_inputPresetToAudioSource(aaudio_input_preset_t preset)221 audio_source_t AAudioConvert_inputPresetToAudioSource(aaudio_input_preset_t preset) {
222 // The public aaudio_input_preset_t constants are supposed to have the same
223 // values as the internal audio_source_t values.
224 STATIC_ASSERT(AAUDIO_UNSPECIFIED == AUDIO_SOURCE_DEFAULT);
225 STATIC_ASSERT(AAUDIO_INPUT_PRESET_GENERIC == AUDIO_SOURCE_MIC);
226 STATIC_ASSERT(AAUDIO_INPUT_PRESET_CAMCORDER == AUDIO_SOURCE_CAMCORDER);
227 STATIC_ASSERT(AAUDIO_INPUT_PRESET_VOICE_RECOGNITION == AUDIO_SOURCE_VOICE_RECOGNITION);
228 STATIC_ASSERT(AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION == AUDIO_SOURCE_VOICE_COMMUNICATION);
229 STATIC_ASSERT(AAUDIO_INPUT_PRESET_UNPROCESSED == AUDIO_SOURCE_UNPROCESSED);
230 STATIC_ASSERT(AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE == AUDIO_SOURCE_VOICE_PERFORMANCE);
231 if (preset == AAUDIO_UNSPECIFIED) {
232 preset = AAUDIO_INPUT_PRESET_VOICE_RECOGNITION;
233 }
234 return (audio_source_t) preset; // same value
235 }
236
AAudioConvert_allowCapturePolicyToAudioFlagsMask(aaudio_allowed_capture_policy_t policy)237 audio_flags_mask_t AAudioConvert_allowCapturePolicyToAudioFlagsMask(
238 aaudio_allowed_capture_policy_t policy) {
239 switch (policy) {
240 case AAUDIO_UNSPECIFIED:
241 case AAUDIO_ALLOW_CAPTURE_BY_ALL:
242 return AUDIO_FLAG_NONE;
243 case AAUDIO_ALLOW_CAPTURE_BY_SYSTEM:
244 return AUDIO_FLAG_NO_MEDIA_PROJECTION;
245 case AAUDIO_ALLOW_CAPTURE_BY_NONE:
246 return static_cast<audio_flags_mask_t>(
247 AUDIO_FLAG_NO_MEDIA_PROJECTION | AUDIO_FLAG_NO_SYSTEM_CAPTURE);
248 default:
249 ALOGE("%s() 0x%08X unrecognized", __func__, policy);
250 return AUDIO_FLAG_NONE; //
251 }
252 }
253
AAudioConvert_privacySensitiveToAudioFlagsMask(bool privacySensitive)254 audio_flags_mask_t AAudioConvert_privacySensitiveToAudioFlagsMask(
255 bool privacySensitive) {
256 return privacySensitive ? AUDIO_FLAG_CAPTURE_PRIVATE : AUDIO_FLAG_NONE;
257 }
258
AAudioConvert_framesToBytes(int32_t numFrames,int32_t bytesPerFrame,int32_t * sizeInBytes)259 int32_t AAudioConvert_framesToBytes(int32_t numFrames,
260 int32_t bytesPerFrame,
261 int32_t *sizeInBytes) {
262 *sizeInBytes = 0;
263
264 if (numFrames < 0 || bytesPerFrame < 0) {
265 ALOGE("negative size, numFrames = %d, frameSize = %d", numFrames, bytesPerFrame);
266 return AAUDIO_ERROR_OUT_OF_RANGE;
267 }
268
269 // Prevent numeric overflow.
270 if (numFrames > (INT32_MAX / bytesPerFrame)) {
271 ALOGE("size overflow, numFrames = %d, frameSize = %d", numFrames, bytesPerFrame);
272 return AAUDIO_ERROR_OUT_OF_RANGE;
273 }
274
275 *sizeInBytes = numFrames * bytesPerFrame;
276 return AAUDIO_OK;
277 }
278
AAudioProperty_getMMapProperty(const char * propName,int32_t defaultValue,const char * caller)279 static int32_t AAudioProperty_getMMapProperty(const char *propName,
280 int32_t defaultValue,
281 const char * caller) {
282 int32_t prop = property_get_int32(propName, defaultValue);
283 switch (prop) {
284 case AAUDIO_UNSPECIFIED:
285 case AAUDIO_POLICY_NEVER:
286 case AAUDIO_POLICY_ALWAYS:
287 case AAUDIO_POLICY_AUTO:
288 break;
289 default:
290 ALOGE("%s: invalid = %d", caller, prop);
291 prop = defaultValue;
292 break;
293 }
294 return prop;
295 }
296
AAudioProperty_getMMapPolicy()297 int32_t AAudioProperty_getMMapPolicy() {
298 return AAudioProperty_getMMapProperty(AAUDIO_PROP_MMAP_POLICY,
299 AAUDIO_UNSPECIFIED, __func__);
300 }
301
AAudioProperty_getMMapExclusivePolicy()302 int32_t AAudioProperty_getMMapExclusivePolicy() {
303 return AAudioProperty_getMMapProperty(AAUDIO_PROP_MMAP_EXCLUSIVE_POLICY,
304 AAUDIO_UNSPECIFIED, __func__);
305 }
306
AAudioProperty_getMixerBursts()307 int32_t AAudioProperty_getMixerBursts() {
308 const int32_t defaultBursts = 2; // arbitrary, use 2 for double buffered
309 const int32_t maxBursts = 1024; // arbitrary
310 int32_t prop = property_get_int32(AAUDIO_PROP_MIXER_BURSTS, defaultBursts);
311 if (prop < 1 || prop > maxBursts) {
312 ALOGE("AAudioProperty_getMixerBursts: invalid = %d", prop);
313 prop = defaultBursts;
314 }
315 return prop;
316 }
317
AAudioProperty_getWakeupDelayMicros()318 int32_t AAudioProperty_getWakeupDelayMicros() {
319 const int32_t minMicros = 0; // arbitrary
320 const int32_t defaultMicros = 200; // arbitrary, based on some observed jitter
321 const int32_t maxMicros = 5000; // arbitrary, probably don't want more than 500
322 int32_t prop = property_get_int32(AAUDIO_PROP_WAKEUP_DELAY_USEC, defaultMicros);
323 if (prop < minMicros) {
324 ALOGW("AAudioProperty_getWakeupDelayMicros: clipped %d to %d", prop, minMicros);
325 prop = minMicros;
326 } else if (prop > maxMicros) {
327 ALOGW("AAudioProperty_getWakeupDelayMicros: clipped %d to %d", prop, maxMicros);
328 prop = maxMicros;
329 }
330 return prop;
331 }
332
AAudioProperty_getMinimumSleepMicros()333 int32_t AAudioProperty_getMinimumSleepMicros() {
334 const int32_t minMicros = 20; // arbitrary
335 const int32_t defaultMicros = 200; // arbitrary
336 const int32_t maxMicros = 2000; // arbitrary
337 int32_t prop = property_get_int32(AAUDIO_PROP_MINIMUM_SLEEP_USEC, defaultMicros);
338 if (prop < minMicros) {
339 ALOGW("AAudioProperty_getMinimumSleepMicros: clipped %d to %d", prop, minMicros);
340 prop = minMicros;
341 } else if (prop > maxMicros) {
342 ALOGW("AAudioProperty_getMinimumSleepMicros: clipped %d to %d", prop, maxMicros);
343 prop = maxMicros;
344 }
345 return prop;
346 }
347
AAudioProperty_getHardwareBurstMinMicros()348 int32_t AAudioProperty_getHardwareBurstMinMicros() {
349 const int32_t defaultMicros = 1000; // arbitrary
350 const int32_t maxMicros = 1000 * 1000; // arbitrary
351 int32_t prop = property_get_int32(AAUDIO_PROP_HW_BURST_MIN_USEC, defaultMicros);
352 if (prop < 1 || prop > maxMicros) {
353 ALOGE("AAudioProperty_getHardwareBurstMinMicros: invalid = %d, use %d",
354 prop, defaultMicros);
355 prop = defaultMicros;
356 }
357 return prop;
358 }
359
AAudioProperty_getMMapOffsetMicros(const char * functionName,const char * propertyName)360 static int32_t AAudioProperty_getMMapOffsetMicros(const char *functionName,
361 const char *propertyName) {
362 const int32_t minMicros = -20000; // arbitrary
363 const int32_t defaultMicros = 0; // arbitrary
364 const int32_t maxMicros = 20000; // arbitrary
365 int32_t prop = property_get_int32(propertyName, defaultMicros);
366 if (prop < minMicros) {
367 ALOGW("%s: clipped %d to %d", functionName, prop, minMicros);
368 prop = minMicros;
369 } else if (prop > maxMicros) {
370 ALOGW("%s: clipped %d to %d", functionName, prop, minMicros);
371 prop = maxMicros;
372 }
373 return prop;
374 }
375
AAudioProperty_getInputMMapOffsetMicros()376 int32_t AAudioProperty_getInputMMapOffsetMicros() {
377 return AAudioProperty_getMMapOffsetMicros(__func__, AAUDIO_PROP_INPUT_MMAP_OFFSET_USEC);
378 }
379
AAudioProperty_getOutputMMapOffsetMicros()380 int32_t AAudioProperty_getOutputMMapOffsetMicros() {
381 return AAudioProperty_getMMapOffsetMicros(__func__, AAUDIO_PROP_OUTPUT_MMAP_OFFSET_USEC);
382 }
383
AAudioProperty_getLogMask()384 int32_t AAudioProperty_getLogMask() {
385 return property_get_int32(AAUDIO_PROP_LOG_MASK, 0);
386 }
387
AAudio_isFlushAllowed(aaudio_stream_state_t state)388 aaudio_result_t AAudio_isFlushAllowed(aaudio_stream_state_t state) {
389 aaudio_result_t result = AAUDIO_OK;
390 switch (state) {
391 // Proceed with flushing.
392 case AAUDIO_STREAM_STATE_OPEN:
393 case AAUDIO_STREAM_STATE_PAUSED:
394 case AAUDIO_STREAM_STATE_STOPPED:
395 case AAUDIO_STREAM_STATE_FLUSHED:
396 break;
397
398 // Transition from one inactive state to another.
399 case AAUDIO_STREAM_STATE_STARTING:
400 case AAUDIO_STREAM_STATE_STARTED:
401 case AAUDIO_STREAM_STATE_STOPPING:
402 case AAUDIO_STREAM_STATE_PAUSING:
403 case AAUDIO_STREAM_STATE_FLUSHING:
404 case AAUDIO_STREAM_STATE_CLOSING:
405 case AAUDIO_STREAM_STATE_CLOSED:
406 case AAUDIO_STREAM_STATE_DISCONNECTED:
407 default:
408 ALOGE("can only flush stream when PAUSED, OPEN or STOPPED, state = %s",
409 aaudio::AudioGlobal_convertStreamStateToText(state));
410 result = AAUDIO_ERROR_INVALID_STATE;
411 break;
412 }
413 return result;
414 }
415