blob: 9b1ad72f3a99d7631acd1315c9c339c634ccb9ba [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
Robert Wud7400832021-12-04 01:11:19 +000030#include <media/AudioParameter.h>
jiabine504e7b2021-09-18 00:27:08 +000031#include <media/AudioSystem.h>
Phil Burka9876702020-04-20 18:16:15 -070032#include <media/MediaMetricsItem.h>
Phil Burk4485d412017-05-09 15:55:02 -070033#include <utils/Trace.h>
Phil Burk204a1632017-01-03 17:23:43 -080034
Phil Burkc0c70e32017-02-09 13:18:38 -080035#include "AudioEndpointParcelable.h"
jiabin5f787812023-03-02 20:42:43 +000036#include "binding/AAudioBinderClient.h"
Phil Burkc0c70e32017-02-09 13:18:38 -080037#include "binding/AAudioStreamRequest.h"
38#include "binding/AAudioStreamConfiguration.h"
Phil Burk5ed503c2017-02-01 09:38:15 -080039#include "binding/AAudioServiceMessage.h"
Phil Burka9876702020-04-20 18:16:15 -070040#include "core/AudioGlobal.h"
Phil Burk3df348f2017-02-08 11:41:55 -080041#include "core/AudioStreamBuilder.h"
Phil Burke572f462017-04-20 13:03:19 -070042#include "fifo/FifoBuffer.h"
Phil Burkfd34a932017-07-19 07:03:52 -070043#include "utility/AudioClock.h"
Philip P. Moltmannbda45752020-07-17 16:41:18 -070044#include <media/AidlConversion.h>
Phil Burke572f462017-04-20 13:03:19 -070045
Phil Burkc0c70e32017-02-09 13:18:38 -080046#include "AudioStreamInternal.h"
Phil Burk204a1632017-01-03 17:23:43 -080047
Phil Burka9876702020-04-20 18:16:15 -070048// We do this after the #includes because if a header uses ALOG.
49// it would fail on the reference to mInService.
50#undef LOG_TAG
51// This file is used in both client and server processes.
52// This is needed to make sense of the logs more easily.
53#define LOG_TAG (mInService ? "AudioStreamInternal_Service" : "AudioStreamInternal_Client")
54
Svet Ganov3e5f14f2021-05-13 22:51:08 +000055using android::content::AttributionSourceState;
Phil Burk204a1632017-01-03 17:23:43 -080056
Phil Burk5ed503c2017-02-01 09:38:15 -080057using namespace aaudio;
Phil Burk204a1632017-01-03 17:23:43 -080058
Phil Burke4d7bb42017-03-28 11:32:39 -070059#define MIN_TIMEOUT_NANOS (1000 * AAUDIO_NANOS_PER_MILLISECOND)
60
61// Wait at least this many times longer than the operation should take.
62#define MIN_TIMEOUT_OPERATIONS 4
63
Phil Burkbcc36742017-08-31 17:24:51 -070064#define LOG_TIMESTAMPS 0
Phil Burk87c9f642017-05-17 07:22:39 -070065
Robert Wud559ba52023-06-29 00:08:51 +000066#define ENABLE_SAMPLE_RATE_CONVERTER 1
67
Phil Burkc0c70e32017-02-09 13:18:38 -080068AudioStreamInternal::AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService)
Phil Burk204a1632017-01-03 17:23:43 -080069 : AudioStream()
70 , mClockModel()
Phil Burkec89b2e2017-06-20 15:05:06 -070071 , mInService(inService)
Phil Burkfd34a932017-07-19 07:03:52 -070072 , mServiceInterface(serviceInterface)
Phil Burka53ffa62018-10-10 16:21:37 -070073 , mAtomicInternalTimestamp()
Phil Burkfd34a932017-07-19 07:03:52 -070074 , mWakeupDelayNanos(AAudioProperty_getWakeupDelayMicros() * AAUDIO_NANOS_PER_MICROSECOND)
75 , mMinimumSleepNanos(AAudioProperty_getMinimumSleepMicros() * AAUDIO_NANOS_PER_MICROSECOND)
76 {
jiabin5f787812023-03-02 20:42:43 +000077
Phil Burk204a1632017-01-03 17:23:43 -080078}
79
80AudioStreamInternal::~AudioStreamInternal() {
Phil Burkdd582922020-10-15 20:29:51 +000081 ALOGD("%s() %p called", __func__, this);
Phil Burk204a1632017-01-03 17:23:43 -080082}
83
Phil Burk5ed503c2017-02-01 09:38:15 -080084aaudio_result_t AudioStreamInternal::open(const AudioStreamBuilder &builder) {
Phil Burk204a1632017-01-03 17:23:43 -080085
Phil Burk5ed503c2017-02-01 09:38:15 -080086 aaudio_result_t result = AAUDIO_OK;
87 AAudioStreamRequest request;
Phil Burk99306c82017-08-14 12:38:58 -070088 AAudioStreamConfiguration configurationOutput;
Phil Burk204a1632017-01-03 17:23:43 -080089
Phil Burk99306c82017-08-14 12:38:58 -070090 if (getState() != AAUDIO_STREAM_STATE_UNINITIALIZED) {
Phil Burkfbf031e2017-10-12 15:58:31 -070091 ALOGE("%s - already open! state = %d", __func__, getState());
Phil Burk99306c82017-08-14 12:38:58 -070092 return AAUDIO_ERROR_INVALID_STATE;
93 }
94
95 // Copy requested parameters to the stream.
Phil Burk204a1632017-01-03 17:23:43 -080096 result = AudioStream::open(builder);
97 if (result < 0) {
98 return result;
99 }
100
jiabinef348b82021-04-19 16:53:08 +0000101 const audio_format_t requestedFormat = getFormat();
Phil Burkc0c70e32017-02-09 13:18:38 -0800102 // We have to do volume scaling. So we prefer FLOAT format.
jiabinef348b82021-04-19 16:53:08 +0000103 if (requestedFormat == AUDIO_FORMAT_DEFAULT) {
Phil Burk0127c1b2018-03-29 13:48:06 -0700104 setFormat(AUDIO_FORMAT_PCM_FLOAT);
Phil Burkc0c70e32017-02-09 13:18:38 -0800105 }
Phil Burk04e805b2018-03-27 09:13:53 -0700106 // Request FLOAT for the shared mixer or the device.
Phil Burk0127c1b2018-03-29 13:48:06 -0700107 request.getConfiguration().setFormat(AUDIO_FORMAT_PCM_FLOAT);
Phil Burkc0c70e32017-02-09 13:18:38 -0800108
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000109 // TODO b/182392769: use attribution source util
110 AttributionSourceState attributionSource;
111 attributionSource.uid = VALUE_OR_FATAL(android::legacy2aidl_uid_t_int32_t(getuid()));
112 attributionSource.pid = VALUE_OR_FATAL(android::legacy2aidl_pid_t_int32_t(getpid()));
113 attributionSource.packageName = builder.getOpPackageName();
114 attributionSource.attributionTag = builder.getAttributionTag();
115 attributionSource.token = sp<android::BBinder>::make();
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700116
Phil Burkdec33ab2017-01-17 14:48:16 -0800117 // Build the request to send to the server.
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000118 request.setAttributionSource(attributionSource);
Phil Burk71f35bb2017-04-13 16:05:07 -0700119 request.setSharingModeMatchRequired(isSharingModeMatchRequired());
Phil Burk41f19d82018-02-13 14:59:10 -0800120 request.setInService(isInService());
Phil Burkc0c70e32017-02-09 13:18:38 -0800121
Phil Burk204a1632017-01-03 17:23:43 -0800122 request.getConfiguration().setDeviceId(getDeviceId());
123 request.getConfiguration().setSampleRate(getSampleRate());
Phil Burk39f02dd2017-08-04 09:13:31 -0700124 request.getConfiguration().setDirection(getDirection());
Phil Burk71f35bb2017-04-13 16:05:07 -0700125 request.getConfiguration().setSharingMode(getSharingMode());
jiabina9094092021-06-28 20:36:45 +0000126 request.getConfiguration().setChannelMask(getChannelMask());
Phil Burk71f35bb2017-04-13 16:05:07 -0700127
Phil Burka62fb952018-01-16 12:44:06 -0800128 request.getConfiguration().setUsage(getUsage());
129 request.getConfiguration().setContentType(getContentType());
Jean-Michel Trivi656bfdc2021-09-20 18:42:37 -0700130 request.getConfiguration().setSpatializationBehavior(getSpatializationBehavior());
131 request.getConfiguration().setIsContentSpatialized(isContentSpatialized());
Phil Burka62fb952018-01-16 12:44:06 -0800132 request.getConfiguration().setInputPreset(getInputPreset());
Eric Laurentd17c8502019-10-24 15:58:35 -0700133 request.getConfiguration().setPrivacySensitive(isPrivacySensitive());
Phil Burka62fb952018-01-16 12:44:06 -0800134
Phil Burk3df348f2017-02-08 11:41:55 -0800135 request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
Phil Burk204a1632017-01-03 17:23:43 -0800136
jiabin5f787812023-03-02 20:42:43 +0000137 mServiceStreamHandleInfo = mServiceInterface.openStream(request, configurationOutput);
138 if (getServiceHandle() < 0
jiabina9094092021-06-28 20:36:45 +0000139 && (request.getConfiguration().getSamplesPerFrame() == 1
140 || request.getConfiguration().getChannelMask() == AAUDIO_CHANNEL_MONO)
Phil Burk41f19d82018-02-13 14:59:10 -0800141 && getDirection() == AAUDIO_DIRECTION_OUTPUT
142 && !isInService()) {
143 // if that failed then try switching from mono to stereo if OUTPUT.
144 // Only do this in the client. Otherwise we end up with a mono mixer in the service
145 // that writes to a stereo MMAP stream.
Phil Burk0127c1b2018-03-29 13:48:06 -0700146 ALOGD("%s() - openStream() returned %d, try switching from MONO to STEREO",
jiabin5f787812023-03-02 20:42:43 +0000147 __func__, getServiceHandle());
jiabina9094092021-06-28 20:36:45 +0000148 request.getConfiguration().setChannelMask(AAUDIO_CHANNEL_STEREO);
jiabin5f787812023-03-02 20:42:43 +0000149 mServiceStreamHandleInfo = mServiceInterface.openStream(request, configurationOutput);
Phil Burk41f19d82018-02-13 14:59:10 -0800150 }
jiabin5f787812023-03-02 20:42:43 +0000151 if (getServiceHandle() < 0) {
152 return getServiceHandle();
Phil Burk204a1632017-01-03 17:23:43 -0800153 }
Phil Burk99306c82017-08-14 12:38:58 -0700154
Phil Burka9876702020-04-20 18:16:15 -0700155 // This must match the key generated in oboeservice/AAudioServiceStreamBase.cpp
156 // so the client can have permission to log.
jiabinfbf20302021-07-28 22:15:01 +0000157 if (!mInService) {
158 // No need to log if it is from service side.
159 mMetricsId = std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_STREAM)
jiabin5f787812023-03-02 20:42:43 +0000160 + std::to_string(getServiceHandle());
jiabinfbf20302021-07-28 22:15:01 +0000161 }
Phil Burka9876702020-04-20 18:16:15 -0700162
jiabinef348b82021-04-19 16:53:08 +0000163 android::mediametrics::LogItem(mMetricsId)
164 .set(AMEDIAMETRICS_PROP_PERFORMANCEMODE,
jiabinc8da9032021-04-28 20:42:36 +0000165 AudioGlobal_convertPerformanceModeToText(builder.getPerformanceMode()))
166 .set(AMEDIAMETRICS_PROP_SHARINGMODE,
167 AudioGlobal_convertSharingModeToText(builder.getSharingMode()))
jiabinef348b82021-04-19 16:53:08 +0000168 .set(AMEDIAMETRICS_PROP_ENCODINGCLIENT,
169 android::toString(requestedFormat).c_str()).record();
170
Phil Burk99306c82017-08-14 12:38:58 -0700171 result = configurationOutput.validate();
172 if (result != AAUDIO_OK) {
173 goto error;
174 }
175 // Save results of the open.
jiabina9094092021-06-28 20:36:45 +0000176 if (getChannelMask() == AAUDIO_UNSPECIFIED) {
177 setChannelMask(configurationOutput.getChannelMask());
Phil Burk41f19d82018-02-13 14:59:10 -0800178 }
jiabina9094092021-06-28 20:36:45 +0000179
Phil Burk99306c82017-08-14 12:38:58 -0700180 setDeviceId(configurationOutput.getDeviceId());
Phil Burk4e1af9f2018-01-03 15:54:35 -0800181 setSessionId(configurationOutput.getSessionId());
Phil Burk99306c82017-08-14 12:38:58 -0700182 setSharingMode(configurationOutput.getSharingMode());
183
Phil Burka62fb952018-01-16 12:44:06 -0800184 setUsage(configurationOutput.getUsage());
185 setContentType(configurationOutput.getContentType());
Jean-Michel Trivi656bfdc2021-09-20 18:42:37 -0700186 setSpatializationBehavior(configurationOutput.getSpatializationBehavior());
187 setIsContentSpatialized(configurationOutput.isContentSpatialized());
Phil Burka62fb952018-01-16 12:44:06 -0800188 setInputPreset(configurationOutput.getInputPreset());
189
Robert Wud559ba52023-06-29 00:08:51 +0000190 setDeviceSampleRate(configurationOutput.getSampleRate());
191
192 if (getSampleRate() == AAUDIO_UNSPECIFIED) {
193 setSampleRate(configurationOutput.getSampleRate());
194 }
195
196#if !ENABLE_SAMPLE_RATE_CONVERTER
197 if (getSampleRate() != getDeviceSampleRate()) {
198 goto error;
199 }
200#endif
201
Phil Burk99306c82017-08-14 12:38:58 -0700202 // Save device format so we can do format conversion and volume scaling together.
Phil Burk3d786cb2018-04-09 11:58:09 -0700203 setDeviceFormat(configurationOutput.getFormat());
Robert Wue8b58962023-07-21 19:48:56 +0000204 setDeviceSamplesPerFrame(configurationOutput.getSamplesPerFrame());
Phil Burk99306c82017-08-14 12:38:58 -0700205
Robert Wu310037a2022-09-06 21:48:18 +0000206 setHardwareSamplesPerFrame(configurationOutput.getHardwareSamplesPerFrame());
207 setHardwareSampleRate(configurationOutput.getHardwareSampleRate());
208 setHardwareFormat(configurationOutput.getHardwareFormat());
209
jiabin5f787812023-03-02 20:42:43 +0000210 result = mServiceInterface.getStreamDescription(mServiceStreamHandleInfo, mEndPointParcelable);
Phil Burk99306c82017-08-14 12:38:58 -0700211 if (result != AAUDIO_OK) {
212 goto error;
213 }
214
215 // Resolve parcelable into a descriptor.
216 result = mEndPointParcelable.resolve(&mEndpointDescriptor);
217 if (result != AAUDIO_OK) {
218 goto error;
219 }
220
221 // Configure endpoint based on descriptor.
Phil Burk5edc4ea2020-04-17 08:15:42 -0700222 mAudioEndpoint = std::make_unique<AudioEndpoint>();
223 result = mAudioEndpoint->configure(&mEndpointDescriptor, getDirection());
Phil Burk99306c82017-08-14 12:38:58 -0700224 if (result != AAUDIO_OK) {
225 goto error;
226 }
227
jiabinf7f06152021-11-22 18:10:14 +0000228 if ((result = configureDataInformation(builder.getFramesPerDataCallback())) != AAUDIO_OK) {
229 goto error;
230 }
231
232 setState(AAUDIO_STREAM_STATE_OPEN);
233
234 return result;
235
236error:
237 safeReleaseClose();
238 return result;
239}
240
241aaudio_result_t AudioStreamInternal::configureDataInformation(int32_t callbackFrames) {
Robert Wud559ba52023-06-29 00:08:51 +0000242 int32_t deviceFramesPerBurst = mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
Phil Burk3c4e6b52019-01-22 15:53:36 -0800243
244 // Scale up the burst size to meet the minimum equivalent in microseconds.
245 // This is to avoid waking the CPU too often when the HW burst is very small
Robert Wud559ba52023-06-29 00:08:51 +0000246 // or at high sample rates. The actual number of frames that we call back to
247 // the app with will be 0 < N <= framesPerBurst so round up the division.
248 int32_t framesPerBurst = (static_cast<int64_t>(deviceFramesPerBurst) * getSampleRate() +
249 getDeviceSampleRate() - 1) / getDeviceSampleRate();
jiabinf7f06152021-11-22 18:10:14 +0000250 int32_t burstMicros = 0;
251 const int32_t burstMinMicros = android::AudioSystem::getAAudioHardwareBurstMinUsec();
Phil Burk3c4e6b52019-01-22 15:53:36 -0800252 do {
253 if (burstMicros > 0) { // skip first loop
Robert Wud559ba52023-06-29 00:08:51 +0000254 deviceFramesPerBurst *= 2;
Phil Burk3c4e6b52019-01-22 15:53:36 -0800255 framesPerBurst *= 2;
256 }
257 burstMicros = framesPerBurst * static_cast<int64_t>(1000000) / getSampleRate();
258 } while (burstMicros < burstMinMicros);
259 ALOGD("%s() original HW burst = %d, minMicros = %d => SW burst = %d\n",
Robert Wud559ba52023-06-29 00:08:51 +0000260 __func__, deviceFramesPerBurst, burstMinMicros, framesPerBurst);
Phil Burk3c4e6b52019-01-22 15:53:36 -0800261
262 // Validate final burst size.
Phil Burk6479d502017-11-20 09:32:52 -0800263 if (framesPerBurst < MIN_FRAMES_PER_BURST || framesPerBurst > MAX_FRAMES_PER_BURST) {
264 ALOGE("%s - framesPerBurst out of range = %d", __func__, framesPerBurst);
jiabinf7f06152021-11-22 18:10:14 +0000265 return AAUDIO_ERROR_OUT_OF_RANGE;
Phil Burk99306c82017-08-14 12:38:58 -0700266 }
Robert Wud559ba52023-06-29 00:08:51 +0000267 setDeviceFramesPerBurst(deviceFramesPerBurst);
Phil Burk8d97b8e2020-09-25 23:18:14 +0000268 setFramesPerBurst(framesPerBurst); // only save good value
Phil Burk6479d502017-11-20 09:32:52 -0800269
Robert Wud559ba52023-06-29 00:08:51 +0000270 mDeviceBufferCapacityInFrames = mEndpointDescriptor.dataQueueDescriptor.capacityInFrames;
271
272 mBufferCapacityInFrames = static_cast<int64_t>(mDeviceBufferCapacityInFrames)
273 * getSampleRate() / getDeviceSampleRate();
Phil Burk8d97b8e2020-09-25 23:18:14 +0000274 if (mBufferCapacityInFrames < getFramesPerBurst()
Phil Burk5edc4ea2020-04-17 08:15:42 -0700275 || mBufferCapacityInFrames > MAX_BUFFER_CAPACITY_IN_FRAMES) {
276 ALOGE("%s - bufferCapacity out of range = %d", __func__, mBufferCapacityInFrames);
jiabinf7f06152021-11-22 18:10:14 +0000277 return AAUDIO_ERROR_OUT_OF_RANGE;
Phil Burk99306c82017-08-14 12:38:58 -0700278 }
279
Robert Wud559ba52023-06-29 00:08:51 +0000280 mClockModel.setSampleRate(getDeviceSampleRate());
281 mClockModel.setFramesPerBurst(deviceFramesPerBurst);
Phil Burk99306c82017-08-14 12:38:58 -0700282
Phil Burk134f1972017-12-08 13:06:11 -0800283 if (isDataCallbackSet()) {
jiabinf7f06152021-11-22 18:10:14 +0000284 mCallbackFrames = callbackFrames;
Phil Burk99306c82017-08-14 12:38:58 -0700285 if (mCallbackFrames > getBufferCapacity() / 2) {
Phil Burk29ccc292019-04-15 08:58:08 -0700286 ALOGW("%s - framesPerCallback too big = %d, capacity = %d",
Phil Burkfbf031e2017-10-12 15:58:31 -0700287 __func__, mCallbackFrames, getBufferCapacity());
jiabinf7f06152021-11-22 18:10:14 +0000288 return AAUDIO_ERROR_OUT_OF_RANGE;
Phil Burk99306c82017-08-14 12:38:58 -0700289 } else if (mCallbackFrames < 0) {
Phil Burk29ccc292019-04-15 08:58:08 -0700290 ALOGW("%s - framesPerCallback negative", __func__);
jiabinf7f06152021-11-22 18:10:14 +0000291 return AAUDIO_ERROR_OUT_OF_RANGE;
Phil Burk99306c82017-08-14 12:38:58 -0700292 }
293 if (mCallbackFrames == AAUDIO_UNSPECIFIED) {
Phil Burk8d97b8e2020-09-25 23:18:14 +0000294 mCallbackFrames = getFramesPerBurst();
Phil Burk99306c82017-08-14 12:38:58 -0700295 }
296
Phil Burk0127c1b2018-03-29 13:48:06 -0700297 const int32_t callbackBufferSize = mCallbackFrames * getBytesPerFrame();
Phil Burkbf821e22020-04-17 11:51:43 -0700298 mCallbackBuffer = std::make_unique<uint8_t[]>(callbackBufferSize);
Phil Burk99306c82017-08-14 12:38:58 -0700299 }
300
Robert Wud7400832021-12-04 01:11:19 +0000301 // Exclusive output streams should combine channels when mono audio adjustment
Robert Wu8393bed2021-12-08 02:08:48 +0000302 // is enabled. They should also adjust for audio balance.
Robert Wud7400832021-12-04 01:11:19 +0000303 if ((getDirection() == AAUDIO_DIRECTION_OUTPUT) &&
304 (getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE)) {
305 bool isMasterMono = false;
306 android::AudioSystem::getMasterMono(&isMasterMono);
307 setRequireMonoBlend(isMasterMono);
Robert Wu8393bed2021-12-08 02:08:48 +0000308 float audioBalance = 0;
309 android::AudioSystem::getMasterBalance(&audioBalance);
310 setAudioBalance(audioBalance);
Robert Wud7400832021-12-04 01:11:19 +0000311 }
312
Phil Burkb31b66f2019-09-30 09:33:41 -0700313 // For debugging and analyzing the distribution of MMAP timestamps.
314 // For OUTPUT, use a NEGATIVE offset to move the CPU writes further BEFORE the HW reads.
315 // For INPUT, use a POSITIVE offset to move the CPU reads further AFTER the HW writes.
316 // You can use this offset to reduce glitching.
317 // You can also use this offset to force glitching. By iterating over multiple
318 // values you can reveal the distribution of the hardware timing jitter.
Phil Burk5edc4ea2020-04-17 08:15:42 -0700319 if (mAudioEndpoint->isFreeRunning()) { // MMAP?
Phil Burkb31b66f2019-09-30 09:33:41 -0700320 int32_t offsetMicros = (getDirection() == AAUDIO_DIRECTION_OUTPUT)
321 ? AAudioProperty_getOutputMMapOffsetMicros()
322 : AAudioProperty_getInputMMapOffsetMicros();
323 // This log is used to debug some tricky glitch issues. Please leave.
324 ALOGD_IF(offsetMicros, "%s() - %s mmap offset = %d micros",
325 __func__,
326 (getDirection() == AAUDIO_DIRECTION_OUTPUT) ? "output" : "input",
327 offsetMicros);
328 mTimeOffsetNanos = offsetMicros * AAUDIO_NANOS_PER_MICROSECOND;
329 }
330
Robert Wud559ba52023-06-29 00:08:51 +0000331 // Default buffer size to match Q
332 setBufferSize(mBufferCapacityInFrames / 2);
jiabinf7f06152021-11-22 18:10:14 +0000333 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800334}
335
Phil Burk13d3d832019-06-10 14:36:48 -0700336// This must be called under mStreamLock.
Phil Burk8b4e05e2019-12-17 12:12:09 -0800337aaudio_result_t AudioStreamInternal::release_l() {
Phil Burk965650e2017-09-07 21:00:09 -0700338 aaudio_result_t result = AAUDIO_OK;
jiabin5f787812023-03-02 20:42:43 +0000339 ALOGD("%s(): mServiceStreamHandle = 0x%08X", __func__, getServiceHandle());
340 if (getServiceHandle() != AAUDIO_HANDLE_INVALID) {
Phil Burk8b4e05e2019-12-17 12:12:09 -0800341 // Don't release a stream while it is running. Stop it first.
Phil Burk13d3d832019-06-10 14:36:48 -0700342 // If DISCONNECTED then we should still try to stop in case the
343 // error callback is still running.
jiabincb212cd2022-08-24 16:50:44 -0700344 if (isActive() || isDisconnected()) {
Phil Burkdd582922020-10-15 20:29:51 +0000345 requestStop_l();
Phil Burk4485d412017-05-09 15:55:02 -0700346 }
Phil Burka9876702020-04-20 18:16:15 -0700347
Phil Burk64e16a72020-06-01 13:25:51 -0700348 logReleaseBufferState();
Phil Burka9876702020-04-20 18:16:15 -0700349
Phil Burkec89b2e2017-06-20 15:05:06 -0700350 setState(AAUDIO_STREAM_STATE_CLOSING);
jiabin5f787812023-03-02 20:42:43 +0000351 auto serviceStreamHandleInfo = mServiceStreamHandleInfo;
352 mServiceStreamHandleInfo = AAudioHandleInfo();
Phil Burkc0c70e32017-02-09 13:18:38 -0800353
jiabin5f787812023-03-02 20:42:43 +0000354 mServiceInterface.closeStream(serviceStreamHandleInfo);
Phil Burkbf821e22020-04-17 11:51:43 -0700355 mCallbackBuffer.reset();
Phil Burk5edc4ea2020-04-17 08:15:42 -0700356
357 // Update local frame counters so we can query them after releasing the endpoint.
358 getFramesRead();
359 getFramesWritten();
360 mAudioEndpoint.reset();
Phil Burk965650e2017-09-07 21:00:09 -0700361 result = mEndPointParcelable.close();
Phil Burk8b4e05e2019-12-17 12:12:09 -0800362 aaudio_result_t result2 = AudioStream::release_l();
Phil Burk965650e2017-09-07 21:00:09 -0700363 return (result != AAUDIO_OK) ? result : result2;
Phil Burk204a1632017-01-03 17:23:43 -0800364 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800365 return AAUDIO_ERROR_INVALID_HANDLE;
Phil Burk204a1632017-01-03 17:23:43 -0800366 }
367}
368
Phil Burke4d7bb42017-03-28 11:32:39 -0700369static void *aaudio_callback_thread_proc(void *context)
370{
371 AudioStreamInternal *stream = (AudioStreamInternal *)context;
Phil Burkfbf031e2017-10-12 15:58:31 -0700372 //LOGD("oboe_callback_thread, stream = %p", stream);
jiabind5bd06a2021-04-27 22:04:08 +0000373 if (stream != nullptr) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700374 return stream->callbackLoop();
375 } else {
jiabind5bd06a2021-04-27 22:04:08 +0000376 return nullptr;
Phil Burke4d7bb42017-03-28 11:32:39 -0700377 }
378}
379
jiabinf7f06152021-11-22 18:10:14 +0000380aaudio_result_t AudioStreamInternal::exitStandby_l() {
381 AudioEndpointParcelable endpointParcelable;
382 // The stream is in standby mode, copy all available data and then close the duplicated
383 // shared file descriptor so that it won't cause issue when the HAL try to reallocate new
384 // shared file descriptor when exiting from standby.
385 // Cache current read counter, which will be reset to new read and write counter
386 // when the new data queue and endpoint are reconfigured.
387 const android::fifo_counter_t readCounter = mAudioEndpoint->getDataReadCounter();
388 // Cache the buffer size which may be from client.
389 const int32_t previousBufferSize = mBufferSizeInFrames;
390 // Copy all available data from current data queue.
Robert Wud559ba52023-06-29 00:08:51 +0000391 uint8_t buffer[getDeviceBufferCapacity() * getBytesPerFrame()];
392 android::fifo_frames_t fullFramesAvailable = mAudioEndpoint->read(buffer,
393 getDeviceBufferCapacity());
jiabinf7f06152021-11-22 18:10:14 +0000394 mEndPointParcelable.closeDataFileDescriptor();
395 aaudio_result_t result = mServiceInterface.exitStandby(
jiabin5f787812023-03-02 20:42:43 +0000396 mServiceStreamHandleInfo, endpointParcelable);
jiabinf7f06152021-11-22 18:10:14 +0000397 if (result != AAUDIO_OK) {
398 ALOGE("Failed to exit standby, error=%d", result);
399 goto exit;
400 }
401 // Reconstruct data queue descriptor using new shared file descriptor.
jiabinfc791ee2023-02-15 19:43:40 +0000402 result = mEndPointParcelable.updateDataFileDescriptor(&endpointParcelable);
403 if (result != AAUDIO_OK) {
404 ALOGE("%s failed to update data file descriptor, error=%d", __func__, result);
405 goto exit;
406 }
jiabinf7f06152021-11-22 18:10:14 +0000407 result = mEndPointParcelable.resolveDataQueue(&mEndpointDescriptor.dataQueueDescriptor);
408 if (result != AAUDIO_OK) {
409 ALOGE("Failed to resolve data queue after exiting standby, error=%d", result);
410 goto exit;
411 }
412 // Reconfigure audio endpoint with new data queue descriptor.
413 mAudioEndpoint->configureDataQueue(
414 mEndpointDescriptor.dataQueueDescriptor, getDirection());
415 // Set read and write counters with previous read counter, the later write action
416 // will make the counter at the correct place.
417 mAudioEndpoint->setDataReadCounter(readCounter);
418 mAudioEndpoint->setDataWriteCounter(readCounter);
419 result = configureDataInformation(mCallbackFrames);
420 if (result != AAUDIO_OK) {
421 ALOGE("Failed to configure data information after exiting standby, error=%d", result);
422 goto exit;
423 }
424 // Write data from previous data buffer to new endpoint.
Robert Wud559ba52023-06-29 00:08:51 +0000425 if (const android::fifo_frames_t framesWritten =
jiabinf7f06152021-11-22 18:10:14 +0000426 mAudioEndpoint->write(buffer, fullFramesAvailable);
427 framesWritten != fullFramesAvailable) {
428 ALOGW("Some data lost after exiting standby, frames written: %d, "
429 "frames to write: %d", framesWritten, fullFramesAvailable);
430 }
431 // Reset previous buffer size as it may be requested by the client.
432 setBufferSize(previousBufferSize);
433
434exit:
435 return result;
436}
437
Phil Burkbcc36742017-08-31 17:24:51 -0700438/*
439 * It normally takes about 20-30 msec to start a stream on the server.
440 * But the first time can take as much as 200-300 msec. The HW
441 * starts right away so by the time the client gets a chance to write into
442 * the buffer, it is already in a deep underflow state. That can cause the
443 * XRunCount to be non-zero, which could lead an app to tune its latency higher.
444 * To avoid this problem, we set a request for the processing code to start the
445 * client stream at the same position as the server stream.
446 * The processing code will then save the current offset
447 * between client and server and apply that to any position given to the app.
448 */
Phil Burkdd582922020-10-15 20:29:51 +0000449aaudio_result_t AudioStreamInternal::requestStart_l()
Phil Burk204a1632017-01-03 17:23:43 -0800450{
Phil Burk3316d5e2017-02-15 11:23:01 -0800451 int64_t startTime;
jiabin5f787812023-03-02 20:42:43 +0000452 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700453 ALOGD("requestStart() mServiceStreamHandle invalid");
Phil Burk5ed503c2017-02-01 09:38:15 -0800454 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800455 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700456 if (isActive()) {
Phil Burk29ccc292019-04-15 08:58:08 -0700457 ALOGD("requestStart() already active");
Phil Burkec89b2e2017-06-20 15:05:06 -0700458 return AAUDIO_ERROR_INVALID_STATE;
459 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700460
jiabincb212cd2022-08-24 16:50:44 -0700461 if (isDisconnected()) {
Phil Burk29ccc292019-04-15 08:58:08 -0700462 ALOGD("requestStart() but DISCONNECTED");
Phil Burkbcc36742017-08-31 17:24:51 -0700463 return AAUDIO_ERROR_DISCONNECTED;
464 }
Robert Wud559ba52023-06-29 00:08:51 +0000465 const aaudio_stream_state_t originalState = getState();
Phil Burkec89b2e2017-06-20 15:05:06 -0700466 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burkbcc36742017-08-31 17:24:51 -0700467
468 // Clear any stale timestamps from the previous run.
469 drainTimestampsFromService();
470
Phil Burkec8ca522020-05-19 10:05:58 -0700471 prepareBuffersForStart(); // tell subclasses to get ready
472
jiabin5f787812023-03-02 20:42:43 +0000473 aaudio_result_t result = mServiceInterface.startStream(mServiceStreamHandleInfo);
jiabinf7f06152021-11-22 18:10:14 +0000474 if (result == AAUDIO_ERROR_STANDBY) {
475 // The stream is at standby mode. Need to exit standby before starting the stream.
476 result = exitStandby_l();
477 if (result == AAUDIO_OK) {
jiabin5f787812023-03-02 20:42:43 +0000478 result = mServiceInterface.startStream(mServiceStreamHandleInfo);
jiabinf7f06152021-11-22 18:10:14 +0000479 }
480 }
481 if (result != AAUDIO_OK) {
482 ALOGD("%s() error = %d, stream was probably stolen", __func__, result);
Phil Burk6e463ce2020-04-13 10:20:20 -0700483 // Stealing was added in R. Coerce result to improve backward compatibility.
484 result = AAUDIO_ERROR_DISCONNECTED;
jiabincb212cd2022-08-24 16:50:44 -0700485 setDisconnected();
Phil Burk6e463ce2020-04-13 10:20:20 -0700486 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800487
Phil Burk3316d5e2017-02-15 11:23:01 -0800488 startTime = AudioClock::getNanoseconds();
Phil Burk204a1632017-01-03 17:23:43 -0800489 mClockModel.start(startTime);
Phil Burkbcc36742017-08-31 17:24:51 -0700490 mNeedCatchUp.request(); // Ask data processing code to catch up when first timestamp received.
Phil Burke4d7bb42017-03-28 11:32:39 -0700491
Phil Burk965650e2017-09-07 21:00:09 -0700492 // Start data callback thread.
Phil Burk134f1972017-12-08 13:06:11 -0800493 if (result == AAUDIO_OK && isDataCallbackSet()) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700494 // Launch the callback loop thread.
495 int64_t periodNanos = mCallbackFrames
496 * AAUDIO_NANOS_PER_SECOND
497 / getSampleRate();
498 mCallbackEnabled.store(true);
Phil Burkdd582922020-10-15 20:29:51 +0000499 result = createThread_l(periodNanos, aaudio_callback_thread_proc, this);
Phil Burke4d7bb42017-03-28 11:32:39 -0700500 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700501 if (result != AAUDIO_OK) {
502 setState(originalState);
503 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700504 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800505}
506
Phil Burke4d7bb42017-03-28 11:32:39 -0700507int64_t AudioStreamInternal::calculateReasonableTimeout(int32_t framesPerOperation) {
508
509 // Wait for at least a second or some number of callbacks to join the thread.
Phil Burk71f35bb2017-04-13 16:05:07 -0700510 int64_t timeoutNanoseconds = (MIN_TIMEOUT_OPERATIONS
511 * framesPerOperation
512 * AAUDIO_NANOS_PER_SECOND)
513 / getSampleRate();
Phil Burke4d7bb42017-03-28 11:32:39 -0700514 if (timeoutNanoseconds < MIN_TIMEOUT_NANOS) { // arbitrary number of seconds
515 timeoutNanoseconds = MIN_TIMEOUT_NANOS;
516 }
517 return timeoutNanoseconds;
518}
519
Phil Burk87c9f642017-05-17 07:22:39 -0700520int64_t AudioStreamInternal::calculateReasonableTimeout() {
521 return calculateReasonableTimeout(getFramesPerBurst());
522}
523
Phil Burk13d3d832019-06-10 14:36:48 -0700524// This must be called under mStreamLock.
Phil Burkdd582922020-10-15 20:29:51 +0000525aaudio_result_t AudioStreamInternal::stopCallback_l()
Phil Burke4d7bb42017-03-28 11:32:39 -0700526{
jiabincb212cd2022-08-24 16:50:44 -0700527 if (isDataCallbackSet() && (isActive() || isDisconnected())) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700528 mCallbackEnabled.store(false);
jiabind5bd06a2021-04-27 22:04:08 +0000529 aaudio_result_t result = joinThread_l(nullptr); // may temporarily unlock mStreamLock
Phil Burk6e463ce2020-04-13 10:20:20 -0700530 if (result == AAUDIO_ERROR_INVALID_HANDLE) {
531 ALOGD("%s() INVALID_HANDLE, stream was probably stolen", __func__);
532 result = AAUDIO_OK;
533 }
534 return result;
Phil Burke4d7bb42017-03-28 11:32:39 -0700535 } else {
Phil Burkdd582922020-10-15 20:29:51 +0000536 ALOGD("%s() skipped, isDataCallbackSet() = %d, isActive() = %d, getState() = %d", __func__,
537 isDataCallbackSet(), isActive(), getState());
Phil Burke4d7bb42017-03-28 11:32:39 -0700538 return AAUDIO_OK;
539 }
540}
541
Phil Burkdd582922020-10-15 20:29:51 +0000542aaudio_result_t AudioStreamInternal::requestStop_l() {
543 aaudio_result_t result = stopCallback_l();
Phil Burk5cc83c32017-11-28 15:43:18 -0800544 if (result != AAUDIO_OK) {
Phil Burkdd582922020-10-15 20:29:51 +0000545 ALOGW("%s() stop callback returned %d, returning early", __func__, result);
Phil Burk5cc83c32017-11-28 15:43:18 -0800546 return result;
547 }
Phil Burk13d3d832019-06-10 14:36:48 -0700548 // The stream may have been unlocked temporarily to let a callback finish
549 // and the callback may have stopped the stream.
550 // Check to make sure the stream still needs to be stopped.
Phil Burk0bd745e2020-10-17 18:20:01 +0000551 // See also AudioStream::safeStop_l().
jiabincb212cd2022-08-24 16:50:44 -0700552 if (!(isActive() || isDisconnected())) {
Phil Burkdd582922020-10-15 20:29:51 +0000553 ALOGD("%s() returning early, not active or disconnected", __func__);
Phil Burk13d3d832019-06-10 14:36:48 -0700554 return AAUDIO_OK;
555 }
Phil Burk5cc83c32017-11-28 15:43:18 -0800556
jiabin5f787812023-03-02 20:42:43 +0000557 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700558 ALOGW("%s() mServiceStreamHandle invalid = 0x%08X",
jiabin5f787812023-03-02 20:42:43 +0000559 __func__, getServiceHandle());
Phil Burk71f35bb2017-04-13 16:05:07 -0700560 return AAUDIO_ERROR_INVALID_STATE;
561 }
562
563 mClockModel.stop(AudioClock::getNanoseconds());
564 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burka53ffa62018-10-10 16:21:37 -0700565 mAtomicInternalTimestamp.clear();
Phil Burk965650e2017-09-07 21:00:09 -0700566
jiabin5f787812023-03-02 20:42:43 +0000567 result = mServiceInterface.stopStream(mServiceStreamHandleInfo);
Phil Burk6e463ce2020-04-13 10:20:20 -0700568 if (result == AAUDIO_ERROR_INVALID_HANDLE) {
569 ALOGD("%s() INVALID_HANDLE, stream was probably stolen", __func__);
570 result = AAUDIO_OK;
571 }
572 return result;
Phil Burk71f35bb2017-04-13 16:05:07 -0700573}
574
Phil Burk5ed503c2017-02-01 09:38:15 -0800575aaudio_result_t AudioStreamInternal::registerThread() {
jiabin5f787812023-03-02 20:42:43 +0000576 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700577 ALOGW("%s() mServiceStreamHandle invalid", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800578 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800579 }
jiabin5f787812023-03-02 20:42:43 +0000580 return mServiceInterface.registerAudioThread(mServiceStreamHandleInfo,
581 gettid(),
582 getPeriodNanoseconds());
Phil Burk204a1632017-01-03 17:23:43 -0800583}
584
Phil Burk5ed503c2017-02-01 09:38:15 -0800585aaudio_result_t AudioStreamInternal::unregisterThread() {
jiabin5f787812023-03-02 20:42:43 +0000586 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
Phil Burk29ccc292019-04-15 08:58:08 -0700587 ALOGW("%s() mServiceStreamHandle invalid", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800588 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800589 }
jiabin5f787812023-03-02 20:42:43 +0000590 return mServiceInterface.unregisterAudioThread(mServiceStreamHandleInfo, gettid());
Phil Burk204a1632017-01-03 17:23:43 -0800591}
592
Eric Laurentcb4dae22017-07-01 19:39:32 -0700593aaudio_result_t AudioStreamInternal::startClient(const android::AudioClient& client,
jiabind1f1cb62020-03-24 11:57:57 -0700594 const audio_attributes_t *attr,
Phil Burkbbd52862018-04-13 11:37:42 -0700595 audio_port_handle_t *portHandle) {
596 ALOGV("%s() called", __func__);
jiabin5f787812023-03-02 20:42:43 +0000597 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
Eric Laurentcb4dae22017-07-01 19:39:32 -0700598 return AAUDIO_ERROR_INVALID_STATE;
599 }
jiabin5f787812023-03-02 20:42:43 +0000600 aaudio_result_t result = mServiceInterface.startClient(mServiceStreamHandleInfo,
jiabind1f1cb62020-03-24 11:57:57 -0700601 client, attr, portHandle);
Phil Burkbbd52862018-04-13 11:37:42 -0700602 ALOGV("%s(%d) returning %d", __func__, *portHandle, result);
603 return result;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700604}
605
Phil Burkbbd52862018-04-13 11:37:42 -0700606aaudio_result_t AudioStreamInternal::stopClient(audio_port_handle_t portHandle) {
607 ALOGV("%s(%d) called", __func__, portHandle);
jiabin5f787812023-03-02 20:42:43 +0000608 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
Eric Laurentcb4dae22017-07-01 19:39:32 -0700609 return AAUDIO_ERROR_INVALID_STATE;
610 }
jiabin5f787812023-03-02 20:42:43 +0000611 aaudio_result_t result = mServiceInterface.stopClient(mServiceStreamHandleInfo, portHandle);
Phil Burkbbd52862018-04-13 11:37:42 -0700612 ALOGV("%s(%d) returning %d", __func__, portHandle, result);
613 return result;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700614}
615
jiabind5bd06a2021-04-27 22:04:08 +0000616aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t /*clockId*/,
Phil Burk3316d5e2017-02-15 11:23:01 -0800617 int64_t *framePosition,
618 int64_t *timeNanoseconds) {
Phil Burk97350f92017-07-21 15:59:44 -0700619 // Generated in server and passed to client. Return latest.
Phil Burka53ffa62018-10-10 16:21:37 -0700620 if (mAtomicInternalTimestamp.isValid()) {
621 Timestamp timestamp = mAtomicInternalTimestamp.read();
Robert Wud559ba52023-06-29 00:08:51 +0000622 // This should not overflow as timestamp.getPosition() should be a position in a buffer and
623 // not the actual timestamp. timestamp.getNanoseconds() below uses the actual timestamp.
624 // At 48000 Hz we can run for over 100 years before overflowing the int64_t.
625 int64_t position = (timestamp.getPosition() + mFramesOffsetFromService) * getSampleRate() /
626 getDeviceSampleRate();
Phil Burkbcc36742017-08-31 17:24:51 -0700627 if (position >= 0) {
628 *framePosition = position;
629 *timeNanoseconds = timestamp.getNanoseconds();
630 return AAUDIO_OK;
631 }
Phil Burk97350f92017-07-21 15:59:44 -0700632 }
Phil Burkc75d97f2017-09-08 15:48:36 -0700633 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800634}
635
Phil Burkec89b2e2017-06-20 15:05:06 -0700636void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
Phil Burk204a1632017-01-03 17:23:43 -0800637 static int64_t oldPosition = 0;
Phil Burk3316d5e2017-02-15 11:23:01 -0800638 static int64_t oldTime = 0;
Phil Burk204a1632017-01-03 17:23:43 -0800639 int64_t framePosition = command.timestamp.position;
Phil Burk3316d5e2017-02-15 11:23:01 -0800640 int64_t nanoTime = command.timestamp.timestamp;
Phil Burkbcc36742017-08-31 17:24:51 -0700641 ALOGD("logTimestamp: timestamp says framePosition = %8lld at nanoTime %lld",
Phil Burk204a1632017-01-03 17:23:43 -0800642 (long long) framePosition,
643 (long long) nanoTime);
644 int64_t nanosDelta = nanoTime - oldTime;
645 if (nanosDelta > 0 && oldTime > 0) {
646 int64_t framesDelta = framePosition - oldPosition;
Phil Burk5ed503c2017-02-01 09:38:15 -0800647 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
Phil Burkbcc36742017-08-31 17:24:51 -0700648 ALOGD("logTimestamp: framesDelta = %8lld, nanosDelta = %8lld, rate = %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700649 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
Phil Burk204a1632017-01-03 17:23:43 -0800650 }
651 oldPosition = framePosition;
652 oldTime = nanoTime;
653}
Phil Burk204a1632017-01-03 17:23:43 -0800654
Phil Burk97350f92017-07-21 15:59:44 -0700655aaudio_result_t AudioStreamInternal::onTimestampService(AAudioServiceMessage *message) {
Phil Burk204a1632017-01-03 17:23:43 -0800656#if LOG_TIMESTAMPS
Phil Burkec89b2e2017-06-20 15:05:06 -0700657 logTimestamp(*message);
Phil Burk204a1632017-01-03 17:23:43 -0800658#endif
Phil Burkb31b66f2019-09-30 09:33:41 -0700659 processTimestamp(message->timestamp.position,
660 message->timestamp.timestamp + mTimeOffsetNanos);
Phil Burk5ed503c2017-02-01 09:38:15 -0800661 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800662}
663
Phil Burk97350f92017-07-21 15:59:44 -0700664aaudio_result_t AudioStreamInternal::onTimestampHardware(AAudioServiceMessage *message) {
665 Timestamp timestamp(message->timestamp.position, message->timestamp.timestamp);
Phil Burka53ffa62018-10-10 16:21:37 -0700666 mAtomicInternalTimestamp.write(timestamp);
Phil Burk97350f92017-07-21 15:59:44 -0700667 return AAUDIO_OK;
668}
669
Phil Burk5ed503c2017-02-01 09:38:15 -0800670aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
671 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800672 switch (message->event.event) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800673 case AAUDIO_SERVICE_EVENT_STARTED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700674 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STARTED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700675 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
676 setState(AAUDIO_STREAM_STATE_STARTED);
677 }
Vlad Popaec1788e2022-08-04 11:23:30 +0200678 mPlayerBase->triggerPortIdUpdate(static_cast<audio_port_handle_t>(
679 message->event.dataLong));
Phil Burk204a1632017-01-03 17:23:43 -0800680 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800681 case AAUDIO_SERVICE_EVENT_PAUSED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700682 ALOGD("%s - got AAUDIO_SERVICE_EVENT_PAUSED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700683 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
684 setState(AAUDIO_STREAM_STATE_PAUSED);
685 }
Phil Burk204a1632017-01-03 17:23:43 -0800686 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700687 case AAUDIO_SERVICE_EVENT_STOPPED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700688 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STOPPED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700689 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
690 setState(AAUDIO_STREAM_STATE_STOPPED);
691 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700692 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800693 case AAUDIO_SERVICE_EVENT_FLUSHED:
Phil Burkfbf031e2017-10-12 15:58:31 -0700694 ALOGD("%s - got AAUDIO_SERVICE_EVENT_FLUSHED", __func__);
Phil Burk87c9f642017-05-17 07:22:39 -0700695 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
696 setState(AAUDIO_STREAM_STATE_FLUSHED);
697 onFlushFromServer();
698 }
Phil Burk204a1632017-01-03 17:23:43 -0800699 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800700 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
Phil Burkea04d972017-08-07 12:30:44 -0700701 // Prevent hardware from looping on old data and making buzzing sounds.
702 if (getDirection() == AAUDIO_DIRECTION_OUTPUT) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700703 mAudioEndpoint->eraseDataMemory();
Phil Burkea04d972017-08-07 12:30:44 -0700704 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800705 result = AAUDIO_ERROR_DISCONNECTED;
jiabincb212cd2022-08-24 16:50:44 -0700706 setDisconnected();
Phil Burkfbf031e2017-10-12 15:58:31 -0700707 ALOGW("%s - AAUDIO_SERVICE_EVENT_DISCONNECTED - FIFO cleared", __func__);
Phil Burk204a1632017-01-03 17:23:43 -0800708 break;
Phil Burkc0c70e32017-02-09 13:18:38 -0800709 case AAUDIO_SERVICE_EVENT_VOLUME:
Phil Burk55e5eab2018-04-10 15:16:38 -0700710 ALOGD("%s - AAUDIO_SERVICE_EVENT_VOLUME %lf", __func__, message->event.dataDouble);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700711 mStreamVolume = (float)message->event.dataDouble;
712 doSetVolume();
Phil Burkc0c70e32017-02-09 13:18:38 -0800713 break;
Phil Burk23296382017-11-20 15:45:11 -0800714 case AAUDIO_SERVICE_EVENT_XRUN:
715 mXRunCount = static_cast<int32_t>(message->event.dataLong);
716 break;
Phil Burk204a1632017-01-03 17:23:43 -0800717 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700718 ALOGE("%s - Unrecognized event = %d", __func__, (int) message->event.event);
Phil Burk204a1632017-01-03 17:23:43 -0800719 break;
720 }
721 return result;
722}
723
Phil Burkbcc36742017-08-31 17:24:51 -0700724aaudio_result_t AudioStreamInternal::drainTimestampsFromService() {
725 aaudio_result_t result = AAUDIO_OK;
726
727 while (result == AAUDIO_OK) {
728 AAudioServiceMessage message;
Phil Burk5edc4ea2020-04-17 08:15:42 -0700729 if (!mAudioEndpoint) {
730 break;
731 }
732 if (mAudioEndpoint->readUpCommand(&message) != 1) {
Phil Burkbcc36742017-08-31 17:24:51 -0700733 break; // no command this time, no problem
734 }
735 switch (message.what) {
736 // ignore most messages
737 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
738 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
739 break;
740
741 case AAudioServiceMessage::code::EVENT:
742 result = onEventFromServer(&message);
743 break;
744
745 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700746 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burkbcc36742017-08-31 17:24:51 -0700747 result = AAUDIO_ERROR_INTERNAL;
748 break;
749 }
750 }
751 return result;
752}
753
Phil Burk204a1632017-01-03 17:23:43 -0800754// Process all the commands coming from the server.
Phil Burk5ed503c2017-02-01 09:38:15 -0800755aaudio_result_t AudioStreamInternal::processCommands() {
756 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800757
Phil Burk5ed503c2017-02-01 09:38:15 -0800758 while (result == AAUDIO_OK) {
759 AAudioServiceMessage message;
Phil Burk5edc4ea2020-04-17 08:15:42 -0700760 if (!mAudioEndpoint) {
761 break;
762 }
763 if (mAudioEndpoint->readUpCommand(&message) != 1) {
Phil Burk204a1632017-01-03 17:23:43 -0800764 break; // no command this time, no problem
765 }
766 switch (message.what) {
Phil Burk97350f92017-07-21 15:59:44 -0700767 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
768 result = onTimestampService(&message);
769 break;
770
771 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
772 result = onTimestampHardware(&message);
Phil Burk204a1632017-01-03 17:23:43 -0800773 break;
774
Phil Burk5ed503c2017-02-01 09:38:15 -0800775 case AAudioServiceMessage::code::EVENT:
Phil Burk204a1632017-01-03 17:23:43 -0800776 result = onEventFromServer(&message);
777 break;
778
779 default:
Phil Burkfbf031e2017-10-12 15:58:31 -0700780 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
Phil Burk17fff382017-05-16 14:06:45 -0700781 result = AAUDIO_ERROR_INTERNAL;
Phil Burk204a1632017-01-03 17:23:43 -0800782 break;
783 }
784 }
785 return result;
786}
787
Phil Burk87c9f642017-05-17 07:22:39 -0700788// Read or write the data, block if needed and timeoutMillis > 0
789aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
790 int64_t timeoutNanoseconds)
Phil Burk204a1632017-01-03 17:23:43 -0800791{
jiabin5f787812023-03-02 20:42:43 +0000792 if (isDisconnected()) {
793 return AAUDIO_ERROR_DISCONNECTED;
794 }
795 if (!mInService &&
796 AAudioBinderClient::getInstance().getServiceLifetimeId() != getServiceLifetimeId()) {
797 // The service lifetime id will be changed whenever the binder died. In that case, if
798 // the service lifetime id from AAudioBinderClient is different from the cached one,
799 // returns AAUDIO_ERROR_DISCONNECTED.
800 // Note that only compare the service lifetime id if it is not in service as the streams
801 // in service will all be gone when aaudio service dies.
802 mClockModel.stop(AudioClock::getNanoseconds());
803 // Set the stream as disconnected as the service lifetime id will only change when
804 // the binder dies.
805 setDisconnected();
806 return AAUDIO_ERROR_DISCONNECTED;
807 }
Phil Burkfd34a932017-07-19 07:03:52 -0700808 const char * traceName = "aaProc";
809 const char * fifoName = "aaRdy";
Phil Burk4485d412017-05-09 15:55:02 -0700810 ATRACE_BEGIN(traceName);
Phil Burk4485d412017-05-09 15:55:02 -0700811 if (ATRACE_ENABLED()) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700812 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
Phil Burkfd34a932017-07-19 07:03:52 -0700813 ATRACE_INT(fifoName, fullFrames);
Phil Burk4485d412017-05-09 15:55:02 -0700814 }
815
Phil Burkec89b2e2017-06-20 15:05:06 -0700816 aaudio_result_t result = AAUDIO_OK;
817 int32_t loopCount = 0;
818 uint8_t* audioData = (uint8_t*)buffer;
819 int64_t currentTimeNanos = AudioClock::getNanoseconds();
820 const int64_t entryTimeNanos = currentTimeNanos;
821 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
822 int32_t framesLeft = numFrames;
823
Phil Burk87c9f642017-05-17 07:22:39 -0700824 // Loop until all the data has been processed or until a timeout occurs.
Phil Burk204a1632017-01-03 17:23:43 -0800825 while (framesLeft > 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700826 // The call to processDataNow() will not block. It will just process as much as it can.
Phil Burk3316d5e2017-02-15 11:23:01 -0800827 int64_t wakeTimeNanos = 0;
Phil Burk87c9f642017-05-17 07:22:39 -0700828 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
829 currentTimeNanos, &wakeTimeNanos);
830 if (framesProcessed < 0) {
Phil Burk87c9f642017-05-17 07:22:39 -0700831 result = framesProcessed;
Phil Burk204a1632017-01-03 17:23:43 -0800832 break;
833 }
Phil Burk87c9f642017-05-17 07:22:39 -0700834 framesLeft -= (int32_t) framesProcessed;
835 audioData += framesProcessed * getBytesPerFrame();
Phil Burk204a1632017-01-03 17:23:43 -0800836
837 // Should we block?
838 if (timeoutNanoseconds == 0) {
839 break; // don't block
Phil Burk8d4f0062019-10-03 15:55:41 -0700840 } else if (wakeTimeNanos != 0) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700841 if (!mAudioEndpoint->isFreeRunning()) {
Phil Burkfd34a932017-07-19 07:03:52 -0700842 // If there is software on the other end of the FIFO then it may get delayed.
843 // So wake up just a little after we expect it to be ready.
844 wakeTimeNanos += mWakeupDelayNanos;
Phil Burk204a1632017-01-03 17:23:43 -0800845 }
Phil Burkfd34a932017-07-19 07:03:52 -0700846
Phil Burk2bc7c182017-08-28 11:45:01 -0700847 currentTimeNanos = AudioClock::getNanoseconds();
848 int64_t earliestWakeTime = currentTimeNanos + mMinimumSleepNanos;
849 // Guarantee a minimum sleep time.
850 if (wakeTimeNanos < earliestWakeTime) {
851 wakeTimeNanos = earliestWakeTime;
852 }
853
Phil Burk204a1632017-01-03 17:23:43 -0800854 if (wakeTimeNanos > deadlineNanos) {
855 // If we time out, just return the framesWritten so far.
Phil Burkfbf031e2017-10-12 15:58:31 -0700856 ALOGW("processData(): entered at %lld nanos, currently %lld",
Phil Burkec89b2e2017-06-20 15:05:06 -0700857 (long long) entryTimeNanos, (long long) currentTimeNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700858 ALOGW("processData(): TIMEOUT after %lld nanos",
Phil Burkc0c70e32017-02-09 13:18:38 -0800859 (long long) timeoutNanoseconds);
Phil Burkfbf031e2017-10-12 15:58:31 -0700860 ALOGW("processData(): wakeTime = %lld, deadline = %lld nanos",
Phil Burk87c9f642017-05-17 07:22:39 -0700861 (long long) wakeTimeNanos, (long long) deadlineNanos);
Phil Burkfbf031e2017-10-12 15:58:31 -0700862 ALOGW("processData(): past deadline by %d micros",
Phil Burk87c9f642017-05-17 07:22:39 -0700863 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
Phil Burkec89b2e2017-06-20 15:05:06 -0700864 mClockModel.dump();
Phil Burk5edc4ea2020-04-17 08:15:42 -0700865 mAudioEndpoint->dump();
Phil Burk204a1632017-01-03 17:23:43 -0800866 break;
867 }
868
Phil Burkfd34a932017-07-19 07:03:52 -0700869 if (ATRACE_ENABLED()) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700870 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
Phil Burkfd34a932017-07-19 07:03:52 -0700871 ATRACE_INT(fifoName, fullFrames);
872 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
873 ATRACE_INT("aaSlpNs", (int32_t)sleepForNanos);
874 }
875
876 AudioClock::sleepUntilNanoTime(wakeTimeNanos);
Phil Burk204a1632017-01-03 17:23:43 -0800877 currentTimeNanos = AudioClock::getNanoseconds();
878 }
879 }
880
Phil Burkfd34a932017-07-19 07:03:52 -0700881 if (ATRACE_ENABLED()) {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700882 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
Phil Burkfd34a932017-07-19 07:03:52 -0700883 ATRACE_INT(fifoName, fullFrames);
884 }
885
Phil Burk87c9f642017-05-17 07:22:39 -0700886 // return error or framesProcessed
Phil Burkc0c70e32017-02-09 13:18:38 -0800887 (void) loopCount;
Phil Burk4485d412017-05-09 15:55:02 -0700888 ATRACE_END();
Phil Burk204a1632017-01-03 17:23:43 -0800889 return (result < 0) ? result : numFrames - framesLeft;
890}
891
Phil Burk3316d5e2017-02-15 11:23:01 -0800892void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
Phil Burk87c9f642017-05-17 07:22:39 -0700893 mClockModel.processTimestamp(position, time);
Phil Burk204a1632017-01-03 17:23:43 -0800894}
895
Phil Burk3316d5e2017-02-15 11:23:01 -0800896aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
Phil Burk6479d502017-11-20 09:32:52 -0800897 int32_t adjustedFrames = requestedFrames;
Phil Burk8d97b8e2020-09-25 23:18:14 +0000898 const int32_t maximumSize = getBufferCapacity() - getFramesPerBurst();
Phil Burk5347dca2020-04-08 16:31:07 -0700899 // Minimum size should be a multiple number of bursts.
Phil Burk8d97b8e2020-09-25 23:18:14 +0000900 const int32_t minimumSize = 1 * getFramesPerBurst();
Phil Burk6479d502017-11-20 09:32:52 -0800901
902 // Clip to minimum size so that rounding up will work better.
Phil Burk8d4f0062019-10-03 15:55:41 -0700903 adjustedFrames = std::max(minimumSize, adjustedFrames);
Phil Burk71f35bb2017-04-13 16:05:07 -0700904
Phil Burk8d4f0062019-10-03 15:55:41 -0700905 // Prevent arithmetic overflow by clipping before we round.
906 if (adjustedFrames >= maximumSize) {
Phil Burk6479d502017-11-20 09:32:52 -0800907 adjustedFrames = maximumSize;
908 } else {
909 // Round to the next highest burst size.
Robert Wud559ba52023-06-29 00:08:51 +0000910 int32_t numBursts = (static_cast<int64_t>(adjustedFrames) + getFramesPerBurst() - 1) /
911 getFramesPerBurst();
Phil Burk8d97b8e2020-09-25 23:18:14 +0000912 adjustedFrames = numBursts * getFramesPerBurst();
913 // Clip just in case maximumSize is not a multiple of getFramesPerBurst().
Phil Burk5347dca2020-04-08 16:31:07 -0700914 adjustedFrames = std::min(maximumSize, adjustedFrames);
Phil Burk6479d502017-11-20 09:32:52 -0800915 }
916
Phil Burk5edc4ea2020-04-17 08:15:42 -0700917 if (mAudioEndpoint) {
918 // Clip against the actual size from the endpoint.
Robert Wud559ba52023-06-29 00:08:51 +0000919 int32_t actualFramesDevice = 0;
920 int32_t maximumFramesDevice = (static_cast<int64_t>(maximumSize) * getDeviceSampleRate()
921 + getSampleRate() - 1) / getSampleRate();
Phil Burk5edc4ea2020-04-17 08:15:42 -0700922 // Set to maximum size so we can write extra data when ready in order to reduce glitches.
923 // The amount we keep in the buffer is controlled by mBufferSizeInFrames.
Robert Wud559ba52023-06-29 00:08:51 +0000924 mAudioEndpoint->setBufferSizeInFrames(maximumFramesDevice, &actualFramesDevice);
925 int32_t actualFrames = (static_cast<int64_t>(actualFramesDevice) * getSampleRate() +
926 getDeviceSampleRate() - 1) / getDeviceSampleRate();
Phil Burk5edc4ea2020-04-17 08:15:42 -0700927 // actualFrames should be <= actual maximum size of endpoint
928 adjustedFrames = std::min(actualFrames, adjustedFrames);
929 }
Phil Burk8d4f0062019-10-03 15:55:41 -0700930
Robert Wud559ba52023-06-29 00:08:51 +0000931 const int32_t bufferSizeInFrames = adjustedFrames;
932 const int32_t deviceBufferSizeInFrames = static_cast<int64_t>(bufferSizeInFrames) *
933 getDeviceSampleRate() / getSampleRate();
934
935 if (deviceBufferSizeInFrames != mDeviceBufferSizeInFrames) {
Phil Burk64e16a72020-06-01 13:25:51 -0700936 android::mediametrics::LogItem(mMetricsId)
937 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETBUFFERSIZE)
Robert Wud559ba52023-06-29 00:08:51 +0000938 .set(AMEDIAMETRICS_PROP_BUFFERSIZEFRAMES, deviceBufferSizeInFrames)
Phil Burk64e16a72020-06-01 13:25:51 -0700939 .set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t) getXRunCount())
940 .record();
941 }
942
Robert Wud559ba52023-06-29 00:08:51 +0000943 mBufferSizeInFrames = bufferSizeInFrames;
944 mDeviceBufferSizeInFrames = deviceBufferSizeInFrames;
Phil Burk6c63ae32019-10-28 10:28:21 -0700945 ALOGV("%s(%d) returns %d", __func__, requestedFrames, adjustedFrames);
Phil Burk8d4f0062019-10-03 15:55:41 -0700946 return (aaudio_result_t) adjustedFrames;
Phil Burk204a1632017-01-03 17:23:43 -0800947}
948
Phil Burk87c9f642017-05-17 07:22:39 -0700949int32_t AudioStreamInternal::getBufferSize() const {
Phil Burk8d4f0062019-10-03 15:55:41 -0700950 return mBufferSizeInFrames;
Phil Burk204a1632017-01-03 17:23:43 -0800951}
952
Robert Wud559ba52023-06-29 00:08:51 +0000953int32_t AudioStreamInternal::getDeviceBufferSize() const {
954 return mDeviceBufferSizeInFrames;
955}
956
Phil Burk87c9f642017-05-17 07:22:39 -0700957int32_t AudioStreamInternal::getBufferCapacity() const {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700958 return mBufferCapacityInFrames;
Phil Burk204a1632017-01-03 17:23:43 -0800959}
960
Robert Wud559ba52023-06-29 00:08:51 +0000961int32_t AudioStreamInternal::getDeviceBufferCapacity() const {
962 return mDeviceBufferCapacityInFrames;
963}
964
Phil Burk377c1c22018-12-12 16:06:54 -0800965bool AudioStreamInternal::isClockModelInControl() const {
Phil Burk5edc4ea2020-04-17 08:15:42 -0700966 return isActive() && mAudioEndpoint->isFreeRunning() && mClockModel.isRunning();
Phil Burk377c1c22018-12-12 16:06:54 -0800967}