blob: 89d42bfe9dcf08745a20f6b957d0b89bd1d316b7 [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 Burka9876702020-04-20 18:16:15 -070017#define LOG_TAG "AudioStreamInternal"
Phil Burk204a1632017-01-03 17:23:43 -080018//#define LOG_NDEBUG 0
19#include <utils/Log.h>
20
Phil Burk4485d412017-05-09 15:55:02 -070021#define ATRACE_TAG ATRACE_TAG_AUDIO
22
Phil Burkc0c70e32017-02-09 13:18:38 -080023#include <stdint.h>
Phil Burk204a1632017-01-03 17:23:43 -080024
25#include <binder/IServiceManager.h>
26
Phil Burk5ed503c2017-02-01 09:38:15 -080027#include <aaudio/AAudio.h>
Phil Burkfd34a932017-07-19 07:03:52 -070028#include <cutils/properties.h>
Phil Burka9876702020-04-20 18:16:15 -070029
jiabine504e7b2021-09-18 00:27:08 +000030#include <media/AudioSystem.h>
Phil Burka9876702020-04-20 18:16:15 -070031#include <media/MediaMetricsItem.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"
Phil Burk5ed503c2017-02-01 09:38:15 -080037#include "binding/AAudioServiceMessage.h"
Phil Burka9876702020-04-20 18:16:15 -070038#include "core/AudioGlobal.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"
Philip P. Moltmannbda45752020-07-17 16:41:18 -070042#include <media/AidlConversion.h>
Phil Burke572f462017-04-20 13:03:19 -070043
Phil Burkc0c70e32017-02-09 13:18:38 -080044#include "AudioStreamInternal.h"
Phil Burk204a1632017-01-03 17:23:43 -080045
Phil Burka9876702020-04-20 18:16:15 -070046// We do this after the #includes because if a header uses ALOG.
47// it would fail on the reference to mInService.
48#undef LOG_TAG
49// This file is used in both client and server processes.
50// This is needed to make sense of the logs more easily.
51#define LOG_TAG (mInService ? "AudioStreamInternal_Service" : "AudioStreamInternal_Client")
52
Svet Ganov3e5f14f2021-05-13 22:51:08 +000053using android::content::AttributionSourceState;
Phil Burk204a1632017-01-03 17:23:43 -080054
Phil Burk5ed503c2017-02-01 09:38:15 -080055using namespace aaudio;
Phil Burk204a1632017-01-03 17:23:43 -080056
Phil Burke4d7bb42017-03-28 11:32:39 -070057#define MIN_TIMEOUT_NANOS (1000 * AAUDIO_NANOS_PER_MILLISECOND)
58
59// Wait at least this many times longer than the operation should take.
60#define MIN_TIMEOUT_OPERATIONS 4
61
Phil Burkbcc36742017-08-31 17:24:51 -070062#define LOG_TIMESTAMPS 0
Phil Burk87c9f642017-05-17 07:22:39 -070063
Phil Burkc0c70e32017-02-09 13:18:38 -080064AudioStreamInternal::AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService)
Phil Burk204a1632017-01-03 17:23:43 -080065 : AudioStream()
66 , mClockModel()
Phil Burk5ed503c2017-02-01 09:38:15 -080067 , mServiceStreamHandle(AAUDIO_HANDLE_INVALID)
Phil Burkec89b2e2017-06-20 15:05:06 -070068 , mInService(inService)
Phil Burkfd34a932017-07-19 07:03:52 -070069 , mServiceInterface(serviceInterface)
Phil Burka53ffa62018-10-10 16:21:37 -070070 , mAtomicInternalTimestamp()
Phil Burkfd34a932017-07-19 07:03:52 -070071 , mWakeupDelayNanos(AAudioProperty_getWakeupDelayMicros() * AAUDIO_NANOS_PER_MICROSECOND)
72 , mMinimumSleepNanos(AAudioProperty_getMinimumSleepMicros() * AAUDIO_NANOS_PER_MICROSECOND)
73 {
Phil Burk204a1632017-01-03 17:23:43 -080074}
75
76AudioStreamInternal::~AudioStreamInternal() {
Phil Burkdd582922020-10-15 20:29:51 +000077 ALOGD("%s() %p called", __func__, this);
Phil Burk204a1632017-01-03 17:23:43 -080078}
79
Phil Burk5ed503c2017-02-01 09:38:15 -080080aaudio_result_t AudioStreamInternal::open(const AudioStreamBuilder &builder) {
Phil Burk204a1632017-01-03 17:23:43 -080081
Phil Burk5ed503c2017-02-01 09:38:15 -080082 aaudio_result_t result = AAUDIO_OK;
Phil Burk6479d502017-11-20 09:32:52 -080083 int32_t framesPerBurst;
Phil Burk3c4e6b52019-01-22 15:53:36 -080084 int32_t framesPerHardwareBurst;
Phil Burk5ed503c2017-02-01 09:38:15 -080085 AAudioStreamRequest request;
Phil Burk99306c82017-08-14 12:38:58 -070086 AAudioStreamConfiguration configurationOutput;
Phil Burk204a1632017-01-03 17:23:43 -080087
Phil Burk99306c82017-08-14 12:38:58 -070088 if (getState() != AAUDIO_STREAM_STATE_UNINITIALIZED) {
Phil Burkfbf031e2017-10-12 15:58:31 -070089 ALOGE("%s - already open! state = %d", __func__, getState());
Phil Burk99306c82017-08-14 12:38:58 -070090 return AAUDIO_ERROR_INVALID_STATE;
91 }
92
93 // Copy requested parameters to the stream.
Phil Burk204a1632017-01-03 17:23:43 -080094 result = AudioStream::open(builder);
95 if (result < 0) {
96 return result;
97 }
98
jiabine504e7b2021-09-18 00:27:08 +000099 const int32_t burstMinMicros = android::AudioSystem::getAAudioHardwareBurstMinUsec();
Phil Burk3c4e6b52019-01-22 15:53:36 -0800100 int32_t burstMicros = 0;
101
jiabinef348b82021-04-19 16:53:08 +0000102 const audio_format_t requestedFormat = getFormat();
Phil Burkc0c70e32017-02-09 13:18:38 -0800103 // We have to do volume scaling. So we prefer FLOAT format.
jiabinef348b82021-04-19 16:53:08 +0000104 if (requestedFormat == AUDIO_FORMAT_DEFAULT) {
Phil Burk0127c1b2018-03-29 13:48:06 -0700105 setFormat(AUDIO_FORMAT_PCM_FLOAT);
Phil Burkc0c70e32017-02-09 13:18:38 -0800106 }
Phil Burk04e805b2018-03-27 09:13:53 -0700107 // Request FLOAT for the shared mixer or the device.
Phil Burk0127c1b2018-03-29 13:48:06 -0700108 request.getConfiguration().setFormat(AUDIO_FORMAT_PCM_FLOAT);
Phil Burkc0c70e32017-02-09 13:18:38 -0800109
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000110 // TODO b/182392769: use attribution source util
111 AttributionSourceState attributionSource;
112 attributionSource.uid = VALUE_OR_FATAL(android::legacy2aidl_uid_t_int32_t(getuid()));
113 attributionSource.pid = VALUE_OR_FATAL(android::legacy2aidl_pid_t_int32_t(getpid()));
114 attributionSource.packageName = builder.getOpPackageName();
115 attributionSource.attributionTag = builder.getAttributionTag();
116 attributionSource.token = sp<android::BBinder>::make();
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700117
Phil Burkdec33ab2017-01-17 14:48:16 -0800118 // Build the request to send to the server.
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000119 request.setAttributionSource(attributionSource);
Phil Burk71f35bb2017-04-13 16:05:07 -0700120 request.setSharingModeMatchRequired(isSharingModeMatchRequired());
Phil Burk41f19d82018-02-13 14:59:10 -0800121 request.setInService(isInService());
Phil Burkc0c70e32017-02-09 13:18:38 -0800122
Phil Burk204a1632017-01-03 17:23:43 -0800123 request.getConfiguration().setDeviceId(getDeviceId());
124 request.getConfiguration().setSampleRate(getSampleRate());
Phil Burk39f02dd2017-08-04 09:13:31 -0700125 request.getConfiguration().setDirection(getDirection());
Phil Burk71f35bb2017-04-13 16:05:07 -0700126 request.getConfiguration().setSharingMode(getSharingMode());
jiabina9094092021-06-28 20:36:45 +0000127 request.getConfiguration().setChannelMask(getChannelMask());
Phil Burk71f35bb2017-04-13 16:05:07 -0700128
Phil Burka62fb952018-01-16 12:44:06 -0800129 request.getConfiguration().setUsage(getUsage());
130 request.getConfiguration().setContentType(getContentType());
Jean-Michel Trivi656bfdc2021-09-20 18:42:37 -0700131 request.getConfiguration().setSpatializationBehavior(getSpatializationBehavior());
132 request.getConfiguration().setIsContentSpatialized(isContentSpatialized());
Phil Burka62fb952018-01-16 12:44:06 -0800133 request.getConfiguration().setInputPreset(getInputPreset());
Eric Laurentd17c8502019-10-24 15:58:35 -0700134 request.getConfiguration().setPrivacySensitive(isPrivacySensitive());
Phil Burka62fb952018-01-16 12:44:06 -0800135
Phil Burk3df348f2017-02-08 11:41:55 -0800136 request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
Phil Burk204a1632017-01-03 17:23:43 -0800137
Phil Burk41f19d82018-02-13 14:59:10 -0800138 mDeviceChannelCount = getSamplesPerFrame(); // Assume it will be the same. Update if not.
139
Phil Burk99306c82017-08-14 12:38:58 -0700140 mServiceStreamHandle = mServiceInterface.openStream(request, configurationOutput);
Phil Burk41f19d82018-02-13 14:59:10 -0800141 if (mServiceStreamHandle < 0
jiabina9094092021-06-28 20:36:45 +0000142 && (request.getConfiguration().getSamplesPerFrame() == 1
143 || request.getConfiguration().getChannelMask() == AAUDIO_CHANNEL_MONO)
Phil Burk41f19d82018-02-13 14:59:10 -0800144 && getDirection() == AAUDIO_DIRECTION_OUTPUT
145 && !isInService()) {
146 // if that failed then try switching from mono to stereo if OUTPUT.
147 // Only do this in the client. Otherwise we end up with a mono mixer in the service
148 // that writes to a stereo MMAP stream.
Phil Burk0127c1b2018-03-29 13:48:06 -0700149 ALOGD("%s() - openStream() returned %d, try switching from MONO to STEREO",
Phil Burk41f19d82018-02-13 14:59:10 -0800150 __func__, mServiceStreamHandle);
jiabina9094092021-06-28 20:36:45 +0000151 request.getConfiguration().setChannelMask(AAUDIO_CHANNEL_STEREO);
Phil Burk41f19d82018-02-13 14:59:10 -0800152 mServiceStreamHandle = mServiceInterface.openStream(request, configurationOutput);
153 }
Phil Burk204a1632017-01-03 17:23:43 -0800154 if (mServiceStreamHandle < 0) {
Phil Burk41f19d82018-02-13 14:59:10 -0800155 return mServiceStreamHandle;
Phil Burk204a1632017-01-03 17:23:43 -0800156 }
Phil Burk99306c82017-08-14 12:38:58 -0700157
Phil Burka9876702020-04-20 18:16:15 -0700158 // This must match the key generated in oboeservice/AAudioServiceStreamBase.cpp
159 // so the client can have permission to log.
jiabinfbf20302021-07-28 22:15:01 +0000160 if (!mInService) {
161 // No need to log if it is from service side.
162 mMetricsId = std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_STREAM)
163 + std::to_string(mServiceStreamHandle);
164 }
Phil Burka9876702020-04-20 18:16:15 -0700165
jiabinef348b82021-04-19 16:53:08 +0000166 android::mediametrics::LogItem(mMetricsId)
167 .set(AMEDIAMETRICS_PROP_PERFORMANCEMODE,
jiabinc8da9032021-04-28 20:42:36 +0000168 AudioGlobal_convertPerformanceModeToText(builder.getPerformanceMode()))
169 .set(AMEDIAMETRICS_PROP_SHARINGMODE,
170 AudioGlobal_convertSharingModeToText(builder.getSharingMode()))
jiabinef348b82021-04-19 16:53:08 +0000171 .set(AMEDIAMETRICS_PROP_ENCODINGCLIENT,
172 android::toString(requestedFormat).c_str()).record();
173
Phil Burk99306c82017-08-14 12:38:58 -0700174 result = configurationOutput.validate();
175 if (result != AAUDIO_OK) {
176 goto error;
177 }
178 // Save results of the open.
jiabina9094092021-06-28 20:36:45 +0000179 if (getChannelMask() == AAUDIO_UNSPECIFIED) {
180 setChannelMask(configurationOutput.getChannelMask());
Phil Burk41f19d82018-02-13 14:59:10 -0800181 }
jiabina9094092021-06-28 20:36:45 +0000182
Phil Burk41f19d82018-02-13 14:59:10 -0800183 mDeviceChannelCount = configurationOutput.getSamplesPerFrame();
184
Phil Burk99306c82017-08-14 12:38:58 -0700185 setSampleRate(configurationOutput.getSampleRate());
Phil Burk99306c82017-08-14 12:38:58 -0700186 setDeviceId(configurationOutput.getDeviceId());
Phil Burk4e1af9f2018-01-03 15:54:35 -0800187 setSessionId(configurationOutput.getSessionId());
Phil Burk99306c82017-08-14 12:38:58 -0700188 setSharingMode(configurationOutput.getSharingMode());
189
Phil Burka62fb952018-01-16 12:44:06 -0800190 setUsage(configurationOutput.getUsage());
191 setContentType(configurationOutput.getContentType());
Jean-Michel Trivi656bfdc2021-09-20 18:42:37 -0700192 setSpatializationBehavior(configurationOutput.getSpatializationBehavior());
193 setIsContentSpatialized(configurationOutput.isContentSpatialized());
Phil Burka62fb952018-01-16 12:44:06 -0800194 setInputPreset(configurationOutput.getInputPreset());
195
Phil Burk99306c82017-08-14 12:38:58 -0700196 // Save device format so we can do format conversion and volume scaling together.
Phil Burk3d786cb2018-04-09 11:58:09 -0700197 setDeviceFormat(configurationOutput.getFormat());
Phil Burk99306c82017-08-14 12:38:58 -0700198
199 result = mServiceInterface.getStreamDescription(mServiceStreamHandle, mEndPointParcelable);
200 if (result != AAUDIO_OK) {
201 goto error;
202 }
203
204 // Resolve parcelable into a descriptor.
205 result = mEndPointParcelable.resolve(&mEndpointDescriptor);
206 if (result != AAUDIO_OK) {
207 goto error;
208 }
209
210 // Configure endpoint based on descriptor.
Phil Burk5edc4ea2020-04-17 08:15:42 -0700211 mAudioEndpoint = std::make_unique<AudioEndpoint>();
212 result = mAudioEndpoint->configure(&mEndpointDescriptor, getDirection());
Phil Burk99306c82017-08-14 12:38:58 -0700213 if (result != AAUDIO_OK) {
214 goto error;
215 }
216
Phil Burk3c4e6b52019-01-22 15:53:36 -0800217 framesPerHardwareBurst = mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
218
219 // Scale up the burst size to meet the minimum equivalent in microseconds.
220 // This is to avoid waking the CPU too often when the HW burst is very small
221 // or at high sample rates.
222 framesPerBurst = framesPerHardwareBurst;
223 do {
224 if (burstMicros > 0) { // skip first loop
225 framesPerBurst *= 2;
226 }
227 burstMicros = framesPerBurst * static_cast<int64_t>(1000000) / getSampleRate();
228 } while (burstMicros < burstMinMicros);
229 ALOGD("%s() original HW burst = %d, minMicros = %d => SW burst = %d\n",
230 __func__, framesPerHardwareBurst, burstMinMicros, framesPerBurst);
231
232 // Validate final burst size.
Phil Burk6479d502017-11-20 09:32:52 -0800233 if (framesPerBurst < MIN_FRAMES_PER_BURST || framesPerBurst > MAX_FRAMES_PER_BURST) {
234 ALOGE("%s - framesPerBurst out of range = %d", __func__, framesPerBurst);
Phil Burk99306c82017-08-14 12:38:58 -0700235 result = AAUDIO_ERROR_OUT_OF_RANGE;
236 goto error;
237 }
Phil Burk8d97b8e2020-09-25 23:18:14 +0000238 setFramesPerBurst(framesPerBurst); // only save good value
Phil Burk6479d502017-11-20 09:32:52 -0800239
Phil Burk5edc4ea2020-04-17 08:15:42 -0700240 mBufferCapacityInFrames = mEndpointDescriptor.dataQueueDescriptor.capacityInFrames;
Phil Burk8d97b8e2020-09-25 23:18:14 +0000241 if (mBufferCapacityInFrames < getFramesPerBurst()
Phil Burk5edc4ea2020-04-17 08:15:42 -0700242 || mBufferCapacityInFrames > MAX_BUFFER_CAPACITY_IN_FRAMES) {
243 ALOGE("%s - bufferCapacity out of range = %d", __func__, mBufferCapacityInFrames);
Phil Burk99306c82017-08-14 12:38:58 -0700244 result = AAUDIO_ERROR_OUT_OF_RANGE;
245 goto error;
246 }
247
248 mClockModel.setSampleRate(getSampleRate());
Phil Burk3c4e6b52019-01-22 15:53:36 -0800249 mClockModel.setFramesPerBurst(framesPerHardwareBurst);
Phil Burk99306c82017-08-14 12:38:58 -0700250
Phil Burk134f1972017-12-08 13:06:11 -0800251 if (isDataCallbackSet()) {
Phil Burk99306c82017-08-14 12:38:58 -0700252 mCallbackFrames = builder.getFramesPerDataCallback();
253 if (mCallbackFrames > getBufferCapacity() / 2) {
Phil Burk29ccc292019-04-15 08:58:08 -0700254 ALOGW("%s - framesPerCallback too big = %d, capacity = %d",
Phil Burkfbf031e2017-10-12 15:58:31 -0700255 __func__, mCallbackFrames, getBufferCapacity());
Phil Burk99306c82017-08-14 12:38:58 -0700256 result = AAUDIO_ERROR_OUT_OF_RANGE;
257 goto error;
258
259 } else if (mCallbackFrames < 0) {
Phil Burk29ccc292019-04-15 08:58:08 -0700260 ALOGW("%s - framesPerCallback negative", __func__);
Phil Burk99306c82017-08-14 12:38:58 -0700261 result = AAUDIO_ERROR_OUT_OF_RANGE;
262 goto error;
263
264 }
265 if (mCallbackFrames == AAUDIO_UNSPECIFIED) {
Phil Burk8d97b8e2020-09-25 23:18:14 +0000266 mCallbackFrames = getFramesPerBurst();
Phil Burk99306c82017-08-14 12:38:58 -0700267 }
268
Phil Burk0127c1b2018-03-29 13:48:06 -0700269 const int32_t callbackBufferSize = mCallbackFrames * getBytesPerFrame();
Phil Burkbf821e22020-04-17 11:51:43 -0700270 mCallbackBuffer = std::make_unique<uint8_t[]>(callbackBufferSize);
Phil Burk99306c82017-08-14 12:38:58 -0700271 }
272
Phil Burkb31b66f2019-09-30 09:33:41 -0700273 // For debugging and analyzing the distribution of MMAP timestamps.
274 // For OUTPUT, use a NEGATIVE offset to move the CPU writes further BEFORE the HW reads.
275 // For INPUT, use a POSITIVE offset to move the CPU reads further AFTER the HW writes.
276 // You can use this offset to reduce glitching.
277 // You can also use this offset to force glitching. By iterating over multiple
278 // values you can reveal the distribution of the hardware timing jitter.
Phil Burk5edc4ea2020-04-17 08:15:42 -0700279 if (mAudioEndpoint->isFreeRunning()) { // MMAP?
Phil Burkb31b66f2019-09-30 09:33:41 -0700280 int32_t offsetMicros = (getDirection() == AAUDIO_DIRECTION_OUTPUT)
281 ? AAudioProperty_getOutputMMapOffsetMicros()
282 : AAudioProperty_getInputMMapOffsetMicros();
283 // This log is used to debug some tricky glitch issues. Please leave.
284 ALOGD_IF(offsetMicros, "%s() - %s mmap offset = %d micros",
285 __func__,
286 (getDirection() == AAUDIO_DIRECTION_OUTPUT) ? "output" : "input",
287 offsetMicros);
288 mTimeOffsetNanos = offsetMicros * AAUDIO_NANOS_PER_MICROSECOND;
289 }
290
Phil Burk5edc4ea2020-04-17 08:15:42 -0700291 setBufferSize(mBufferCapacityInFrames / 2); // Default buffer size to match Q
Phil Burk6c63ae32019-10-28 10:28:21 -0700292
Phil Burk99306c82017-08-14 12:38:58 -0700293 setState(AAUDIO_STREAM_STATE_OPEN);
Phil Burk99306c82017-08-14 12:38:58 -0700294
295 return result;
296
297error:
Phil Burkdd582922020-10-15 20:29:51 +0000298 safeReleaseClose();
Phil Burk204a1632017-01-03 17:23:43 -0800299 return result;
300}
301
Phil Burk13d3d832019-06-10 14:36:48 -0700302// This must be called under mStreamLock.
Phil Burk8b4e05e2019-12-17 12:12:09 -0800303aaudio_result_t AudioStreamInternal::release_l() {
Phil Burk965650e2017-09-07 21:00:09 -0700304 aaudio_result_t result = AAUDIO_OK;
Phil Burkdd582922020-10-15 20:29:51 +0000305 ALOGD("%s(): mServiceStreamHandle = 0x%08X", __func__, mServiceStreamHandle);
Phil Burk5ed503c2017-02-01 09:38:15 -0800306 if (mServiceStreamHandle != AAUDIO_HANDLE_INVALID) {
Phil Burk4485d412017-05-09 15:55:02 -0700307 aaudio_stream_state_t currentState = getState();
Phil Burk8b4e05e2019-12-17 12:12:09 -0800308 // Don't release a stream while it is running. Stop it first.
Phil Burk13d3d832019-06-10 14:36:48 -0700309 // If DISCONNECTED then we should still try to stop in case the
310 // error callback is still running.
311 if (isActive() || currentState == AAUDIO_STREAM_STATE_DISCONNECTED) {
Phil Burkdd582922020-10-15 20:29:51 +0000312 requestStop_l();
Phil Burk4485d412017-05-09 15:55:02 -0700313 }
Phil Burka9876702020-04-20 18:16:15 -0700314
Phil Burk64e16a72020-06-01 13:25:51 -0700315 logReleaseBufferState();
Phil Burka9876702020-04-20 18:16:15 -0700316
Phil Burkec89b2e2017-06-20 15:05:06 -0700317 setState(AAUDIO_STREAM_STATE_CLOSING);
Phil Burk5ed503c2017-02-01 09:38:15 -0800318 aaudio_handle_t serviceStreamHandle = mServiceStreamHandle;
319 mServiceStreamHandle = AAUDIO_HANDLE_INVALID;
Phil Burkc0c70e32017-02-09 13:18:38 -0800320
321 mServiceInterface.closeStream(serviceStreamHandle);
Phil Burkbf821e22020-04-17 11:51:43 -0700322 mCallbackBuffer.reset();
Phil Burk5edc4ea2020-04-17 08:15:42 -0700323
324 // Update local frame counters so we can query them after releasing the endpoint.
325 getFramesRead();
326 getFramesWritten();
327 mAudioEndpoint.reset();
Phil Burk965650e2017-09-07 21:00:09 -0700328 result = mEndPointParcelable.close();
Phil Burk8b4e05e2019-12-17 12:12:09 -0800329 aaudio_result_t result2 = AudioStream::release_l();
Phil Burk965650e2017-09-07 21:00:09 -0700330 return (result != AAUDIO_OK) ? result : result2;
Phil Burk204a1632017-01-03 17:23:43 -0800331 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800332 return AAUDIO_ERROR_INVALID_HANDLE;
Phil Burk204a1632017-01-03 17:23:43 -0800333 }
334}
335
Phil Burke4d7bb42017-03-28 11:32:39 -0700336static void *aaudio_callback_thread_proc(void *context)
337{
338 AudioStreamInternal *stream = (AudioStreamInternal *)context;
Phil Burkfbf031e2017-10-12 15:58:31 -0700339 //LOGD("oboe_callback_thread, stream = %p", stream);
jiabind5bd06a2021-04-27 22:04:08 +0000340 if (stream != nullptr) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700341 return stream->callbackLoop();
342 } else {
jiabind5bd06a2021-04-27 22:04:08 +0000343 return nullptr;
Phil Burke4d7bb42017-03-28 11:32:39 -0700344 }
345}
346
Phil Burkbcc36742017-08-31 17:24:51 -0700347/*
348 * It normally takes about 20-30 msec to start a stream on the server.
349 * But the first time can take as much as 200-300 msec. The HW
350 * starts right away so by the time the client gets a chance to write into
351 * the buffer, it is already in a deep underflow state. That can cause the
352 * XRunCount to be non-zero, which could lead an app to tune its latency higher.
353 * To avoid this problem, we set a request for the processing code to start the
354 * client stream at the same position as the server stream.
355 * The processing code will then save the current offset
356 * between client and server and apply that to any position given to the app.
357 */
Phil Burkdd582922020-10-15 20:29:51 +0000358aaudio_result_t AudioStreamInternal::requestStart_l()
Phil Burk204a1632017-01-03 17:23:43 -0800359{
Phil Burk3316d5e2017-02-15 11:23:01 -0800360 int64_t startTime;
Phil Burk5ed503c2017-02-01 09:38:15 -0800361 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700362 ALOGD("requestStart() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800363 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800364 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700365 if (isActive()) {
Phil Burk29ccc292019-04-15 08:58:08 -0700366 ALOGD("requestStart() already active");
Phil Burkec89b2e2017-06-20 15:05:06 -0700367 return AAUDIO_ERROR_INVALID_STATE;
368 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700369
Phil Burkbcc36742017-08-31 17:24:51 -0700370 aaudio_stream_state_t originalState = getState();
371 if (originalState == AAUDIO_STREAM_STATE_DISCONNECTED) {
Phil Burk29ccc292019-04-15 08:58:08 -0700372 ALOGD("requestStart() but DISCONNECTED");
Phil Burkbcc36742017-08-31 17:24:51 -0700373 return AAUDIO_ERROR_DISCONNECTED;
374 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700375 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burkbcc36742017-08-31 17:24:51 -0700376
377 // Clear any stale timestamps from the previous run.
378 drainTimestampsFromService();
379
Phil Burkec8ca522020-05-19 10:05:58 -0700380 prepareBuffersForStart(); // tell subclasses to get ready
381
Phil Burk965650e2017-09-07 21:00:09 -0700382 aaudio_result_t result = mServiceInterface.startStream(mServiceStreamHandle);
Phil Burk6e463ce2020-04-13 10:20:20 -0700383 if (result == AAUDIO_ERROR_INVALID_HANDLE) {
384 ALOGD("%s() INVALID_HANDLE, stream was probably stolen", __func__);
385 // Stealing was added in R. Coerce result to improve backward compatibility.
386 result = AAUDIO_ERROR_DISCONNECTED;
387 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
388 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800389
Phil Burk3316d5e2017-02-15 11:23:01 -0800390 startTime = AudioClock::getNanoseconds();
Phil Burk204a1632017-01-03 17:23:43 -0800391 mClockModel.start(startTime);
Phil Burkbcc36742017-08-31 17:24:51 -0700392 mNeedCatchUp.request(); // Ask data processing code to catch up when first timestamp received.
Phil Burke4d7bb42017-03-28 11:32:39 -0700393
Phil Burk965650e2017-09-07 21:00:09 -0700394 // Start data callback thread.
Phil Burk134f1972017-12-08 13:06:11 -0800395 if (result == AAUDIO_OK && isDataCallbackSet()) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700396 // Launch the callback loop thread.
397 int64_t periodNanos = mCallbackFrames
398 * AAUDIO_NANOS_PER_SECOND
399 / getSampleRate();
400 mCallbackEnabled.store(true);
Phil Burkdd582922020-10-15 20:29:51 +0000401 result = createThread_l(periodNanos, aaudio_callback_thread_proc, this);
Phil Burke4d7bb42017-03-28 11:32:39 -0700402 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700403 if (result != AAUDIO_OK) {
404 setState(originalState);
405 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700406 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800407}
408
Phil Burke4d7bb42017-03-28 11:32:39 -0700409int64_t AudioStreamInternal::calculateReasonableTimeout(int32_t framesPerOperation) {
410
411 // Wait for at least a second or some number of callbacks to join the thread.
Phil Burk71f35bb2017-04-13 16:05:07 -0700412 int64_t timeoutNanoseconds = (MIN_TIMEOUT_OPERATIONS
413 * framesPerOperation
414 * AAUDIO_NANOS_PER_SECOND)
415 / getSampleRate();
Phil Burke4d7bb42017-03-28 11:32:39 -0700416 if (timeoutNanoseconds < MIN_TIMEOUT_NANOS) { // arbitrary number of seconds
417 timeoutNanoseconds = MIN_TIMEOUT_NANOS;
418 }
419 return timeoutNanoseconds;
420}
421
Phil Burk87c9f642017-05-17 07:22:39 -0700422int64_t AudioStreamInternal::calculateReasonableTimeout() {
423 return calculateReasonableTimeout(getFramesPerBurst());
424}
425
Phil Burk13d3d832019-06-10 14:36:48 -0700426// This must be called under mStreamLock.
Phil Burkdd582922020-10-15 20:29:51 +0000427aaudio_result_t AudioStreamInternal::stopCallback_l()
Phil Burke4d7bb42017-03-28 11:32:39 -0700428{
Phil Burk13d3d832019-06-10 14:36:48 -0700429 if (isDataCallbackSet()
430 && (isActive() || getState() == AAUDIO_STREAM_STATE_DISCONNECTED)) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700431 mCallbackEnabled.store(false);
jiabind5bd06a2021-04-27 22:04:08 +0000432 aaudio_result_t result = joinThread_l(nullptr); // may temporarily unlock mStreamLock
Phil Burk6e463ce2020-04-13 10:20:20 -0700433 if (result == AAUDIO_ERROR_INVALID_HANDLE) {
434 ALOGD("%s() INVALID_HANDLE, stream was probably stolen", __func__);
435 result = AAUDIO_OK;
436 }
437 return result;
Phil Burke4d7bb42017-03-28 11:32:39 -0700438 } else {
Phil Burkdd582922020-10-15 20:29:51 +0000439 ALOGD("%s() skipped, isDataCallbackSet() = %d, isActive() = %d, getState() = %d", __func__,
440 isDataCallbackSet(), isActive(), getState());
Phil Burke4d7bb42017-03-28 11:32:39 -0700441 return AAUDIO_OK;
442 }
443}
444
Phil Burkdd582922020-10-15 20:29:51 +0000445aaudio_result_t AudioStreamInternal::requestStop_l() {
446 aaudio_result_t result = stopCallback_l();
Phil Burk5cc83c32017-11-28 15:43:18 -0800447 if (result != AAUDIO_OK) {
Phil Burkdd582922020-10-15 20:29:51 +0000448 ALOGW("%s() stop callback returned %d, returning early", __func__, result);
Phil Burk5cc83c32017-11-28 15:43:18 -0800449 return result;
450 }
Phil Burk13d3d832019-06-10 14:36:48 -0700451 // The stream may have been unlocked temporarily to let a callback finish
452 // and the callback may have stopped the stream.
453 // Check to make sure the stream still needs to be stopped.
Phil Burk0bd745e2020-10-17 18:20:01 +0000454 // See also AudioStream::safeStop_l().
Phil Burk13d3d832019-06-10 14:36:48 -0700455 if (!(isActive() || getState() == AAUDIO_STREAM_STATE_DISCONNECTED)) {
Phil Burkdd582922020-10-15 20:29:51 +0000456 ALOGD("%s() returning early, not active or disconnected", __func__);
Phil Burk13d3d832019-06-10 14:36:48 -0700457 return AAUDIO_OK;
458 }
Phil Burk5cc83c32017-11-28 15:43:18 -0800459
Phil Burk71f35bb2017-04-13 16:05:07 -0700460 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700461 ALOGW("%s() mServiceStreamHandle invalid = 0x%08X",
462 __func__, mServiceStreamHandle);
Phil Burk71f35bb2017-04-13 16:05:07 -0700463 return AAUDIO_ERROR_INVALID_STATE;
464 }
465
466 mClockModel.stop(AudioClock::getNanoseconds());
467 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burka53ffa62018-10-10 16:21:37 -0700468 mAtomicInternalTimestamp.clear();
Phil Burk965650e2017-09-07 21:00:09 -0700469
Phil Burk6e463ce2020-04-13 10:20:20 -0700470 result = mServiceInterface.stopStream(mServiceStreamHandle);
471 if (result == AAUDIO_ERROR_INVALID_HANDLE) {
472 ALOGD("%s() INVALID_HANDLE, stream was probably stolen", __func__);
473 result = AAUDIO_OK;
474 }
475 return result;
Phil Burk71f35bb2017-04-13 16:05:07 -0700476}
477
Phil Burk5ed503c2017-02-01 09:38:15 -0800478aaudio_result_t AudioStreamInternal::registerThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800479 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700480 ALOGW("%s() mServiceStreamHandle invalid", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800481 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800482 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800483 return mServiceInterface.registerAudioThread(mServiceStreamHandle,
Phil Burkc0c70e32017-02-09 13:18:38 -0800484 gettid(),
485 getPeriodNanoseconds());
Phil Burk204a1632017-01-03 17:23:43 -0800486}
487
Phil Burk5ed503c2017-02-01 09:38:15 -0800488aaudio_result_t AudioStreamInternal::unregisterThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800489 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700490 ALOGW("%s() mServiceStreamHandle invalid", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800491 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800492 }
Phil Burk2ac035f2017-06-23 14:51:14 -0700493 return mServiceInterface.unregisterAudioThread(mServiceStreamHandle, gettid());
Phil Burk204a1632017-01-03 17:23:43 -0800494}
495
Eric Laurentcb4dae22017-07-01 19:39:32 -0700496aaudio_result_t AudioStreamInternal::startClient(const android::AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -0700497 const audio_attributes_t *attr,
Phil Burkbbd52862018-04-13 11:37:42 -0700498 audio_port_handle_t *portHandle) {
499 ALOGV("%s() called", __func__);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700500 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
501 return AAUDIO_ERROR_INVALID_STATE;
502 }
Phil Burkbbd52862018-04-13 11:37:42 -0700503 aaudio_result_t result = mServiceInterface.startClient(mServiceStreamHandle,
jiabind1f1cb62020-03-24 11:57:57 -0700504 client, attr, portHandle);
Phil Burkbbd52862018-04-13 11:37:42 -0700505 ALOGV("%s(%d) returning %d", __func__, *portHandle, result);
506 return result;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700507}
508
Phil Burkbbd52862018-04-13 11:37:42 -0700509aaudio_result_t AudioStreamInternal::stopClient(audio_port_handle_t portHandle) {
510 ALOGV("%s(%d) called", __func__, portHandle);
Eric Laurentcb4dae22017-07-01 19:39:32 -0700511 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
512 return AAUDIO_ERROR_INVALID_STATE;
513 }
Phil Burkbbd52862018-04-13 11:37:42 -0700514 aaudio_result_t result = mServiceInterface.stopClient(mServiceStreamHandle, portHandle);
515 ALOGV("%s(%d) returning %d", __func__, portHandle, result);
516 return result;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700517}
518
jiabind5bd06a2021-04-27 22:04:08 +0000519aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t /*clockId*/,
Phil Burk3316d5e2017-02-15 11:23:01 -0800520 int64_t *framePosition,
521 int64_t *timeNanoseconds) {
Phil Burk97350f92017-07-21 15:59:44 -0700522 // Generated in server and passed to client. Return latest.
Phil Burka53ffa62018-10-10 16:21:37 -0700523 if (mAtomicInternalTimestamp.isValid()) {
524 Timestamp timestamp = mAtomicInternalTimestamp.read();
Phil Burkbcc36742017-08-31 17:24:51 -0700525 int64_t position = timestamp.getPosition() + mFramesOffsetFromService;
526 if (position >= 0) {
527 *framePosition = position;
528 *timeNanoseconds = timestamp.getNanoseconds();
529 return AAUDIO_OK;
530 }
Phil Burk97350f92017-07-21 15:59:44 -0700531 }
Phil Burkc75d97f2017-09-08 15:48:36 -0700532 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800533}
534
Phil Burk0befec62017-07-28 15:12:13 -0700535aaudio_result_t AudioStreamInternal::updateStateMachine() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700536 if (isDataCallbackActive()) {
537 return AAUDIO_OK; // state is getting updated by the callback thread read/write call
538 }
Phil Burk204a1632017-01-03 17:23:43 -0800539 return processCommands();
540}
541
Phil Burkec89b2e2017-06-20 15:05:06 -0700542void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
Phil Burk204a1632017-01-03 17:23:43 -0800543 static int64_t oldPosition = 0;
Phil Burk3316d5e2017-02-15 11:23:01 -0800544 static int64_t oldTime = 0;
Phil Burk204a1632017-01-03 17:23:43 -0800545 int64_t framePosition = command.timestamp.position;
Phil Burk3316d5e2017-02-15 11:23:01 -0800546 int64_t nanoTime = command.timestamp.timestamp;
Phil Burkbcc36742017-08-31 17:24:51 -0700547 ALOGD("logTimestamp: timestamp says framePosition = %8lld at nanoTime %lld",
Phil Burk204a1632017-01-03 17:23:43 -0800548 (long long) framePosition,
549 (long long) nanoTime);
550 int64_t nanosDelta = nanoTime - oldTime;
551 if (nanosDelta > 0 && oldTime > 0) {
552 int64_t framesDelta = framePosition - oldPosition;
Phil Burk5ed503c2017-02-01 09:38:15 -0800553 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
Phil Burkbcc36742017-08-31 17:24:51 -0700554 ALOGD("logTimestamp: framesDelta = %8lld, nanosDelta = %8lld, rate = %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700555 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
Phil Burk204a1632017-01-03 17:23:43 -0800556 }
557 oldPosition = framePosition;
558 oldTime = nanoTime;
559}
Phil Burk204a1632017-01-03 17:23:43 -0800560
Phil Burk97350f92017-07-21 15:59:44 -0700561aaudio_result_t AudioStreamInternal::onTimestampService(AAudioServiceMessage *message) {
Phil Burk204a1632017-01-03 17:23:43 -0800562#if LOG_TIMESTAMPS
Phil Burkec89b2e2017-06-20 15:05:06 -0700563 logTimestamp(*message);
Phil Burk204a1632017-01-03 17:23:43 -0800564#endif
Phil Burkb31b66f2019-09-30 09:33:41 -0700565 processTimestamp(message->timestamp.position,
566 message->timestamp.timestamp + mTimeOffsetNanos);
Phil Burk5ed503c2017-02-01 09:38:15 -0800567 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800568}
569
Phil Burk97350f92017-07-21 15:59:44 -0700570aaudio_result_t AudioStreamInternal::onTimestampHardware(AAudioServiceMessage *message) {
571 Timestamp timestamp(message->timestamp.position, message->timestamp.timestamp);
Phil Burka53ffa62018-10-10 16:21:37 -0700572 mAtomicInternalTimestamp.write(timestamp);
Phil Burk97350f92017-07-21 15:59:44 -0700573 return AAUDIO_OK;
574}
575
Phil Burk5ed503c2017-02-01 09:38:15 -0800576aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
577 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800578 switch (message->event.event) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800579 case AAUDIO_SERVICE_EVENT_STARTED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700580 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STARTED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700581 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
582 setState(AAUDIO_STREAM_STATE_STARTED);
583 }
Phil Burk204a1632017-01-03 17:23:43 -0800584 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800585 case AAUDIO_SERVICE_EVENT_PAUSED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700586 ALOGD("%s - got AAUDIO_SERVICE_EVENT_PAUSED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700587 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
588 setState(AAUDIO_STREAM_STATE_PAUSED);
589 }
Phil Burk204a1632017-01-03 17:23:43 -0800590 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700591 case AAUDIO_SERVICE_EVENT_STOPPED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700592 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STOPPED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700593 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
594 setState(AAUDIO_STREAM_STATE_STOPPED);
595 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700596 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800597 case AAUDIO_SERVICE_EVENT_FLUSHED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700598 ALOGD("%s - got AAUDIO_SERVICE_EVENT_FLUSHED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700599 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
600 setState(AAUDIO_STREAM_STATE_FLUSHED);
601 onFlushFromServer();
602 }
Phil Burk204a1632017-01-03 17:23:43 -0800603 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800604 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
Phil Burkea04d972017-08-07 12:30:44 -0700605 // Prevent hardware from looping on old data and making buzzing sounds.
606 if (getDirection() == AAUDIO_DIRECTION_OUTPUT) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700607 mAudioEndpoint->eraseDataMemory();
Phil Burkea04d972017-08-07 12:30:44 -0700608 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800609 result = AAUDIO_ERROR_DISCONNECTED;
Phil Burkc0c70e32017-02-09 13:18:38 -0800610 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
Phil Burkfbf031e2017-10-12 15:58:31 -0700611 ALOGW("%s - AAUDIO_SERVICE_EVENT_DISCONNECTED - FIFO cleared", __func__);
Phil Burk204a1632017-01-03 17:23:43 -0800612 break;
Phil Burkc0c70e32017-02-09 13:18:38 -0800613 case AAUDIO_SERVICE_EVENT_VOLUME:
Phil Burk55e5eab2018-04-10 15:16:38 -0700614 ALOGD("%s - AAUDIO_SERVICE_EVENT_VOLUME %lf", __func__, message->event.dataDouble);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700615 mStreamVolume = (float)message->event.dataDouble;
616 doSetVolume();
Phil Burkc0c70e32017-02-09 13:18:38 -0800617 break;
Phil Burk23296382017-11-20 15:45:11 -0800618 case AAUDIO_SERVICE_EVENT_XRUN:
619 mXRunCount = static_cast<int32_t>(message->event.dataLong);
620 break;
Phil Burk204a1632017-01-03 17:23:43 -0800621 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700622 ALOGE("%s - Unrecognized event = %d", __func__, (int) message->event.event);
Phil Burk204a1632017-01-03 17:23:43 -0800623 break;
624 }
625 return result;
626}
627
Phil Burkbcc36742017-08-31 17:24:51 -0700628aaudio_result_t AudioStreamInternal::drainTimestampsFromService() {
629 aaudio_result_t result = AAUDIO_OK;
630
631 while (result == AAUDIO_OK) {
632 AAudioServiceMessage message;
Phil Burk5edc4ea2020-04-17 08:15:42 -0700633 if (!mAudioEndpoint) {
634 break;
635 }
636 if (mAudioEndpoint->readUpCommand(&message) != 1) {
Phil Burkbcc36742017-08-31 17:24:51 -0700637 break; // no command this time, no problem
638 }
639 switch (message.what) {
640 // ignore most messages
641 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
642 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
643 break;
644
645 case AAudioServiceMessage::code::EVENT:
646 result = onEventFromServer(&message);
647 break;
648
649 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700650 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burkbcc36742017-08-31 17:24:51 -0700651 result = AAUDIO_ERROR_INTERNAL;
652 break;
653 }
654 }
655 return result;
656}
657
Phil Burk204a1632017-01-03 17:23:43 -0800658// Process all the commands coming from the server.
Phil Burk5ed503c2017-02-01 09:38:15 -0800659aaudio_result_t AudioStreamInternal::processCommands() {
660 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800661
Phil Burk5ed503c2017-02-01 09:38:15 -0800662 while (result == AAUDIO_OK) {
663 AAudioServiceMessage message;
Phil Burk5edc4ea2020-04-17 08:15:42 -0700664 if (!mAudioEndpoint) {
665 break;
666 }
667 if (mAudioEndpoint->readUpCommand(&message) != 1) {
Phil Burk204a1632017-01-03 17:23:43 -0800668 break; // no command this time, no problem
669 }
670 switch (message.what) {
Phil Burk97350f92017-07-21 15:59:44 -0700671 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
672 result = onTimestampService(&message);
673 break;
674
675 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
676 result = onTimestampHardware(&message);
Phil Burk204a1632017-01-03 17:23:43 -0800677 break;
678
Phil Burk5ed503c2017-02-01 09:38:15 -0800679 case AAudioServiceMessage::code::EVENT:
Phil Burk204a1632017-01-03 17:23:43 -0800680 result = onEventFromServer(&message);
681 break;
682
683 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700684 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burk17fff382017-05-16 14:06:45 -0700685 result = AAUDIO_ERROR_INTERNAL;
Phil Burk204a1632017-01-03 17:23:43 -0800686 break;
687 }
688 }
689 return result;
690}
691
Phil Burk87c9f642017-05-17 07:22:39 -0700692// Read or write the data, block if needed and timeoutMillis > 0
693aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
694 int64_t timeoutNanoseconds)
Phil Burk204a1632017-01-03 17:23:43 -0800695{
Phil Burkfd34a932017-07-19 07:03:52 -0700696 const char * traceName = "aaProc";
697 const char * fifoName = "aaRdy";
Phil Burk4485d412017-05-09 15:55:02 -0700698 ATRACE_BEGIN(traceName);
Phil Burk4485d412017-05-09 15:55:02 -0700699 if (ATRACE_ENABLED()) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700700 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
Phil Burkfd34a932017-07-19 07:03:52 -0700701 ATRACE_INT(fifoName, fullFrames);
Phil Burk4485d412017-05-09 15:55:02 -0700702 }
703
Phil Burkec89b2e2017-06-20 15:05:06 -0700704 aaudio_result_t result = AAUDIO_OK;
705 int32_t loopCount = 0;
706 uint8_t* audioData = (uint8_t*)buffer;
707 int64_t currentTimeNanos = AudioClock::getNanoseconds();
708 const int64_t entryTimeNanos = currentTimeNanos;
709 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
710 int32_t framesLeft = numFrames;
711
Phil Burk87c9f642017-05-17 07:22:39 -0700712 // Loop until all the data has been processed or until a timeout occurs.
Phil Burk204a1632017-01-03 17:23:43 -0800713 while (framesLeft > 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700714 // The call to processDataNow() will not block. It will just process as much as it can.
Phil Burk3316d5e2017-02-15 11:23:01 -0800715 int64_t wakeTimeNanos = 0;
Phil Burk87c9f642017-05-17 07:22:39 -0700716 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
717 currentTimeNanos, &wakeTimeNanos);
718 if (framesProcessed < 0) {
Phil Burk87c9f642017-05-17 07:22:39 -0700719 result = framesProcessed;
Phil Burk204a1632017-01-03 17:23:43 -0800720 break;
721 }
Phil Burk87c9f642017-05-17 07:22:39 -0700722 framesLeft -= (int32_t) framesProcessed;
723 audioData += framesProcessed * getBytesPerFrame();
Phil Burk204a1632017-01-03 17:23:43 -0800724
725 // Should we block?
726 if (timeoutNanoseconds == 0) {
727 break; // don't block
Phil Burk8d4f0062019-10-03 15:55:41 -0700728 } else if (wakeTimeNanos != 0) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700729 if (!mAudioEndpoint->isFreeRunning()) {
Phil Burkfd34a932017-07-19 07:03:52 -0700730 // If there is software on the other end of the FIFO then it may get delayed.
731 // So wake up just a little after we expect it to be ready.
732 wakeTimeNanos += mWakeupDelayNanos;
Phil Burk204a1632017-01-03 17:23:43 -0800733 }
Phil Burkfd34a932017-07-19 07:03:52 -0700734
Phil Burk2bc7c182017-08-28 11:45:01 -0700735 currentTimeNanos = AudioClock::getNanoseconds();
736 int64_t earliestWakeTime = currentTimeNanos + mMinimumSleepNanos;
737 // Guarantee a minimum sleep time.
738 if (wakeTimeNanos < earliestWakeTime) {
739 wakeTimeNanos = earliestWakeTime;
740 }
741
Phil Burk204a1632017-01-03 17:23:43 -0800742 if (wakeTimeNanos > deadlineNanos) {
743 // If we time out, just return the framesWritten so far.
Phil Burkcf5f6d22017-05-26 12:35:07 -0700744 // TODO remove after we fix the deadline bug
Phil Burkfbf031e2017-10-12 15:58:31 -0700745 ALOGW("processData(): entered at %lld nanos, currently %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700746 (long long) entryTimeNanos, (long long) currentTimeNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700747 ALOGW("processData(): TIMEOUT after %lld nanos",
Phil Burkc0c70e32017-02-09 13:18:38 -0800748 (long long) timeoutNanoseconds);
Phil Burkfbf031e2017-10-12 15:58:31 -0700749 ALOGW("processData(): wakeTime = %lld, deadline = %lld nanos",
Phil Burk87c9f642017-05-17 07:22:39 -0700750 (long long) wakeTimeNanos, (long long) deadlineNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700751 ALOGW("processData(): past deadline by %d micros",
Phil Burk87c9f642017-05-17 07:22:39 -0700752 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
Phil Burkec89b2e2017-06-20 15:05:06 -0700753 mClockModel.dump();
Phil Burk5edc4ea2020-04-17 08:15:42 -0700754 mAudioEndpoint->dump();
Phil Burk204a1632017-01-03 17:23:43 -0800755 break;
756 }
757
Phil Burkfd34a932017-07-19 07:03:52 -0700758 if (ATRACE_ENABLED()) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700759 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
Phil Burkfd34a932017-07-19 07:03:52 -0700760 ATRACE_INT(fifoName, fullFrames);
761 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
762 ATRACE_INT("aaSlpNs", (int32_t)sleepForNanos);
763 }
764
765 AudioClock::sleepUntilNanoTime(wakeTimeNanos);
Phil Burk204a1632017-01-03 17:23:43 -0800766 currentTimeNanos = AudioClock::getNanoseconds();
767 }
768 }
769
Phil Burkfd34a932017-07-19 07:03:52 -0700770 if (ATRACE_ENABLED()) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700771 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
Phil Burkfd34a932017-07-19 07:03:52 -0700772 ATRACE_INT(fifoName, fullFrames);
773 }
774
Phil Burk87c9f642017-05-17 07:22:39 -0700775 // return error or framesProcessed
Phil Burkc0c70e32017-02-09 13:18:38 -0800776 (void) loopCount;
Phil Burk4485d412017-05-09 15:55:02 -0700777 ATRACE_END();
Phil Burk204a1632017-01-03 17:23:43 -0800778 return (result < 0) ? result : numFrames - framesLeft;
779}
780
Phil Burk3316d5e2017-02-15 11:23:01 -0800781void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
Phil Burk87c9f642017-05-17 07:22:39 -0700782 mClockModel.processTimestamp(position, time);
Phil Burk204a1632017-01-03 17:23:43 -0800783}
784
Phil Burk3316d5e2017-02-15 11:23:01 -0800785aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
Phil Burk6479d502017-11-20 09:32:52 -0800786 int32_t adjustedFrames = requestedFrames;
Phil Burk8d97b8e2020-09-25 23:18:14 +0000787 const int32_t maximumSize = getBufferCapacity() - getFramesPerBurst();
Phil Burk5347dca2020-04-08 16:31:07 -0700788 // Minimum size should be a multiple number of bursts.
Phil Burk8d97b8e2020-09-25 23:18:14 +0000789 const int32_t minimumSize = 1 * getFramesPerBurst();
Phil Burk6479d502017-11-20 09:32:52 -0800790
791 // Clip to minimum size so that rounding up will work better.
Phil Burk8d4f0062019-10-03 15:55:41 -0700792 adjustedFrames = std::max(minimumSize, adjustedFrames);
Phil Burk71f35bb2017-04-13 16:05:07 -0700793
Phil Burk8d4f0062019-10-03 15:55:41 -0700794 // Prevent arithmetic overflow by clipping before we round.
795 if (adjustedFrames >= maximumSize) {
Phil Burk6479d502017-11-20 09:32:52 -0800796 adjustedFrames = maximumSize;
797 } else {
798 // Round to the next highest burst size.
Phil Burk8d97b8e2020-09-25 23:18:14 +0000799 int32_t numBursts = (adjustedFrames + getFramesPerBurst() - 1) / getFramesPerBurst();
800 adjustedFrames = numBursts * getFramesPerBurst();
801 // Clip just in case maximumSize is not a multiple of getFramesPerBurst().
Phil Burk5347dca2020-04-08 16:31:07 -0700802 adjustedFrames = std::min(maximumSize, adjustedFrames);
Phil Burk6479d502017-11-20 09:32:52 -0800803 }
804
Phil Burk5edc4ea2020-04-17 08:15:42 -0700805 if (mAudioEndpoint) {
806 // Clip against the actual size from the endpoint.
807 int32_t actualFrames = 0;
808 // Set to maximum size so we can write extra data when ready in order to reduce glitches.
809 // The amount we keep in the buffer is controlled by mBufferSizeInFrames.
810 mAudioEndpoint->setBufferSizeInFrames(maximumSize, &actualFrames);
811 // actualFrames should be <= actual maximum size of endpoint
812 adjustedFrames = std::min(actualFrames, adjustedFrames);
813 }
Phil Burk8d4f0062019-10-03 15:55:41 -0700814
Phil Burk64e16a72020-06-01 13:25:51 -0700815 if (adjustedFrames != mBufferSizeInFrames) {
816 android::mediametrics::LogItem(mMetricsId)
817 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETBUFFERSIZE)
818 .set(AMEDIAMETRICS_PROP_BUFFERSIZEFRAMES, adjustedFrames)
819 .set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t) getXRunCount())
820 .record();
821 }
822
Phil Burk8d4f0062019-10-03 15:55:41 -0700823 mBufferSizeInFrames = adjustedFrames;
Phil Burk6c63ae32019-10-28 10:28:21 -0700824 ALOGV("%s(%d) returns %d", __func__, requestedFrames, adjustedFrames);
Phil Burk8d4f0062019-10-03 15:55:41 -0700825 return (aaudio_result_t) adjustedFrames;
Phil Burk204a1632017-01-03 17:23:43 -0800826}
827
Phil Burk87c9f642017-05-17 07:22:39 -0700828int32_t AudioStreamInternal::getBufferSize() const {
Phil Burk8d4f0062019-10-03 15:55:41 -0700829 return mBufferSizeInFrames;
Phil Burk204a1632017-01-03 17:23:43 -0800830}
831
Phil Burk87c9f642017-05-17 07:22:39 -0700832int32_t AudioStreamInternal::getBufferCapacity() const {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700833 return mBufferCapacityInFrames;
Phil Burk204a1632017-01-03 17:23:43 -0800834}
835
Phil Burk377c1c22018-12-12 16:06:54 -0800836bool AudioStreamInternal::isClockModelInControl() const {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700837 return isActive() && mAudioEndpoint->isFreeRunning() && mClockModel.isRunning();
Phil Burk377c1c22018-12-12 16:06:54 -0800838}