blob: b7b4b5cd5038c6ab21ef5020a052739d62417134 [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());
Eric Laurentcb4dae22017-07-01 19:39:32 -0700107 request.setInService(mInService);
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 Burk3df348f2017-02-08 11:41:55 -0800115 request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
Phil Burk204a1632017-01-03 17:23:43 -0800116
Phil Burk99306c82017-08-14 12:38:58 -0700117 mServiceStreamHandle = mServiceInterface.openStream(request, configurationOutput);
Phil Burk204a1632017-01-03 17:23:43 -0800118 if (mServiceStreamHandle < 0) {
119 result = mServiceStreamHandle;
Phil Burkfbf031e2017-10-12 15:58:31 -0700120 ALOGE("%s - openStream() returned %d", __func__, result);
Phil Burk99306c82017-08-14 12:38:58 -0700121 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800122 }
Phil Burk99306c82017-08-14 12:38:58 -0700123
124 result = configurationOutput.validate();
125 if (result != AAUDIO_OK) {
126 goto error;
127 }
128 // Save results of the open.
129 setSampleRate(configurationOutput.getSampleRate());
130 setSamplesPerFrame(configurationOutput.getSamplesPerFrame());
131 setDeviceId(configurationOutput.getDeviceId());
132 setSharingMode(configurationOutput.getSharingMode());
133
134 // Save device format so we can do format conversion and volume scaling together.
135 mDeviceFormat = configurationOutput.getFormat();
136
137 result = mServiceInterface.getStreamDescription(mServiceStreamHandle, mEndPointParcelable);
138 if (result != AAUDIO_OK) {
139 goto error;
140 }
141
142 // Resolve parcelable into a descriptor.
143 result = mEndPointParcelable.resolve(&mEndpointDescriptor);
144 if (result != AAUDIO_OK) {
145 goto error;
146 }
147
148 // Configure endpoint based on descriptor.
149 result = mAudioEndpoint.configure(&mEndpointDescriptor, getDirection());
150 if (result != AAUDIO_OK) {
151 goto error;
152 }
153
Phil Burk99306c82017-08-14 12:38:58 -0700154
155 // Validate result from server.
Phil Burk6479d502017-11-20 09:32:52 -0800156 framesPerBurst = mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
157 if (framesPerBurst < MIN_FRAMES_PER_BURST || framesPerBurst > MAX_FRAMES_PER_BURST) {
158 ALOGE("%s - framesPerBurst out of range = %d", __func__, framesPerBurst);
Phil Burk99306c82017-08-14 12:38:58 -0700159 result = AAUDIO_ERROR_OUT_OF_RANGE;
160 goto error;
161 }
Phil Burk6479d502017-11-20 09:32:52 -0800162 mFramesPerBurst = framesPerBurst; // only save good value
163
164 capacity = mEndpointDescriptor.dataQueueDescriptor.capacityInFrames;
165 if (capacity < mFramesPerBurst || capacity > MAX_BUFFER_CAPACITY_IN_FRAMES) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700166 ALOGE("%s - bufferCapacity out of range = %d", __func__, capacity);
Phil Burk99306c82017-08-14 12:38:58 -0700167 result = AAUDIO_ERROR_OUT_OF_RANGE;
168 goto error;
169 }
170
171 mClockModel.setSampleRate(getSampleRate());
172 mClockModel.setFramesPerBurst(mFramesPerBurst);
173
174 if (getDataCallbackProc()) {
175 mCallbackFrames = builder.getFramesPerDataCallback();
176 if (mCallbackFrames > getBufferCapacity() / 2) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700177 ALOGE("%s - framesPerCallback too big = %d, capacity = %d",
178 __func__, mCallbackFrames, getBufferCapacity());
Phil Burk99306c82017-08-14 12:38:58 -0700179 result = AAUDIO_ERROR_OUT_OF_RANGE;
180 goto error;
181
182 } else if (mCallbackFrames < 0) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700183 ALOGE("%s - framesPerCallback negative", __func__);
Phil Burk99306c82017-08-14 12:38:58 -0700184 result = AAUDIO_ERROR_OUT_OF_RANGE;
185 goto error;
186
187 }
188 if (mCallbackFrames == AAUDIO_UNSPECIFIED) {
189 mCallbackFrames = mFramesPerBurst;
190 }
191
192 int32_t bytesPerFrame = getSamplesPerFrame()
193 * AAudioConvert_formatToSizeInBytes(getFormat());
194 int32_t callbackBufferSize = mCallbackFrames * bytesPerFrame;
195 mCallbackBuffer = new uint8_t[callbackBufferSize];
196 }
197
198 setState(AAUDIO_STREAM_STATE_OPEN);
Phil Burk99306c82017-08-14 12:38:58 -0700199
200 return result;
201
202error:
203 close();
Phil Burk204a1632017-01-03 17:23:43 -0800204 return result;
205}
206
Phil Burk5ed503c2017-02-01 09:38:15 -0800207aaudio_result_t AudioStreamInternal::close() {
Phil Burk965650e2017-09-07 21:00:09 -0700208 aaudio_result_t result = AAUDIO_OK;
209 ALOGD("close(): mServiceStreamHandle = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700210 mServiceStreamHandle);
Phil Burk5ed503c2017-02-01 09:38:15 -0800211 if (mServiceStreamHandle != AAUDIO_HANDLE_INVALID) {
Phil Burk4485d412017-05-09 15:55:02 -0700212 // Don't close a stream while it is running.
213 aaudio_stream_state_t currentState = getState();
Phil Burk87c9f642017-05-17 07:22:39 -0700214 if (isActive()) {
Phil Burk4485d412017-05-09 15:55:02 -0700215 requestStop();
216 aaudio_stream_state_t nextState;
217 int64_t timeoutNanoseconds = MIN_TIMEOUT_NANOS;
Phil Burk965650e2017-09-07 21:00:09 -0700218 result = waitForStateChange(currentState, &nextState,
Phil Burk4485d412017-05-09 15:55:02 -0700219 timeoutNanoseconds);
220 if (result != AAUDIO_OK) {
Phil Burk965650e2017-09-07 21:00:09 -0700221 ALOGE("close() waitForStateChange() returned %d %s",
Phil Burk4485d412017-05-09 15:55:02 -0700222 result, AAudio_convertResultToText(result));
223 }
224 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700225 setState(AAUDIO_STREAM_STATE_CLOSING);
Phil Burk5ed503c2017-02-01 09:38:15 -0800226 aaudio_handle_t serviceStreamHandle = mServiceStreamHandle;
227 mServiceStreamHandle = AAUDIO_HANDLE_INVALID;
Phil Burkc0c70e32017-02-09 13:18:38 -0800228
229 mServiceInterface.closeStream(serviceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700230 delete[] mCallbackBuffer;
Phil Burk4485d412017-05-09 15:55:02 -0700231 mCallbackBuffer = nullptr;
Phil Burk965650e2017-09-07 21:00:09 -0700232
Phil Burkec89b2e2017-06-20 15:05:06 -0700233 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burk965650e2017-09-07 21:00:09 -0700234 result = mEndPointParcelable.close();
235 aaudio_result_t result2 = AudioStream::close();
236 return (result != AAUDIO_OK) ? result : result2;
Phil Burk204a1632017-01-03 17:23:43 -0800237 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800238 return AAUDIO_ERROR_INVALID_HANDLE;
Phil Burk204a1632017-01-03 17:23:43 -0800239 }
240}
241
Phil Burke4d7bb42017-03-28 11:32:39 -0700242static void *aaudio_callback_thread_proc(void *context)
243{
244 AudioStreamInternal *stream = (AudioStreamInternal *)context;
Phil Burkfbf031e2017-10-12 15:58:31 -0700245 //LOGD("oboe_callback_thread, stream = %p", stream);
Phil Burke4d7bb42017-03-28 11:32:39 -0700246 if (stream != NULL) {
247 return stream->callbackLoop();
248 } else {
249 return NULL;
250 }
251}
252
Phil Burkbcc36742017-08-31 17:24:51 -0700253/*
254 * It normally takes about 20-30 msec to start a stream on the server.
255 * But the first time can take as much as 200-300 msec. The HW
256 * starts right away so by the time the client gets a chance to write into
257 * the buffer, it is already in a deep underflow state. That can cause the
258 * XRunCount to be non-zero, which could lead an app to tune its latency higher.
259 * To avoid this problem, we set a request for the processing code to start the
260 * client stream at the same position as the server stream.
261 * The processing code will then save the current offset
262 * between client and server and apply that to any position given to the app.
263 */
Phil Burk5ed503c2017-02-01 09:38:15 -0800264aaudio_result_t AudioStreamInternal::requestStart()
Phil Burk204a1632017-01-03 17:23:43 -0800265{
Phil Burk3316d5e2017-02-15 11:23:01 -0800266 int64_t startTime;
Phil Burk5ed503c2017-02-01 09:38:15 -0800267 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700268 ALOGE("requestStart() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800269 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800270 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700271 if (isActive()) {
Phil Burkbcc36742017-08-31 17:24:51 -0700272 ALOGE("requestStart() already active");
Phil Burkec89b2e2017-06-20 15:05:06 -0700273 return AAUDIO_ERROR_INVALID_STATE;
274 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700275
Phil Burkbcc36742017-08-31 17:24:51 -0700276 aaudio_stream_state_t originalState = getState();
277 if (originalState == AAUDIO_STREAM_STATE_DISCONNECTED) {
278 ALOGE("requestStart() but DISCONNECTED");
279 return AAUDIO_ERROR_DISCONNECTED;
280 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700281 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burkbcc36742017-08-31 17:24:51 -0700282
283 // Clear any stale timestamps from the previous run.
284 drainTimestampsFromService();
285
Phil Burk965650e2017-09-07 21:00:09 -0700286 aaudio_result_t result = mServiceInterface.startStream(mServiceStreamHandle);
Phil Burkc0c70e32017-02-09 13:18:38 -0800287
Phil Burk3316d5e2017-02-15 11:23:01 -0800288 startTime = AudioClock::getNanoseconds();
Phil Burk204a1632017-01-03 17:23:43 -0800289 mClockModel.start(startTime);
Phil Burkbcc36742017-08-31 17:24:51 -0700290 mNeedCatchUp.request(); // Ask data processing code to catch up when first timestamp received.
Phil Burke4d7bb42017-03-28 11:32:39 -0700291
Phil Burk965650e2017-09-07 21:00:09 -0700292 // Start data callback thread.
Phil Burke4d7bb42017-03-28 11:32:39 -0700293 if (result == AAUDIO_OK && getDataCallbackProc() != nullptr) {
294 // Launch the callback loop thread.
295 int64_t periodNanos = mCallbackFrames
296 * AAUDIO_NANOS_PER_SECOND
297 / getSampleRate();
298 mCallbackEnabled.store(true);
299 result = createThread(periodNanos, aaudio_callback_thread_proc, this);
300 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700301 if (result != AAUDIO_OK) {
302 setState(originalState);
303 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700304 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800305}
306
Phil Burke4d7bb42017-03-28 11:32:39 -0700307int64_t AudioStreamInternal::calculateReasonableTimeout(int32_t framesPerOperation) {
308
309 // Wait for at least a second or some number of callbacks to join the thread.
Phil Burk71f35bb2017-04-13 16:05:07 -0700310 int64_t timeoutNanoseconds = (MIN_TIMEOUT_OPERATIONS
311 * framesPerOperation
312 * AAUDIO_NANOS_PER_SECOND)
313 / getSampleRate();
Phil Burke4d7bb42017-03-28 11:32:39 -0700314 if (timeoutNanoseconds < MIN_TIMEOUT_NANOS) { // arbitrary number of seconds
315 timeoutNanoseconds = MIN_TIMEOUT_NANOS;
316 }
317 return timeoutNanoseconds;
318}
319
Phil Burk87c9f642017-05-17 07:22:39 -0700320int64_t AudioStreamInternal::calculateReasonableTimeout() {
321 return calculateReasonableTimeout(getFramesPerBurst());
322}
323
Phil Burke4d7bb42017-03-28 11:32:39 -0700324aaudio_result_t AudioStreamInternal::stopCallback()
325{
326 if (isDataCallbackActive()) {
327 mCallbackEnabled.store(false);
Phil Burk87c9f642017-05-17 07:22:39 -0700328 return joinThread(NULL);
Phil Burke4d7bb42017-03-28 11:32:39 -0700329 } else {
330 return AAUDIO_OK;
331 }
332}
333
Phil Burk71f35bb2017-04-13 16:05:07 -0700334aaudio_result_t AudioStreamInternal::requestStopInternal()
335{
336 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700337 ALOGE("requestStopInternal() mServiceStreamHandle invalid = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700338 mServiceStreamHandle);
339 return AAUDIO_ERROR_INVALID_STATE;
340 }
341
342 mClockModel.stop(AudioClock::getNanoseconds());
343 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burkbcc36742017-08-31 17:24:51 -0700344 mAtomicTimestamp.clear();
Phil Burk965650e2017-09-07 21:00:09 -0700345
346 return mServiceInterface.stopStream(mServiceStreamHandle);
Phil Burk71f35bb2017-04-13 16:05:07 -0700347}
348
Phil Burk5ed503c2017-02-01 09:38:15 -0800349aaudio_result_t AudioStreamInternal::requestStop()
Phil Burk204a1632017-01-03 17:23:43 -0800350{
Phil Burk71f35bb2017-04-13 16:05:07 -0700351 aaudio_result_t result = stopCallback();
352 if (result != AAUDIO_OK) {
353 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800354 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700355 result = requestStopInternal();
Phil Burk204a1632017-01-03 17:23:43 -0800356 return result;
357}
358
Phil Burk5ed503c2017-02-01 09:38:15 -0800359aaudio_result_t AudioStreamInternal::registerThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800360 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700361 ALOGE("registerThread() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800362 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800363 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800364 return mServiceInterface.registerAudioThread(mServiceStreamHandle,
Phil Burkc0c70e32017-02-09 13:18:38 -0800365 gettid(),
366 getPeriodNanoseconds());
Phil Burk204a1632017-01-03 17:23:43 -0800367}
368
Phil Burk5ed503c2017-02-01 09:38:15 -0800369aaudio_result_t AudioStreamInternal::unregisterThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800370 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkbcc36742017-08-31 17:24:51 -0700371 ALOGE("unregisterThread() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800372 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800373 }
Phil Burk2ac035f2017-06-23 14:51:14 -0700374 return mServiceInterface.unregisterAudioThread(mServiceStreamHandle, gettid());
Phil Burk204a1632017-01-03 17:23:43 -0800375}
376
Eric Laurentcb4dae22017-07-01 19:39:32 -0700377aaudio_result_t AudioStreamInternal::startClient(const android::AudioClient& client,
378 audio_port_handle_t *clientHandle) {
379 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
380 return AAUDIO_ERROR_INVALID_STATE;
381 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700382
Eric Laurentcb4dae22017-07-01 19:39:32 -0700383 return mServiceInterface.startClient(mServiceStreamHandle, client, clientHandle);
384}
385
386aaudio_result_t AudioStreamInternal::stopClient(audio_port_handle_t clientHandle) {
387 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
388 return AAUDIO_ERROR_INVALID_STATE;
389 }
390 return mServiceInterface.stopClient(mServiceStreamHandle, clientHandle);
391}
392
Phil Burk5ed503c2017-02-01 09:38:15 -0800393aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t clockId,
Phil Burk3316d5e2017-02-15 11:23:01 -0800394 int64_t *framePosition,
395 int64_t *timeNanoseconds) {
Phil Burk97350f92017-07-21 15:59:44 -0700396 // Generated in server and passed to client. Return latest.
397 if (mAtomicTimestamp.isValid()) {
398 Timestamp timestamp = mAtomicTimestamp.read();
Phil Burkbcc36742017-08-31 17:24:51 -0700399 int64_t position = timestamp.getPosition() + mFramesOffsetFromService;
400 if (position >= 0) {
401 *framePosition = position;
402 *timeNanoseconds = timestamp.getNanoseconds();
403 return AAUDIO_OK;
404 }
Phil Burk97350f92017-07-21 15:59:44 -0700405 }
Phil Burkc75d97f2017-09-08 15:48:36 -0700406 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800407}
408
Phil Burk0befec62017-07-28 15:12:13 -0700409aaudio_result_t AudioStreamInternal::updateStateMachine() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700410 if (isDataCallbackActive()) {
411 return AAUDIO_OK; // state is getting updated by the callback thread read/write call
412 }
Phil Burk204a1632017-01-03 17:23:43 -0800413 return processCommands();
414}
415
Phil Burkec89b2e2017-06-20 15:05:06 -0700416void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
Phil Burk204a1632017-01-03 17:23:43 -0800417 static int64_t oldPosition = 0;
Phil Burk3316d5e2017-02-15 11:23:01 -0800418 static int64_t oldTime = 0;
Phil Burk204a1632017-01-03 17:23:43 -0800419 int64_t framePosition = command.timestamp.position;
Phil Burk3316d5e2017-02-15 11:23:01 -0800420 int64_t nanoTime = command.timestamp.timestamp;
Phil Burkbcc36742017-08-31 17:24:51 -0700421 ALOGD("logTimestamp: timestamp says framePosition = %8lld at nanoTime %lld",
Phil Burk204a1632017-01-03 17:23:43 -0800422 (long long) framePosition,
423 (long long) nanoTime);
424 int64_t nanosDelta = nanoTime - oldTime;
425 if (nanosDelta > 0 && oldTime > 0) {
426 int64_t framesDelta = framePosition - oldPosition;
Phil Burk5ed503c2017-02-01 09:38:15 -0800427 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
Phil Burkbcc36742017-08-31 17:24:51 -0700428 ALOGD("logTimestamp: framesDelta = %8lld, nanosDelta = %8lld, rate = %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700429 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
Phil Burk204a1632017-01-03 17:23:43 -0800430 }
431 oldPosition = framePosition;
432 oldTime = nanoTime;
433}
Phil Burk204a1632017-01-03 17:23:43 -0800434
Phil Burk97350f92017-07-21 15:59:44 -0700435aaudio_result_t AudioStreamInternal::onTimestampService(AAudioServiceMessage *message) {
Phil Burk204a1632017-01-03 17:23:43 -0800436#if LOG_TIMESTAMPS
Phil Burkec89b2e2017-06-20 15:05:06 -0700437 logTimestamp(*message);
Phil Burk204a1632017-01-03 17:23:43 -0800438#endif
Phil Burk87c9f642017-05-17 07:22:39 -0700439 processTimestamp(message->timestamp.position, message->timestamp.timestamp);
Phil Burk5ed503c2017-02-01 09:38:15 -0800440 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800441}
442
Phil Burk97350f92017-07-21 15:59:44 -0700443aaudio_result_t AudioStreamInternal::onTimestampHardware(AAudioServiceMessage *message) {
444 Timestamp timestamp(message->timestamp.position, message->timestamp.timestamp);
445 mAtomicTimestamp.write(timestamp);
446 return AAUDIO_OK;
447}
448
Phil Burk5ed503c2017-02-01 09:38:15 -0800449aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
450 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800451 switch (message->event.event) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800452 case AAUDIO_SERVICE_EVENT_STARTED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700453 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STARTED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700454 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
455 setState(AAUDIO_STREAM_STATE_STARTED);
456 }
Phil Burk204a1632017-01-03 17:23:43 -0800457 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800458 case AAUDIO_SERVICE_EVENT_PAUSED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700459 ALOGD("%s - got AAUDIO_SERVICE_EVENT_PAUSED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700460 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
461 setState(AAUDIO_STREAM_STATE_PAUSED);
462 }
Phil Burk204a1632017-01-03 17:23:43 -0800463 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700464 case AAUDIO_SERVICE_EVENT_STOPPED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700465 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STOPPED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700466 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
467 setState(AAUDIO_STREAM_STATE_STOPPED);
468 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700469 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800470 case AAUDIO_SERVICE_EVENT_FLUSHED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700471 ALOGD("%s - got AAUDIO_SERVICE_EVENT_FLUSHED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700472 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
473 setState(AAUDIO_STREAM_STATE_FLUSHED);
474 onFlushFromServer();
475 }
Phil Burk204a1632017-01-03 17:23:43 -0800476 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800477 case AAUDIO_SERVICE_EVENT_CLOSED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700478 ALOGD("%s - got AAUDIO_SERVICE_EVENT_CLOSED", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800479 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burk204a1632017-01-03 17:23:43 -0800480 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800481 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
Phil Burkea04d972017-08-07 12:30:44 -0700482 // Prevent hardware from looping on old data and making buzzing sounds.
483 if (getDirection() == AAUDIO_DIRECTION_OUTPUT) {
484 mAudioEndpoint.eraseDataMemory();
485 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800486 result = AAUDIO_ERROR_DISCONNECTED;
Phil Burkc0c70e32017-02-09 13:18:38 -0800487 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
Phil Burkfbf031e2017-10-12 15:58:31 -0700488 ALOGW("%s - AAUDIO_SERVICE_EVENT_DISCONNECTED - FIFO cleared", __func__);
Phil Burk204a1632017-01-03 17:23:43 -0800489 break;
Phil Burkc0c70e32017-02-09 13:18:38 -0800490 case AAUDIO_SERVICE_EVENT_VOLUME:
Eric Laurenta2f296e2017-06-21 18:51:47 -0700491 mStreamVolume = (float)message->event.dataDouble;
492 doSetVolume();
Phil Burkfbf031e2017-10-12 15:58:31 -0700493 ALOGD("%s - AAUDIO_SERVICE_EVENT_VOLUME %lf", __func__, message->event.dataDouble);
Phil Burkc0c70e32017-02-09 13:18:38 -0800494 break;
Phil Burk23296382017-11-20 15:45:11 -0800495 case AAUDIO_SERVICE_EVENT_XRUN:
496 mXRunCount = static_cast<int32_t>(message->event.dataLong);
497 break;
Phil Burk204a1632017-01-03 17:23:43 -0800498 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700499 ALOGE("%s - Unrecognized event = %d", __func__, (int) message->event.event);
Phil Burk204a1632017-01-03 17:23:43 -0800500 break;
501 }
502 return result;
503}
504
Phil Burkbcc36742017-08-31 17:24:51 -0700505aaudio_result_t AudioStreamInternal::drainTimestampsFromService() {
506 aaudio_result_t result = AAUDIO_OK;
507
508 while (result == AAUDIO_OK) {
509 AAudioServiceMessage message;
510 if (mAudioEndpoint.readUpCommand(&message) != 1) {
511 break; // no command this time, no problem
512 }
513 switch (message.what) {
514 // ignore most messages
515 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
516 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
517 break;
518
519 case AAudioServiceMessage::code::EVENT:
520 result = onEventFromServer(&message);
521 break;
522
523 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700524 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burkbcc36742017-08-31 17:24:51 -0700525 result = AAUDIO_ERROR_INTERNAL;
526 break;
527 }
528 }
529 return result;
530}
531
Phil Burk204a1632017-01-03 17:23:43 -0800532// Process all the commands coming from the server.
Phil Burk5ed503c2017-02-01 09:38:15 -0800533aaudio_result_t AudioStreamInternal::processCommands() {
534 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800535
Phil Burk5ed503c2017-02-01 09:38:15 -0800536 while (result == AAUDIO_OK) {
537 AAudioServiceMessage message;
Phil Burk204a1632017-01-03 17:23:43 -0800538 if (mAudioEndpoint.readUpCommand(&message) != 1) {
539 break; // no command this time, no problem
540 }
541 switch (message.what) {
Phil Burk97350f92017-07-21 15:59:44 -0700542 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
543 result = onTimestampService(&message);
544 break;
545
546 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
547 result = onTimestampHardware(&message);
Phil Burk204a1632017-01-03 17:23:43 -0800548 break;
549
Phil Burk5ed503c2017-02-01 09:38:15 -0800550 case AAudioServiceMessage::code::EVENT:
Phil Burk204a1632017-01-03 17:23:43 -0800551 result = onEventFromServer(&message);
552 break;
553
554 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700555 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burk17fff382017-05-16 14:06:45 -0700556 result = AAUDIO_ERROR_INTERNAL;
Phil Burk204a1632017-01-03 17:23:43 -0800557 break;
558 }
559 }
560 return result;
561}
562
Phil Burk87c9f642017-05-17 07:22:39 -0700563// Read or write the data, block if needed and timeoutMillis > 0
564aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
565 int64_t timeoutNanoseconds)
Phil Burk204a1632017-01-03 17:23:43 -0800566{
Phil Burkfd34a932017-07-19 07:03:52 -0700567 const char * traceName = "aaProc";
568 const char * fifoName = "aaRdy";
Phil Burk4485d412017-05-09 15:55:02 -0700569 ATRACE_BEGIN(traceName);
Phil Burk4485d412017-05-09 15:55:02 -0700570 if (ATRACE_ENABLED()) {
Phil Burkfd34a932017-07-19 07:03:52 -0700571 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
572 ATRACE_INT(fifoName, fullFrames);
Phil Burk4485d412017-05-09 15:55:02 -0700573 }
574
Phil Burkec89b2e2017-06-20 15:05:06 -0700575 aaudio_result_t result = AAUDIO_OK;
576 int32_t loopCount = 0;
577 uint8_t* audioData = (uint8_t*)buffer;
578 int64_t currentTimeNanos = AudioClock::getNanoseconds();
579 const int64_t entryTimeNanos = currentTimeNanos;
580 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
581 int32_t framesLeft = numFrames;
582
Phil Burk87c9f642017-05-17 07:22:39 -0700583 // Loop until all the data has been processed or until a timeout occurs.
Phil Burk204a1632017-01-03 17:23:43 -0800584 while (framesLeft > 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700585 // The call to processDataNow() will not block. It will just process as much as it can.
Phil Burk3316d5e2017-02-15 11:23:01 -0800586 int64_t wakeTimeNanos = 0;
Phil Burk87c9f642017-05-17 07:22:39 -0700587 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
588 currentTimeNanos, &wakeTimeNanos);
589 if (framesProcessed < 0) {
Phil Burk87c9f642017-05-17 07:22:39 -0700590 result = framesProcessed;
Phil Burk204a1632017-01-03 17:23:43 -0800591 break;
592 }
Phil Burk87c9f642017-05-17 07:22:39 -0700593 framesLeft -= (int32_t) framesProcessed;
594 audioData += framesProcessed * getBytesPerFrame();
Phil Burk204a1632017-01-03 17:23:43 -0800595
596 // Should we block?
597 if (timeoutNanoseconds == 0) {
598 break; // don't block
599 } else if (framesLeft > 0) {
Phil Burkfd34a932017-07-19 07:03:52 -0700600 if (!mAudioEndpoint.isFreeRunning()) {
601 // If there is software on the other end of the FIFO then it may get delayed.
602 // So wake up just a little after we expect it to be ready.
603 wakeTimeNanos += mWakeupDelayNanos;
Phil Burk204a1632017-01-03 17:23:43 -0800604 }
Phil Burkfd34a932017-07-19 07:03:52 -0700605
Phil Burk2bc7c182017-08-28 11:45:01 -0700606 currentTimeNanos = AudioClock::getNanoseconds();
607 int64_t earliestWakeTime = currentTimeNanos + mMinimumSleepNanos;
608 // Guarantee a minimum sleep time.
609 if (wakeTimeNanos < earliestWakeTime) {
610 wakeTimeNanos = earliestWakeTime;
611 }
612
Phil Burk204a1632017-01-03 17:23:43 -0800613 if (wakeTimeNanos > deadlineNanos) {
614 // If we time out, just return the framesWritten so far.
Phil Burkcf5f6d22017-05-26 12:35:07 -0700615 // TODO remove after we fix the deadline bug
Phil Burkfbf031e2017-10-12 15:58:31 -0700616 ALOGW("processData(): entered at %lld nanos, currently %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700617 (long long) entryTimeNanos, (long long) currentTimeNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700618 ALOGW("processData(): TIMEOUT after %lld nanos",
Phil Burkc0c70e32017-02-09 13:18:38 -0800619 (long long) timeoutNanoseconds);
Phil Burkfbf031e2017-10-12 15:58:31 -0700620 ALOGW("processData(): wakeTime = %lld, deadline = %lld nanos",
Phil Burk87c9f642017-05-17 07:22:39 -0700621 (long long) wakeTimeNanos, (long long) deadlineNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700622 ALOGW("processData(): past deadline by %d micros",
Phil Burk87c9f642017-05-17 07:22:39 -0700623 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
Phil Burkec89b2e2017-06-20 15:05:06 -0700624 mClockModel.dump();
625 mAudioEndpoint.dump();
Phil Burk204a1632017-01-03 17:23:43 -0800626 break;
627 }
628
Phil Burkfd34a932017-07-19 07:03:52 -0700629 if (ATRACE_ENABLED()) {
630 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
631 ATRACE_INT(fifoName, fullFrames);
632 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
633 ATRACE_INT("aaSlpNs", (int32_t)sleepForNanos);
634 }
635
636 AudioClock::sleepUntilNanoTime(wakeTimeNanos);
Phil Burk204a1632017-01-03 17:23:43 -0800637 currentTimeNanos = AudioClock::getNanoseconds();
638 }
639 }
640
Phil Burkfd34a932017-07-19 07:03:52 -0700641 if (ATRACE_ENABLED()) {
642 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
643 ATRACE_INT(fifoName, fullFrames);
644 }
645
Phil Burk87c9f642017-05-17 07:22:39 -0700646 // return error or framesProcessed
Phil Burkc0c70e32017-02-09 13:18:38 -0800647 (void) loopCount;
Phil Burk4485d412017-05-09 15:55:02 -0700648 ATRACE_END();
Phil Burk204a1632017-01-03 17:23:43 -0800649 return (result < 0) ? result : numFrames - framesLeft;
650}
651
Phil Burk3316d5e2017-02-15 11:23:01 -0800652void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
Phil Burk87c9f642017-05-17 07:22:39 -0700653 mClockModel.processTimestamp(position, time);
Phil Burk204a1632017-01-03 17:23:43 -0800654}
655
Phil Burk3316d5e2017-02-15 11:23:01 -0800656aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
Phil Burk6479d502017-11-20 09:32:52 -0800657 int32_t adjustedFrames = requestedFrames;
Phil Burk3316d5e2017-02-15 11:23:01 -0800658 int32_t actualFrames = 0;
Phil Burk6479d502017-11-20 09:32:52 -0800659 int32_t maximumSize = getBufferCapacity();
660
661 // Clip to minimum size so that rounding up will work better.
662 if (adjustedFrames < 1) {
663 adjustedFrames = 1;
Phil Burk71f35bb2017-04-13 16:05:07 -0700664 }
665
Phil Burk6479d502017-11-20 09:32:52 -0800666 if (adjustedFrames > maximumSize) {
667 // Clip to maximum size.
668 adjustedFrames = maximumSize;
669 } else {
670 // Round to the next highest burst size.
671 int32_t numBursts = (adjustedFrames + mFramesPerBurst - 1) / mFramesPerBurst;
672 adjustedFrames = numBursts * mFramesPerBurst;
673 // Rounding may have gone above maximum.
674 if (adjustedFrames > maximumSize) {
675 adjustedFrames = maximumSize;
676 }
677 }
678
679 aaudio_result_t result = mAudioEndpoint.setBufferSizeInFrames(adjustedFrames, &actualFrames);
Phil Burkbcc36742017-08-31 17:24:51 -0700680 ALOGD("setBufferSize() req = %d => %d", requestedFrames, actualFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800681 if (result < 0) {
682 return result;
683 } else {
684 return (aaudio_result_t) actualFrames;
685 }
Phil Burk204a1632017-01-03 17:23:43 -0800686}
687
Phil Burk87c9f642017-05-17 07:22:39 -0700688int32_t AudioStreamInternal::getBufferSize() const {
Phil Burk204a1632017-01-03 17:23:43 -0800689 return mAudioEndpoint.getBufferSizeInFrames();
690}
691
Phil Burk87c9f642017-05-17 07:22:39 -0700692int32_t AudioStreamInternal::getBufferCapacity() const {
Phil Burk204a1632017-01-03 17:23:43 -0800693 return mAudioEndpoint.getBufferCapacityInFrames();
694}
695
Phil Burk87c9f642017-05-17 07:22:39 -0700696int32_t AudioStreamInternal::getFramesPerBurst() const {
Phil Burk6479d502017-11-20 09:32:52 -0800697 return mFramesPerBurst;
Phil Burk204a1632017-01-03 17:23:43 -0800698}
699
Phil Burk87c9f642017-05-17 07:22:39 -0700700aaudio_result_t AudioStreamInternal::joinThread(void** returnArg) {
701 return AudioStream::joinThread(returnArg, calculateReasonableTimeout(getFramesPerBurst()));
Phil Burk4c5129b2017-04-28 15:17:32 -0700702}