blob: 6b253025fcfb265ab94700692e25520291c6e0f5 [file] [log] [blame]
Phil Burk204a1632017-01-03 17:23:43 -08001/*
2 * Copyright (C) 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
Phil Burkcf5f6d22017-05-26 12:35:07 -070017// This file is used in both client and server processes.
18// This is needed to make sense of the logs more easily.
Eric Laurentcb4dae22017-07-01 19:39:32 -070019#define LOG_TAG (mInService ? "AudioStreamInternal_Service" : "AudioStreamInternal_Client")
Phil Burk204a1632017-01-03 17:23:43 -080020//#define LOG_NDEBUG 0
21#include <utils/Log.h>
22
Phil Burk4485d412017-05-09 15:55:02 -070023#define ATRACE_TAG ATRACE_TAG_AUDIO
24
Phil Burkc0c70e32017-02-09 13:18:38 -080025#include <stdint.h>
Phil Burk204a1632017-01-03 17:23:43 -080026
27#include <binder/IServiceManager.h>
28
Phil Burk5ed503c2017-02-01 09:38:15 -080029#include <aaudio/AAudio.h>
Phil Burkfd34a932017-07-19 07:03:52 -070030#include <cutils/properties.h>
Phil Burke4d7bb42017-03-28 11:32:39 -070031#include <utils/String16.h>
Phil Burk4485d412017-05-09 15:55:02 -070032#include <utils/Trace.h>
Phil Burk204a1632017-01-03 17:23:43 -080033
Phil Burkc0c70e32017-02-09 13:18:38 -080034#include "AudioEndpointParcelable.h"
35#include "binding/AAudioStreamRequest.h"
36#include "binding/AAudioStreamConfiguration.h"
37#include "binding/IAAudioService.h"
Phil Burk5ed503c2017-02-01 09:38:15 -080038#include "binding/AAudioServiceMessage.h"
Phil Burk3df348f2017-02-08 11:41:55 -080039#include "core/AudioStreamBuilder.h"
Phil Burke572f462017-04-20 13:03:19 -070040#include "fifo/FifoBuffer.h"
Phil Burkfd34a932017-07-19 07:03:52 -070041#include "utility/AudioClock.h"
Phil Burke572f462017-04-20 13:03:19 -070042#include "utility/LinearRamp.h"
43
Phil Burkc0c70e32017-02-09 13:18:38 -080044#include "AudioStreamInternal.h"
Phil Burk204a1632017-01-03 17:23:43 -080045
Phil Burk204a1632017-01-03 17:23:43 -080046using android::String16;
Phil Burkdec33ab2017-01-17 14:48:16 -080047using android::Mutex;
Phil Burkc0c70e32017-02-09 13:18:38 -080048using android::WrappingBuffer;
Phil Burk204a1632017-01-03 17:23:43 -080049
Phil Burk5ed503c2017-02-01 09:38:15 -080050using namespace aaudio;
Phil Burk204a1632017-01-03 17:23:43 -080051
Phil Burke4d7bb42017-03-28 11:32:39 -070052#define MIN_TIMEOUT_NANOS (1000 * AAUDIO_NANOS_PER_MILLISECOND)
53
54// Wait at least this many times longer than the operation should take.
55#define MIN_TIMEOUT_OPERATIONS 4
56
Phil Burkbcc36742017-08-31 17:24:51 -070057#define LOG_TIMESTAMPS 0
Phil Burk87c9f642017-05-17 07:22:39 -070058
Phil Burkc0c70e32017-02-09 13:18:38 -080059AudioStreamInternal::AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService)
Phil Burk204a1632017-01-03 17:23:43 -080060 : AudioStream()
61 , mClockModel()
62 , mAudioEndpoint()
Phil Burk5ed503c2017-02-01 09:38:15 -080063 , mServiceStreamHandle(AAUDIO_HANDLE_INVALID)
Phil Burkec89b2e2017-06-20 15:05:06 -070064 , mInService(inService)
Phil Burkfd34a932017-07-19 07:03:52 -070065 , mServiceInterface(serviceInterface)
Phil Burkbcc36742017-08-31 17:24:51 -070066 , mAtomicTimestamp()
Phil Burkfd34a932017-07-19 07:03:52 -070067 , mWakeupDelayNanos(AAudioProperty_getWakeupDelayMicros() * AAUDIO_NANOS_PER_MICROSECOND)
68 , mMinimumSleepNanos(AAudioProperty_getMinimumSleepMicros() * AAUDIO_NANOS_PER_MICROSECOND)
69 {
Phil Burkfbf031e2017-10-12 15:58:31 -070070 ALOGD("%s - mWakeupDelayNanos = %d, mMinimumSleepNanos = %d",
71 __func__, mWakeupDelayNanos, mMinimumSleepNanos);
Phil Burk204a1632017-01-03 17:23:43 -080072}
73
74AudioStreamInternal::~AudioStreamInternal() {
75}
76
Phil Burk5ed503c2017-02-01 09:38:15 -080077aaudio_result_t AudioStreamInternal::open(const AudioStreamBuilder &builder) {
Phil Burk204a1632017-01-03 17:23:43 -080078
Phil Burk5ed503c2017-02-01 09:38:15 -080079 aaudio_result_t result = AAUDIO_OK;
Phil Burk99306c82017-08-14 12:38:58 -070080 int32_t capacity;
Phil Burk6479d502017-11-20 09:32:52 -080081 int32_t framesPerBurst;
Phil Burk5ed503c2017-02-01 09:38:15 -080082 AAudioStreamRequest request;
Phil Burk99306c82017-08-14 12:38:58 -070083 AAudioStreamConfiguration configurationOutput;
Phil Burk204a1632017-01-03 17:23:43 -080084
Phil Burk99306c82017-08-14 12:38:58 -070085 if (getState() != AAUDIO_STREAM_STATE_UNINITIALIZED) {
Phil Burkfbf031e2017-10-12 15:58:31 -070086 ALOGE("%s - already open! state = %d", __func__, getState());
Phil Burk99306c82017-08-14 12:38:58 -070087 return AAUDIO_ERROR_INVALID_STATE;
88 }
89
90 // Copy requested parameters to the stream.
Phil Burk204a1632017-01-03 17:23:43 -080091 result = AudioStream::open(builder);
92 if (result < 0) {
93 return result;
94 }
95
Phil Burkc0c70e32017-02-09 13:18:38 -080096 // We have to do volume scaling. So we prefer FLOAT format.
Glenn Kasten37a466a2017-05-30 15:53:14 -070097 if (getFormat() == AAUDIO_FORMAT_UNSPECIFIED) {
Phil Burkc0c70e32017-02-09 13:18:38 -080098 setFormat(AAUDIO_FORMAT_PCM_FLOAT);
99 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700100 // Request FLOAT for the shared mixer.
jiabin901f65d2017-07-12 17:56:35 -0700101 request.getConfiguration().setFormat(AAUDIO_FORMAT_PCM_FLOAT);
Phil Burkc0c70e32017-02-09 13:18:38 -0800102
Phil Burkdec33ab2017-01-17 14:48:16 -0800103 // Build the request to send to the server.
Phil Burk204a1632017-01-03 17:23:43 -0800104 request.setUserId(getuid());
105 request.setProcessId(getpid());
Phil Burk71f35bb2017-04-13 16:05:07 -0700106 request.setSharingModeMatchRequired(isSharingModeMatchRequired());
Phil Burk41f19d82018-02-13 14:59:10 -0800107 request.setInService(isInService());
Phil Burkc0c70e32017-02-09 13:18:38 -0800108
Phil Burk204a1632017-01-03 17:23:43 -0800109 request.getConfiguration().setDeviceId(getDeviceId());
110 request.getConfiguration().setSampleRate(getSampleRate());
111 request.getConfiguration().setSamplesPerFrame(getSamplesPerFrame());
Phil Burk39f02dd2017-08-04 09:13:31 -0700112 request.getConfiguration().setDirection(getDirection());
Phil Burk71f35bb2017-04-13 16:05:07 -0700113 request.getConfiguration().setSharingMode(getSharingMode());
114
Phil Burka62fb952018-01-16 12:44:06 -0800115 request.getConfiguration().setUsage(getUsage());
116 request.getConfiguration().setContentType(getContentType());
117 request.getConfiguration().setInputPreset(getInputPreset());
118
Phil Burk3df348f2017-02-08 11:41:55 -0800119 request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
Phil Burk204a1632017-01-03 17:23:43 -0800120
Phil Burk41f19d82018-02-13 14:59:10 -0800121 mDeviceChannelCount = getSamplesPerFrame(); // Assume it will be the same. Update if not.
122
Phil Burk99306c82017-08-14 12:38:58 -0700123 mServiceStreamHandle = mServiceInterface.openStream(request, configurationOutput);
Phil Burk41f19d82018-02-13 14:59:10 -0800124 if (mServiceStreamHandle < 0
125 && request.getConfiguration().getSamplesPerFrame() == 1 // mono?
126 && getDirection() == AAUDIO_DIRECTION_OUTPUT
127 && !isInService()) {
128 // if that failed then try switching from mono to stereo if OUTPUT.
129 // Only do this in the client. Otherwise we end up with a mono mixer in the service
130 // that writes to a stereo MMAP stream.
131 ALOGD("%s - openStream() returned %d, try switching from MONO to STEREO",
132 __func__, mServiceStreamHandle);
133 request.getConfiguration().setSamplesPerFrame(2); // stereo
134 mServiceStreamHandle = mServiceInterface.openStream(request, configurationOutput);
135 }
Phil Burk204a1632017-01-03 17:23:43 -0800136 if (mServiceStreamHandle < 0) {
Phil Burk41f19d82018-02-13 14:59:10 -0800137 ALOGE("%s - openStream() returned %d", __func__, mServiceStreamHandle);
138 return mServiceStreamHandle;
Phil Burk204a1632017-01-03 17:23:43 -0800139 }
Phil Burk99306c82017-08-14 12:38:58 -0700140
141 result = configurationOutput.validate();
142 if (result != AAUDIO_OK) {
143 goto error;
144 }
145 // Save results of the open.
Phil Burk41f19d82018-02-13 14:59:10 -0800146 if (getSamplesPerFrame() == AAUDIO_UNSPECIFIED) {
147 setSamplesPerFrame(configurationOutput.getSamplesPerFrame());
148 }
149 mDeviceChannelCount = configurationOutput.getSamplesPerFrame();
150
Phil Burk99306c82017-08-14 12:38:58 -0700151 setSampleRate(configurationOutput.getSampleRate());
Phil Burk99306c82017-08-14 12:38:58 -0700152 setDeviceId(configurationOutput.getDeviceId());
Phil Burk4e1af9f2018-01-03 15:54:35 -0800153 setSessionId(configurationOutput.getSessionId());
Phil Burk99306c82017-08-14 12:38:58 -0700154 setSharingMode(configurationOutput.getSharingMode());
155
Phil Burka62fb952018-01-16 12:44:06 -0800156 setUsage(configurationOutput.getUsage());
157 setContentType(configurationOutput.getContentType());
158 setInputPreset(configurationOutput.getInputPreset());
159
Phil Burk99306c82017-08-14 12:38:58 -0700160 // Save device format so we can do format conversion and volume scaling together.
161 mDeviceFormat = configurationOutput.getFormat();
162
163 result = mServiceInterface.getStreamDescription(mServiceStreamHandle, mEndPointParcelable);
164 if (result != AAUDIO_OK) {
165 goto error;
166 }
167
168 // Resolve parcelable into a descriptor.
169 result = mEndPointParcelable.resolve(&mEndpointDescriptor);
170 if (result != AAUDIO_OK) {
171 goto error;
172 }
173
174 // Configure endpoint based on descriptor.
175 result = mAudioEndpoint.configure(&mEndpointDescriptor, getDirection());
176 if (result != AAUDIO_OK) {
177 goto error;
178 }
179
Phil Burk99306c82017-08-14 12:38:58 -0700180 // Validate result from server.
Phil Burk6479d502017-11-20 09:32:52 -0800181 framesPerBurst = mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
182 if (framesPerBurst < MIN_FRAMES_PER_BURST || framesPerBurst > MAX_FRAMES_PER_BURST) {
183 ALOGE("%s - framesPerBurst out of range = %d", __func__, framesPerBurst);
Phil Burk99306c82017-08-14 12:38:58 -0700184 result = AAUDIO_ERROR_OUT_OF_RANGE;
185 goto error;
186 }
Phil Burk6479d502017-11-20 09:32:52 -0800187 mFramesPerBurst = framesPerBurst; // only save good value
188
189 capacity = mEndpointDescriptor.dataQueueDescriptor.capacityInFrames;
190 if (capacity < mFramesPerBurst || capacity > MAX_BUFFER_CAPACITY_IN_FRAMES) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700191 ALOGE("%s - bufferCapacity out of range = %d", __func__, capacity);
Phil Burk99306c82017-08-14 12:38:58 -0700192 result = AAUDIO_ERROR_OUT_OF_RANGE;
193 goto error;
194 }
195
196 mClockModel.setSampleRate(getSampleRate());
197 mClockModel.setFramesPerBurst(mFramesPerBurst);
198
Phil Burk134f1972017-12-08 13:06:11 -0800199 if (isDataCallbackSet()) {
Phil Burk99306c82017-08-14 12:38:58 -0700200 mCallbackFrames = builder.getFramesPerDataCallback();
201 if (mCallbackFrames > getBufferCapacity() / 2) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700202 ALOGE("%s - framesPerCallback too big = %d, capacity = %d",
203 __func__, mCallbackFrames, getBufferCapacity());
Phil Burk99306c82017-08-14 12:38:58 -0700204 result = AAUDIO_ERROR_OUT_OF_RANGE;
205 goto error;
206
207 } else if (mCallbackFrames < 0) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700208 ALOGE("%s - framesPerCallback negative", __func__);
Phil Burk99306c82017-08-14 12:38:58 -0700209 result = AAUDIO_ERROR_OUT_OF_RANGE;
210 goto error;
211
212 }
213 if (mCallbackFrames == AAUDIO_UNSPECIFIED) {
214 mCallbackFrames = mFramesPerBurst;
215 }
216
217 int32_t bytesPerFrame = getSamplesPerFrame()
218 * AAudioConvert_formatToSizeInBytes(getFormat());
219 int32_t callbackBufferSize = mCallbackFrames * bytesPerFrame;
220 mCallbackBuffer = new uint8_t[callbackBufferSize];
221 }
222
223 setState(AAUDIO_STREAM_STATE_OPEN);
Phil Burk99306c82017-08-14 12:38:58 -0700224
225 return result;
226
227error:
228 close();
Phil Burk204a1632017-01-03 17:23:43 -0800229 return result;
230}
231
Phil Burk5ed503c2017-02-01 09:38:15 -0800232aaudio_result_t AudioStreamInternal::close() {
Phil Burk965650e2017-09-07 21:00:09 -0700233 aaudio_result_t result = AAUDIO_OK;
234 ALOGD("close(): mServiceStreamHandle = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700235 mServiceStreamHandle);
Phil Burk5ed503c2017-02-01 09:38:15 -0800236 if (mServiceStreamHandle != AAUDIO_HANDLE_INVALID) {
Phil Burk4485d412017-05-09 15:55:02 -0700237 // Don't close a stream while it is running.
238 aaudio_stream_state_t currentState = getState();
Phil Burk87c9f642017-05-17 07:22:39 -0700239 if (isActive()) {
Phil Burk4485d412017-05-09 15:55:02 -0700240 requestStop();
241 aaudio_stream_state_t nextState;
242 int64_t timeoutNanoseconds = MIN_TIMEOUT_NANOS;
Phil Burk965650e2017-09-07 21:00:09 -0700243 result = waitForStateChange(currentState, &nextState,
Phil Burk4485d412017-05-09 15:55:02 -0700244 timeoutNanoseconds);
245 if (result != AAUDIO_OK) {
Phil Burk965650e2017-09-07 21:00:09 -0700246 ALOGE("close() waitForStateChange() returned %d %s",
Phil Burk4485d412017-05-09 15:55:02 -0700247 result, AAudio_convertResultToText(result));
248 }
249 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700250 setState(AAUDIO_STREAM_STATE_CLOSING);
Phil Burk5ed503c2017-02-01 09:38:15 -0800251 aaudio_handle_t serviceStreamHandle = mServiceStreamHandle;
252 mServiceStreamHandle = AAUDIO_HANDLE_INVALID;
Phil Burkc0c70e32017-02-09 13:18:38 -0800253
254 mServiceInterface.closeStream(serviceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700255 delete[] mCallbackBuffer;
Phil Burk4485d412017-05-09 15:55:02 -0700256 mCallbackBuffer = nullptr;
Phil Burk965650e2017-09-07 21:00:09 -0700257
Phil Burkec89b2e2017-06-20 15:05:06 -0700258 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burk965650e2017-09-07 21:00:09 -0700259 result = mEndPointParcelable.close();
260 aaudio_result_t result2 = AudioStream::close();
261 return (result != AAUDIO_OK) ? result : result2;
Phil Burk204a1632017-01-03 17:23:43 -0800262 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800263 return AAUDIO_ERROR_INVALID_HANDLE;
Phil Burk204a1632017-01-03 17:23:43 -0800264 }
265}
266
Phil Burke4d7bb42017-03-28 11:32:39 -0700267static void *aaudio_callback_thread_proc(void *context)
268{
269 AudioStreamInternal *stream = (AudioStreamInternal *)context;
Phil Burkfbf031e2017-10-12 15:58:31 -0700270 //LOGD("oboe_callback_thread, stream = %p", stream);
Phil Burke4d7bb42017-03-28 11:32:39 -0700271 if (stream != NULL) {
272 return stream->callbackLoop();
273 } else {
274 return NULL;
275 }
276}
277
Phil Burkbcc36742017-08-31 17:24:51 -0700278/*
279 * It normally takes about 20-30 msec to start a stream on the server.
280 * But the first time can take as much as 200-300 msec. The HW
281 * starts right away so by the time the client gets a chance to write into
282 * the buffer, it is already in a deep underflow state. That can cause the
283 * XRunCount to be non-zero, which could lead an app to tune its latency higher.
284 * To avoid this problem, we set a request for the processing code to start the
285 * client stream at the same position as the server stream.
286 * The processing code will then save the current offset
287 * between client and server and apply that to any position given to the app.
288 */
Phil Burk5ed503c2017-02-01 09:38:15 -0800289aaudio_result_t AudioStreamInternal::requestStart()
Phil Burk204a1632017-01-03 17:23:43 -0800290{
Phil Burk3316d5e2017-02-15 11:23:01 -0800291 int64_t startTime;
Phil Burk5ed503c2017-02-01 09:38:15 -0800292 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700293 ALOGE("requestStart() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800294 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800295 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700296 if (isActive()) {
Phil Burkbcc36742017-08-31 17:24:51 -0700297 ALOGE("requestStart() already active");
Phil Burkec89b2e2017-06-20 15:05:06 -0700298 return AAUDIO_ERROR_INVALID_STATE;
299 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700300
Phil Burkbcc36742017-08-31 17:24:51 -0700301 aaudio_stream_state_t originalState = getState();
302 if (originalState == AAUDIO_STREAM_STATE_DISCONNECTED) {
303 ALOGE("requestStart() but DISCONNECTED");
304 return AAUDIO_ERROR_DISCONNECTED;
305 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700306 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burkbcc36742017-08-31 17:24:51 -0700307
308 // Clear any stale timestamps from the previous run.
309 drainTimestampsFromService();
310
Phil Burk965650e2017-09-07 21:00:09 -0700311 aaudio_result_t result = mServiceInterface.startStream(mServiceStreamHandle);
Phil Burkc0c70e32017-02-09 13:18:38 -0800312
Phil Burk3316d5e2017-02-15 11:23:01 -0800313 startTime = AudioClock::getNanoseconds();
Phil Burk204a1632017-01-03 17:23:43 -0800314 mClockModel.start(startTime);
Phil Burkbcc36742017-08-31 17:24:51 -0700315 mNeedCatchUp.request(); // Ask data processing code to catch up when first timestamp received.
Phil Burke4d7bb42017-03-28 11:32:39 -0700316
Phil Burk965650e2017-09-07 21:00:09 -0700317 // Start data callback thread.
Phil Burk134f1972017-12-08 13:06:11 -0800318 if (result == AAUDIO_OK && isDataCallbackSet()) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700319 // Launch the callback loop thread.
320 int64_t periodNanos = mCallbackFrames
321 * AAUDIO_NANOS_PER_SECOND
322 / getSampleRate();
323 mCallbackEnabled.store(true);
324 result = createThread(periodNanos, aaudio_callback_thread_proc, this);
325 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700326 if (result != AAUDIO_OK) {
327 setState(originalState);
328 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700329 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800330}
331
Phil Burke4d7bb42017-03-28 11:32:39 -0700332int64_t AudioStreamInternal::calculateReasonableTimeout(int32_t framesPerOperation) {
333
334 // Wait for at least a second or some number of callbacks to join the thread.
Phil Burk71f35bb2017-04-13 16:05:07 -0700335 int64_t timeoutNanoseconds = (MIN_TIMEOUT_OPERATIONS
336 * framesPerOperation
337 * AAUDIO_NANOS_PER_SECOND)
338 / getSampleRate();
Phil Burke4d7bb42017-03-28 11:32:39 -0700339 if (timeoutNanoseconds < MIN_TIMEOUT_NANOS) { // arbitrary number of seconds
340 timeoutNanoseconds = MIN_TIMEOUT_NANOS;
341 }
342 return timeoutNanoseconds;
343}
344
Phil Burk87c9f642017-05-17 07:22:39 -0700345int64_t AudioStreamInternal::calculateReasonableTimeout() {
346 return calculateReasonableTimeout(getFramesPerBurst());
347}
348
Phil Burke4d7bb42017-03-28 11:32:39 -0700349aaudio_result_t AudioStreamInternal::stopCallback()
350{
351 if (isDataCallbackActive()) {
352 mCallbackEnabled.store(false);
Phil Burk87c9f642017-05-17 07:22:39 -0700353 return joinThread(NULL);
Phil Burke4d7bb42017-03-28 11:32:39 -0700354 } else {
355 return AAUDIO_OK;
356 }
357}
358
Phil Burk5cc83c32017-11-28 15:43:18 -0800359aaudio_result_t AudioStreamInternal::requestStop()
Phil Burk71f35bb2017-04-13 16:05:07 -0700360{
Phil Burk5cc83c32017-11-28 15:43:18 -0800361 aaudio_result_t result = stopCallback();
362 if (result != AAUDIO_OK) {
363 return result;
364 }
365
Phil Burk71f35bb2017-04-13 16:05:07 -0700366 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700367 ALOGE("requestStopInternal() mServiceStreamHandle invalid = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700368 mServiceStreamHandle);
369 return AAUDIO_ERROR_INVALID_STATE;
370 }
371
372 mClockModel.stop(AudioClock::getNanoseconds());
373 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burkbcc36742017-08-31 17:24:51 -0700374 mAtomicTimestamp.clear();
Phil Burk965650e2017-09-07 21:00:09 -0700375
376 return mServiceInterface.stopStream(mServiceStreamHandle);
Phil Burk71f35bb2017-04-13 16:05:07 -0700377}
378
Phil Burk5ed503c2017-02-01 09:38:15 -0800379aaudio_result_t AudioStreamInternal::registerThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800380 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700381 ALOGE("registerThread() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800382 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800383 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800384 return mServiceInterface.registerAudioThread(mServiceStreamHandle,
Phil Burkc0c70e32017-02-09 13:18:38 -0800385 gettid(),
386 getPeriodNanoseconds());
Phil Burk204a1632017-01-03 17:23:43 -0800387}
388
Phil Burk5ed503c2017-02-01 09:38:15 -0800389aaudio_result_t AudioStreamInternal::unregisterThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800390 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700391 ALOGE("unregisterThread() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800392 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800393 }
Phil Burk2ac035f2017-06-23 14:51:14 -0700394 return mServiceInterface.unregisterAudioThread(mServiceStreamHandle, gettid());
Phil Burk204a1632017-01-03 17:23:43 -0800395}
396
Eric Laurentcb4dae22017-07-01 19:39:32 -0700397aaudio_result_t AudioStreamInternal::startClient(const android::AudioClient& client,
398 audio_port_handle_t *clientHandle) {
399 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
400 return AAUDIO_ERROR_INVALID_STATE;
401 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700402
Eric Laurentcb4dae22017-07-01 19:39:32 -0700403 return mServiceInterface.startClient(mServiceStreamHandle, client, clientHandle);
404}
405
406aaudio_result_t AudioStreamInternal::stopClient(audio_port_handle_t clientHandle) {
407 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
408 return AAUDIO_ERROR_INVALID_STATE;
409 }
410 return mServiceInterface.stopClient(mServiceStreamHandle, clientHandle);
411}
412
Phil Burk5ed503c2017-02-01 09:38:15 -0800413aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t clockId,
Phil Burk3316d5e2017-02-15 11:23:01 -0800414 int64_t *framePosition,
415 int64_t *timeNanoseconds) {
Phil Burk97350f92017-07-21 15:59:44 -0700416 // Generated in server and passed to client. Return latest.
417 if (mAtomicTimestamp.isValid()) {
418 Timestamp timestamp = mAtomicTimestamp.read();
Phil Burkbcc36742017-08-31 17:24:51 -0700419 int64_t position = timestamp.getPosition() + mFramesOffsetFromService;
420 if (position >= 0) {
421 *framePosition = position;
422 *timeNanoseconds = timestamp.getNanoseconds();
423 return AAUDIO_OK;
424 }
Phil Burk97350f92017-07-21 15:59:44 -0700425 }
Phil Burkc75d97f2017-09-08 15:48:36 -0700426 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800427}
428
Phil Burk0befec62017-07-28 15:12:13 -0700429aaudio_result_t AudioStreamInternal::updateStateMachine() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700430 if (isDataCallbackActive()) {
431 return AAUDIO_OK; // state is getting updated by the callback thread read/write call
432 }
Phil Burk204a1632017-01-03 17:23:43 -0800433 return processCommands();
434}
435
Phil Burkec89b2e2017-06-20 15:05:06 -0700436void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
Phil Burk204a1632017-01-03 17:23:43 -0800437 static int64_t oldPosition = 0;
Phil Burk3316d5e2017-02-15 11:23:01 -0800438 static int64_t oldTime = 0;
Phil Burk204a1632017-01-03 17:23:43 -0800439 int64_t framePosition = command.timestamp.position;
Phil Burk3316d5e2017-02-15 11:23:01 -0800440 int64_t nanoTime = command.timestamp.timestamp;
Phil Burkbcc36742017-08-31 17:24:51 -0700441 ALOGD("logTimestamp: timestamp says framePosition = %8lld at nanoTime %lld",
Phil Burk204a1632017-01-03 17:23:43 -0800442 (long long) framePosition,
443 (long long) nanoTime);
444 int64_t nanosDelta = nanoTime - oldTime;
445 if (nanosDelta > 0 && oldTime > 0) {
446 int64_t framesDelta = framePosition - oldPosition;
Phil Burk5ed503c2017-02-01 09:38:15 -0800447 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
Phil Burkbcc36742017-08-31 17:24:51 -0700448 ALOGD("logTimestamp: framesDelta = %8lld, nanosDelta = %8lld, rate = %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700449 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
Phil Burk204a1632017-01-03 17:23:43 -0800450 }
451 oldPosition = framePosition;
452 oldTime = nanoTime;
453}
Phil Burk204a1632017-01-03 17:23:43 -0800454
Phil Burk97350f92017-07-21 15:59:44 -0700455aaudio_result_t AudioStreamInternal::onTimestampService(AAudioServiceMessage *message) {
Phil Burk204a1632017-01-03 17:23:43 -0800456#if LOG_TIMESTAMPS
Phil Burkec89b2e2017-06-20 15:05:06 -0700457 logTimestamp(*message);
Phil Burk204a1632017-01-03 17:23:43 -0800458#endif
Phil Burk87c9f642017-05-17 07:22:39 -0700459 processTimestamp(message->timestamp.position, message->timestamp.timestamp);
Phil Burk5ed503c2017-02-01 09:38:15 -0800460 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800461}
462
Phil Burk97350f92017-07-21 15:59:44 -0700463aaudio_result_t AudioStreamInternal::onTimestampHardware(AAudioServiceMessage *message) {
464 Timestamp timestamp(message->timestamp.position, message->timestamp.timestamp);
465 mAtomicTimestamp.write(timestamp);
466 return AAUDIO_OK;
467}
468
Phil Burk5ed503c2017-02-01 09:38:15 -0800469aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
470 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800471 switch (message->event.event) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800472 case AAUDIO_SERVICE_EVENT_STARTED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700473 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STARTED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700474 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
475 setState(AAUDIO_STREAM_STATE_STARTED);
476 }
Phil Burk204a1632017-01-03 17:23:43 -0800477 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800478 case AAUDIO_SERVICE_EVENT_PAUSED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700479 ALOGD("%s - got AAUDIO_SERVICE_EVENT_PAUSED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700480 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
481 setState(AAUDIO_STREAM_STATE_PAUSED);
482 }
Phil Burk204a1632017-01-03 17:23:43 -0800483 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700484 case AAUDIO_SERVICE_EVENT_STOPPED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700485 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STOPPED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700486 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
487 setState(AAUDIO_STREAM_STATE_STOPPED);
488 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700489 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800490 case AAUDIO_SERVICE_EVENT_FLUSHED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700491 ALOGD("%s - got AAUDIO_SERVICE_EVENT_FLUSHED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700492 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
493 setState(AAUDIO_STREAM_STATE_FLUSHED);
494 onFlushFromServer();
495 }
Phil Burk204a1632017-01-03 17:23:43 -0800496 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800497 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
Phil Burkea04d972017-08-07 12:30:44 -0700498 // Prevent hardware from looping on old data and making buzzing sounds.
499 if (getDirection() == AAUDIO_DIRECTION_OUTPUT) {
500 mAudioEndpoint.eraseDataMemory();
501 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800502 result = AAUDIO_ERROR_DISCONNECTED;
Phil Burkc0c70e32017-02-09 13:18:38 -0800503 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
Phil Burkfbf031e2017-10-12 15:58:31 -0700504 ALOGW("%s - AAUDIO_SERVICE_EVENT_DISCONNECTED - FIFO cleared", __func__);
Phil Burk204a1632017-01-03 17:23:43 -0800505 break;
Phil Burkc0c70e32017-02-09 13:18:38 -0800506 case AAUDIO_SERVICE_EVENT_VOLUME:
Eric Laurenta2f296e2017-06-21 18:51:47 -0700507 mStreamVolume = (float)message->event.dataDouble;
508 doSetVolume();
Phil Burkfbf031e2017-10-12 15:58:31 -0700509 ALOGD("%s - AAUDIO_SERVICE_EVENT_VOLUME %lf", __func__, message->event.dataDouble);
Phil Burkc0c70e32017-02-09 13:18:38 -0800510 break;
Phil Burk23296382017-11-20 15:45:11 -0800511 case AAUDIO_SERVICE_EVENT_XRUN:
512 mXRunCount = static_cast<int32_t>(message->event.dataLong);
513 break;
Phil Burk204a1632017-01-03 17:23:43 -0800514 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700515 ALOGE("%s - Unrecognized event = %d", __func__, (int) message->event.event);
Phil Burk204a1632017-01-03 17:23:43 -0800516 break;
517 }
518 return result;
519}
520
Phil Burkbcc36742017-08-31 17:24:51 -0700521aaudio_result_t AudioStreamInternal::drainTimestampsFromService() {
522 aaudio_result_t result = AAUDIO_OK;
523
524 while (result == AAUDIO_OK) {
525 AAudioServiceMessage message;
526 if (mAudioEndpoint.readUpCommand(&message) != 1) {
527 break; // no command this time, no problem
528 }
529 switch (message.what) {
530 // ignore most messages
531 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
532 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
533 break;
534
535 case AAudioServiceMessage::code::EVENT:
536 result = onEventFromServer(&message);
537 break;
538
539 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700540 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burkbcc36742017-08-31 17:24:51 -0700541 result = AAUDIO_ERROR_INTERNAL;
542 break;
543 }
544 }
545 return result;
546}
547
Phil Burk204a1632017-01-03 17:23:43 -0800548// Process all the commands coming from the server.
Phil Burk5ed503c2017-02-01 09:38:15 -0800549aaudio_result_t AudioStreamInternal::processCommands() {
550 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800551
Phil Burk5ed503c2017-02-01 09:38:15 -0800552 while (result == AAUDIO_OK) {
553 AAudioServiceMessage message;
Phil Burk204a1632017-01-03 17:23:43 -0800554 if (mAudioEndpoint.readUpCommand(&message) != 1) {
555 break; // no command this time, no problem
556 }
557 switch (message.what) {
Phil Burk97350f92017-07-21 15:59:44 -0700558 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
559 result = onTimestampService(&message);
560 break;
561
562 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
563 result = onTimestampHardware(&message);
Phil Burk204a1632017-01-03 17:23:43 -0800564 break;
565
Phil Burk5ed503c2017-02-01 09:38:15 -0800566 case AAudioServiceMessage::code::EVENT:
Phil Burk204a1632017-01-03 17:23:43 -0800567 result = onEventFromServer(&message);
568 break;
569
570 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700571 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burk17fff382017-05-16 14:06:45 -0700572 result = AAUDIO_ERROR_INTERNAL;
Phil Burk204a1632017-01-03 17:23:43 -0800573 break;
574 }
575 }
576 return result;
577}
578
Phil Burk87c9f642017-05-17 07:22:39 -0700579// Read or write the data, block if needed and timeoutMillis > 0
580aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
581 int64_t timeoutNanoseconds)
Phil Burk204a1632017-01-03 17:23:43 -0800582{
Phil Burkfd34a932017-07-19 07:03:52 -0700583 const char * traceName = "aaProc";
584 const char * fifoName = "aaRdy";
Phil Burk4485d412017-05-09 15:55:02 -0700585 ATRACE_BEGIN(traceName);
Phil Burk4485d412017-05-09 15:55:02 -0700586 if (ATRACE_ENABLED()) {
Phil Burkfd34a932017-07-19 07:03:52 -0700587 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
588 ATRACE_INT(fifoName, fullFrames);
Phil Burk4485d412017-05-09 15:55:02 -0700589 }
590
Phil Burkec89b2e2017-06-20 15:05:06 -0700591 aaudio_result_t result = AAUDIO_OK;
592 int32_t loopCount = 0;
593 uint8_t* audioData = (uint8_t*)buffer;
594 int64_t currentTimeNanos = AudioClock::getNanoseconds();
595 const int64_t entryTimeNanos = currentTimeNanos;
596 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
597 int32_t framesLeft = numFrames;
598
Phil Burk87c9f642017-05-17 07:22:39 -0700599 // Loop until all the data has been processed or until a timeout occurs.
Phil Burk204a1632017-01-03 17:23:43 -0800600 while (framesLeft > 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700601 // The call to processDataNow() will not block. It will just process as much as it can.
Phil Burk3316d5e2017-02-15 11:23:01 -0800602 int64_t wakeTimeNanos = 0;
Phil Burk87c9f642017-05-17 07:22:39 -0700603 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
604 currentTimeNanos, &wakeTimeNanos);
605 if (framesProcessed < 0) {
Phil Burk87c9f642017-05-17 07:22:39 -0700606 result = framesProcessed;
Phil Burk204a1632017-01-03 17:23:43 -0800607 break;
608 }
Phil Burk87c9f642017-05-17 07:22:39 -0700609 framesLeft -= (int32_t) framesProcessed;
610 audioData += framesProcessed * getBytesPerFrame();
Phil Burk204a1632017-01-03 17:23:43 -0800611
612 // Should we block?
613 if (timeoutNanoseconds == 0) {
614 break; // don't block
615 } else if (framesLeft > 0) {
Phil Burkfd34a932017-07-19 07:03:52 -0700616 if (!mAudioEndpoint.isFreeRunning()) {
617 // If there is software on the other end of the FIFO then it may get delayed.
618 // So wake up just a little after we expect it to be ready.
619 wakeTimeNanos += mWakeupDelayNanos;
Phil Burk204a1632017-01-03 17:23:43 -0800620 }
Phil Burkfd34a932017-07-19 07:03:52 -0700621
Phil Burk2bc7c182017-08-28 11:45:01 -0700622 currentTimeNanos = AudioClock::getNanoseconds();
623 int64_t earliestWakeTime = currentTimeNanos + mMinimumSleepNanos;
624 // Guarantee a minimum sleep time.
625 if (wakeTimeNanos < earliestWakeTime) {
626 wakeTimeNanos = earliestWakeTime;
627 }
628
Phil Burk204a1632017-01-03 17:23:43 -0800629 if (wakeTimeNanos > deadlineNanos) {
630 // If we time out, just return the framesWritten so far.
Phil Burkcf5f6d22017-05-26 12:35:07 -0700631 // TODO remove after we fix the deadline bug
Phil Burkfbf031e2017-10-12 15:58:31 -0700632 ALOGW("processData(): entered at %lld nanos, currently %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700633 (long long) entryTimeNanos, (long long) currentTimeNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700634 ALOGW("processData(): TIMEOUT after %lld nanos",
Phil Burkc0c70e32017-02-09 13:18:38 -0800635 (long long) timeoutNanoseconds);
Phil Burkfbf031e2017-10-12 15:58:31 -0700636 ALOGW("processData(): wakeTime = %lld, deadline = %lld nanos",
Phil Burk87c9f642017-05-17 07:22:39 -0700637 (long long) wakeTimeNanos, (long long) deadlineNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700638 ALOGW("processData(): past deadline by %d micros",
Phil Burk87c9f642017-05-17 07:22:39 -0700639 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
Phil Burkec89b2e2017-06-20 15:05:06 -0700640 mClockModel.dump();
641 mAudioEndpoint.dump();
Phil Burk204a1632017-01-03 17:23:43 -0800642 break;
643 }
644
Phil Burkfd34a932017-07-19 07:03:52 -0700645 if (ATRACE_ENABLED()) {
646 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
647 ATRACE_INT(fifoName, fullFrames);
648 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
649 ATRACE_INT("aaSlpNs", (int32_t)sleepForNanos);
650 }
651
652 AudioClock::sleepUntilNanoTime(wakeTimeNanos);
Phil Burk204a1632017-01-03 17:23:43 -0800653 currentTimeNanos = AudioClock::getNanoseconds();
654 }
655 }
656
Phil Burkfd34a932017-07-19 07:03:52 -0700657 if (ATRACE_ENABLED()) {
658 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
659 ATRACE_INT(fifoName, fullFrames);
660 }
661
Phil Burk87c9f642017-05-17 07:22:39 -0700662 // return error or framesProcessed
Phil Burkc0c70e32017-02-09 13:18:38 -0800663 (void) loopCount;
Phil Burk4485d412017-05-09 15:55:02 -0700664 ATRACE_END();
Phil Burk204a1632017-01-03 17:23:43 -0800665 return (result < 0) ? result : numFrames - framesLeft;
666}
667
Phil Burk3316d5e2017-02-15 11:23:01 -0800668void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
Phil Burk87c9f642017-05-17 07:22:39 -0700669 mClockModel.processTimestamp(position, time);
Phil Burk204a1632017-01-03 17:23:43 -0800670}
671
Phil Burk3316d5e2017-02-15 11:23:01 -0800672aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
Phil Burk6479d502017-11-20 09:32:52 -0800673 int32_t adjustedFrames = requestedFrames;
Phil Burk3316d5e2017-02-15 11:23:01 -0800674 int32_t actualFrames = 0;
Phil Burk6479d502017-11-20 09:32:52 -0800675 int32_t maximumSize = getBufferCapacity();
676
677 // Clip to minimum size so that rounding up will work better.
678 if (adjustedFrames < 1) {
679 adjustedFrames = 1;
Phil Burk71f35bb2017-04-13 16:05:07 -0700680 }
681
Phil Burk6479d502017-11-20 09:32:52 -0800682 if (adjustedFrames > maximumSize) {
683 // Clip to maximum size.
684 adjustedFrames = maximumSize;
685 } else {
686 // Round to the next highest burst size.
687 int32_t numBursts = (adjustedFrames + mFramesPerBurst - 1) / mFramesPerBurst;
688 adjustedFrames = numBursts * mFramesPerBurst;
689 // Rounding may have gone above maximum.
690 if (adjustedFrames > maximumSize) {
691 adjustedFrames = maximumSize;
692 }
693 }
694
695 aaudio_result_t result = mAudioEndpoint.setBufferSizeInFrames(adjustedFrames, &actualFrames);
Phil Burkbcc36742017-08-31 17:24:51 -0700696 ALOGD("setBufferSize() req = %d => %d", requestedFrames, actualFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800697 if (result < 0) {
698 return result;
699 } else {
700 return (aaudio_result_t) actualFrames;
701 }
Phil Burk204a1632017-01-03 17:23:43 -0800702}
703
Phil Burk87c9f642017-05-17 07:22:39 -0700704int32_t AudioStreamInternal::getBufferSize() const {
Phil Burk204a1632017-01-03 17:23:43 -0800705 return mAudioEndpoint.getBufferSizeInFrames();
706}
707
Phil Burk87c9f642017-05-17 07:22:39 -0700708int32_t AudioStreamInternal::getBufferCapacity() const {
Phil Burk204a1632017-01-03 17:23:43 -0800709 return mAudioEndpoint.getBufferCapacityInFrames();
710}
711
Phil Burk87c9f642017-05-17 07:22:39 -0700712int32_t AudioStreamInternal::getFramesPerBurst() const {
Phil Burk6479d502017-11-20 09:32:52 -0800713 return mFramesPerBurst;
Phil Burk204a1632017-01-03 17:23:43 -0800714}
715
Phil Burk87c9f642017-05-17 07:22:39 -0700716aaudio_result_t AudioStreamInternal::joinThread(void** returnArg) {
717 return AudioStream::joinThread(returnArg, calculateReasonableTimeout(getFramesPerBurst()));
Phil Burk4c5129b2017-04-28 15:17:32 -0700718}