1 /*
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
17 #define LOG_TAG "AudioStreamInternal"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20
21 #define ATRACE_TAG ATRACE_TAG_AUDIO
22
23 #include <stdint.h>
24
25 #include <binder/IServiceManager.h>
26
27 #include <aaudio/AAudio.h>
28 #include <cutils/properties.h>
29
30 #include <media/AudioParameter.h>
31 #include <media/AudioSystem.h>
32 #include <media/MediaMetricsItem.h>
33 #include <utils/Trace.h>
34
35 #include "AudioEndpointParcelable.h"
36 #include "binding/AAudioBinderClient.h"
37 #include "binding/AAudioStreamRequest.h"
38 #include "binding/AAudioStreamConfiguration.h"
39 #include "binding/AAudioServiceMessage.h"
40 #include "core/AudioGlobal.h"
41 #include "core/AudioStreamBuilder.h"
42 #include "fifo/FifoBuffer.h"
43 #include "utility/AudioClock.h"
44 #include <media/AidlConversion.h>
45
46 #include "AudioStreamInternal.h"
47
48 // 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
55 using android::content::AttributionSourceState;
56
57 using namespace aaudio;
58
59 #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
64 #define LOG_TIMESTAMPS 0
65
AudioStreamInternal(AAudioServiceInterface & serviceInterface,bool inService)66 AudioStreamInternal::AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService)
67 : AudioStream()
68 , mClockModel()
69 , mInService(inService)
70 , mServiceInterface(serviceInterface)
71 , mAtomicInternalTimestamp()
72 , mWakeupDelayNanos(AAudioProperty_getWakeupDelayMicros() * AAUDIO_NANOS_PER_MICROSECOND)
73 , mMinimumSleepNanos(AAudioProperty_getMinimumSleepMicros() * AAUDIO_NANOS_PER_MICROSECOND)
74 {
75
76 }
77
~AudioStreamInternal()78 AudioStreamInternal::~AudioStreamInternal() {
79 ALOGD("%s() %p called", __func__, this);
80 }
81
open(const AudioStreamBuilder & builder)82 aaudio_result_t AudioStreamInternal::open(const AudioStreamBuilder &builder) {
83
84 aaudio_result_t result = AAUDIO_OK;
85 AAudioStreamRequest request;
86 AAudioStreamConfiguration configurationOutput;
87
88 if (getState() != AAUDIO_STREAM_STATE_UNINITIALIZED) {
89 ALOGE("%s - already open! state = %d", __func__, getState());
90 return AAUDIO_ERROR_INVALID_STATE;
91 }
92
93 // Copy requested parameters to the stream.
94 result = AudioStream::open(builder);
95 if (result < 0) {
96 return result;
97 }
98
99 const audio_format_t requestedFormat = getFormat();
100 // We have to do volume scaling. So we prefer FLOAT format.
101 if (requestedFormat == AUDIO_FORMAT_DEFAULT) {
102 setFormat(AUDIO_FORMAT_PCM_FLOAT);
103 }
104 // Request FLOAT for the shared mixer or the device.
105 request.getConfiguration().setFormat(AUDIO_FORMAT_PCM_FLOAT);
106
107 // TODO b/182392769: use attribution source util
108 AttributionSourceState attributionSource;
109 attributionSource.uid = VALUE_OR_FATAL(android::legacy2aidl_uid_t_int32_t(getuid()));
110 attributionSource.pid = VALUE_OR_FATAL(android::legacy2aidl_pid_t_int32_t(getpid()));
111 attributionSource.packageName = builder.getOpPackageName();
112 attributionSource.attributionTag = builder.getAttributionTag();
113 attributionSource.token = sp<android::BBinder>::make();
114
115 // Build the request to send to the server.
116 request.setAttributionSource(attributionSource);
117 request.setSharingModeMatchRequired(isSharingModeMatchRequired());
118 request.setInService(isInService());
119
120 request.getConfiguration().setDeviceId(getDeviceId());
121 request.getConfiguration().setSampleRate(getSampleRate());
122 request.getConfiguration().setDirection(getDirection());
123 request.getConfiguration().setSharingMode(getSharingMode());
124 request.getConfiguration().setChannelMask(getChannelMask());
125
126 request.getConfiguration().setUsage(getUsage());
127 request.getConfiguration().setContentType(getContentType());
128 request.getConfiguration().setSpatializationBehavior(getSpatializationBehavior());
129 request.getConfiguration().setIsContentSpatialized(isContentSpatialized());
130 request.getConfiguration().setInputPreset(getInputPreset());
131 request.getConfiguration().setPrivacySensitive(isPrivacySensitive());
132
133 request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
134
135 request.getConfiguration().setHardwareSamplesPerFrame(builder.getHardwareSamplesPerFrame());
136 request.getConfiguration().setHardwareSampleRate(builder.getHardwareSampleRate());
137 request.getConfiguration().setHardwareFormat(builder.getHardwareFormat());
138
139 mDeviceChannelCount = getSamplesPerFrame(); // Assume it will be the same. Update if not.
140
141 mServiceStreamHandleInfo = mServiceInterface.openStream(request, configurationOutput);
142 if (getServiceHandle() < 0
143 && (request.getConfiguration().getSamplesPerFrame() == 1
144 || request.getConfiguration().getChannelMask() == AAUDIO_CHANNEL_MONO)
145 && getDirection() == AAUDIO_DIRECTION_OUTPUT
146 && !isInService()) {
147 // if that failed then try switching from mono to stereo if OUTPUT.
148 // Only do this in the client. Otherwise we end up with a mono mixer in the service
149 // that writes to a stereo MMAP stream.
150 ALOGD("%s() - openStream() returned %d, try switching from MONO to STEREO",
151 __func__, getServiceHandle());
152 request.getConfiguration().setChannelMask(AAUDIO_CHANNEL_STEREO);
153 mServiceStreamHandleInfo = mServiceInterface.openStream(request, configurationOutput);
154 }
155 if (getServiceHandle() < 0) {
156 return getServiceHandle();
157 }
158
159 // This must match the key generated in oboeservice/AAudioServiceStreamBase.cpp
160 // so the client can have permission to log.
161 if (!mInService) {
162 // No need to log if it is from service side.
163 mMetricsId = std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_STREAM)
164 + std::to_string(getServiceHandle());
165 }
166
167 android::mediametrics::LogItem(mMetricsId)
168 .set(AMEDIAMETRICS_PROP_PERFORMANCEMODE,
169 AudioGlobal_convertPerformanceModeToText(builder.getPerformanceMode()))
170 .set(AMEDIAMETRICS_PROP_SHARINGMODE,
171 AudioGlobal_convertSharingModeToText(builder.getSharingMode()))
172 .set(AMEDIAMETRICS_PROP_ENCODINGCLIENT,
173 android::toString(requestedFormat).c_str()).record();
174
175 result = configurationOutput.validate();
176 if (result != AAUDIO_OK) {
177 goto error;
178 }
179 // Save results of the open.
180 if (getChannelMask() == AAUDIO_UNSPECIFIED) {
181 setChannelMask(configurationOutput.getChannelMask());
182 }
183
184 mDeviceChannelCount = configurationOutput.getSamplesPerFrame();
185
186 setSampleRate(configurationOutput.getSampleRate());
187 setDeviceId(configurationOutput.getDeviceId());
188 setSessionId(configurationOutput.getSessionId());
189 setSharingMode(configurationOutput.getSharingMode());
190
191 setUsage(configurationOutput.getUsage());
192 setContentType(configurationOutput.getContentType());
193 setSpatializationBehavior(configurationOutput.getSpatializationBehavior());
194 setIsContentSpatialized(configurationOutput.isContentSpatialized());
195 setInputPreset(configurationOutput.getInputPreset());
196
197 // Save device format so we can do format conversion and volume scaling together.
198 setDeviceFormat(configurationOutput.getFormat());
199
200 setHardwareSamplesPerFrame(configurationOutput.getHardwareSamplesPerFrame());
201 setHardwareSampleRate(configurationOutput.getHardwareSampleRate());
202 setHardwareFormat(configurationOutput.getHardwareFormat());
203
204 result = mServiceInterface.getStreamDescription(mServiceStreamHandleInfo, mEndPointParcelable);
205 if (result != AAUDIO_OK) {
206 goto error;
207 }
208
209 // Resolve parcelable into a descriptor.
210 result = mEndPointParcelable.resolve(&mEndpointDescriptor);
211 if (result != AAUDIO_OK) {
212 goto error;
213 }
214
215 // Configure endpoint based on descriptor.
216 mAudioEndpoint = std::make_unique<AudioEndpoint>();
217 result = mAudioEndpoint->configure(&mEndpointDescriptor, getDirection());
218 if (result != AAUDIO_OK) {
219 goto error;
220 }
221
222 if ((result = configureDataInformation(builder.getFramesPerDataCallback())) != AAUDIO_OK) {
223 goto error;
224 }
225
226 setState(AAUDIO_STREAM_STATE_OPEN);
227
228 return result;
229
230 error:
231 safeReleaseClose();
232 return result;
233 }
234
configureDataInformation(int32_t callbackFrames)235 aaudio_result_t AudioStreamInternal::configureDataInformation(int32_t callbackFrames) {
236 int32_t framesPerHardwareBurst = mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
237
238 // Scale up the burst size to meet the minimum equivalent in microseconds.
239 // This is to avoid waking the CPU too often when the HW burst is very small
240 // or at high sample rates.
241 int32_t framesPerBurst = framesPerHardwareBurst;
242 int32_t burstMicros = 0;
243 const int32_t burstMinMicros = android::AudioSystem::getAAudioHardwareBurstMinUsec();
244 do {
245 if (burstMicros > 0) { // skip first loop
246 framesPerBurst *= 2;
247 }
248 burstMicros = framesPerBurst * static_cast<int64_t>(1000000) / getSampleRate();
249 } while (burstMicros < burstMinMicros);
250 ALOGD("%s() original HW burst = %d, minMicros = %d => SW burst = %d\n",
251 __func__, framesPerHardwareBurst, burstMinMicros, framesPerBurst);
252
253 // Validate final burst size.
254 if (framesPerBurst < MIN_FRAMES_PER_BURST || framesPerBurst > MAX_FRAMES_PER_BURST) {
255 ALOGE("%s - framesPerBurst out of range = %d", __func__, framesPerBurst);
256 return AAUDIO_ERROR_OUT_OF_RANGE;
257 }
258 setFramesPerBurst(framesPerBurst); // only save good value
259
260 mBufferCapacityInFrames = mEndpointDescriptor.dataQueueDescriptor.capacityInFrames;
261 if (mBufferCapacityInFrames < getFramesPerBurst()
262 || mBufferCapacityInFrames > MAX_BUFFER_CAPACITY_IN_FRAMES) {
263 ALOGE("%s - bufferCapacity out of range = %d", __func__, mBufferCapacityInFrames);
264 return AAUDIO_ERROR_OUT_OF_RANGE;
265 }
266
267 mClockModel.setSampleRate(getSampleRate());
268 mClockModel.setFramesPerBurst(framesPerHardwareBurst);
269
270 if (isDataCallbackSet()) {
271 mCallbackFrames = callbackFrames;
272 if (mCallbackFrames > getBufferCapacity() / 2) {
273 ALOGW("%s - framesPerCallback too big = %d, capacity = %d",
274 __func__, mCallbackFrames, getBufferCapacity());
275 return AAUDIO_ERROR_OUT_OF_RANGE;
276 } else if (mCallbackFrames < 0) {
277 ALOGW("%s - framesPerCallback negative", __func__);
278 return AAUDIO_ERROR_OUT_OF_RANGE;
279 }
280 if (mCallbackFrames == AAUDIO_UNSPECIFIED) {
281 mCallbackFrames = getFramesPerBurst();
282 }
283
284 const int32_t callbackBufferSize = mCallbackFrames * getBytesPerFrame();
285 mCallbackBuffer = std::make_unique<uint8_t[]>(callbackBufferSize);
286 }
287
288 // Exclusive output streams should combine channels when mono audio adjustment
289 // is enabled. They should also adjust for audio balance.
290 if ((getDirection() == AAUDIO_DIRECTION_OUTPUT) &&
291 (getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE)) {
292 bool isMasterMono = false;
293 android::AudioSystem::getMasterMono(&isMasterMono);
294 setRequireMonoBlend(isMasterMono);
295 float audioBalance = 0;
296 android::AudioSystem::getMasterBalance(&audioBalance);
297 setAudioBalance(audioBalance);
298 }
299
300 // For debugging and analyzing the distribution of MMAP timestamps.
301 // For OUTPUT, use a NEGATIVE offset to move the CPU writes further BEFORE the HW reads.
302 // For INPUT, use a POSITIVE offset to move the CPU reads further AFTER the HW writes.
303 // You can use this offset to reduce glitching.
304 // You can also use this offset to force glitching. By iterating over multiple
305 // values you can reveal the distribution of the hardware timing jitter.
306 if (mAudioEndpoint->isFreeRunning()) { // MMAP?
307 int32_t offsetMicros = (getDirection() == AAUDIO_DIRECTION_OUTPUT)
308 ? AAudioProperty_getOutputMMapOffsetMicros()
309 : AAudioProperty_getInputMMapOffsetMicros();
310 // This log is used to debug some tricky glitch issues. Please leave.
311 ALOGD_IF(offsetMicros, "%s() - %s mmap offset = %d micros",
312 __func__,
313 (getDirection() == AAUDIO_DIRECTION_OUTPUT) ? "output" : "input",
314 offsetMicros);
315 mTimeOffsetNanos = offsetMicros * AAUDIO_NANOS_PER_MICROSECOND;
316 }
317
318 setBufferSize(mBufferCapacityInFrames / 2); // Default buffer size to match Q
319 return AAUDIO_OK;
320 }
321
322 // This must be called under mStreamLock.
release_l()323 aaudio_result_t AudioStreamInternal::release_l() {
324 aaudio_result_t result = AAUDIO_OK;
325 ALOGD("%s(): mServiceStreamHandle = 0x%08X", __func__, getServiceHandle());
326 if (getServiceHandle() != AAUDIO_HANDLE_INVALID) {
327 // Don't release a stream while it is running. Stop it first.
328 // If DISCONNECTED then we should still try to stop in case the
329 // error callback is still running.
330 if (isActive() || isDisconnected()) {
331 requestStop_l();
332 }
333
334 logReleaseBufferState();
335
336 setState(AAUDIO_STREAM_STATE_CLOSING);
337 auto serviceStreamHandleInfo = mServiceStreamHandleInfo;
338 mServiceStreamHandleInfo = AAudioHandleInfo();
339
340 mServiceInterface.closeStream(serviceStreamHandleInfo);
341 mCallbackBuffer.reset();
342
343 // Update local frame counters so we can query them after releasing the endpoint.
344 getFramesRead();
345 getFramesWritten();
346 mAudioEndpoint.reset();
347 result = mEndPointParcelable.close();
348 aaudio_result_t result2 = AudioStream::release_l();
349 return (result != AAUDIO_OK) ? result : result2;
350 } else {
351 return AAUDIO_ERROR_INVALID_HANDLE;
352 }
353 }
354
aaudio_callback_thread_proc(void * context)355 static void *aaudio_callback_thread_proc(void *context)
356 {
357 AudioStreamInternal *stream = (AudioStreamInternal *)context;
358 //LOGD("oboe_callback_thread, stream = %p", stream);
359 if (stream != nullptr) {
360 return stream->callbackLoop();
361 } else {
362 return nullptr;
363 }
364 }
365
exitStandby_l()366 aaudio_result_t AudioStreamInternal::exitStandby_l() {
367 AudioEndpointParcelable endpointParcelable;
368 // The stream is in standby mode, copy all available data and then close the duplicated
369 // shared file descriptor so that it won't cause issue when the HAL try to reallocate new
370 // shared file descriptor when exiting from standby.
371 // Cache current read counter, which will be reset to new read and write counter
372 // when the new data queue and endpoint are reconfigured.
373 const android::fifo_counter_t readCounter = mAudioEndpoint->getDataReadCounter();
374 // Cache the buffer size which may be from client.
375 const int32_t previousBufferSize = mBufferSizeInFrames;
376 // Copy all available data from current data queue.
377 uint8_t buffer[getBufferCapacity() * getBytesPerFrame()];
378 android::fifo_frames_t fullFramesAvailable =
379 mAudioEndpoint->read(buffer, getBufferCapacity());
380 mEndPointParcelable.closeDataFileDescriptor();
381 aaudio_result_t result = mServiceInterface.exitStandby(
382 mServiceStreamHandleInfo, endpointParcelable);
383 if (result != AAUDIO_OK) {
384 ALOGE("Failed to exit standby, error=%d", result);
385 goto exit;
386 }
387 // Reconstruct data queue descriptor using new shared file descriptor.
388 result = mEndPointParcelable.updateDataFileDescriptor(&endpointParcelable);
389 if (result != AAUDIO_OK) {
390 ALOGE("%s failed to update data file descriptor, error=%d", __func__, result);
391 goto exit;
392 }
393 result = mEndPointParcelable.resolveDataQueue(&mEndpointDescriptor.dataQueueDescriptor);
394 if (result != AAUDIO_OK) {
395 ALOGE("Failed to resolve data queue after exiting standby, error=%d", result);
396 goto exit;
397 }
398 // Reconfigure audio endpoint with new data queue descriptor.
399 mAudioEndpoint->configureDataQueue(
400 mEndpointDescriptor.dataQueueDescriptor, getDirection());
401 // Set read and write counters with previous read counter, the later write action
402 // will make the counter at the correct place.
403 mAudioEndpoint->setDataReadCounter(readCounter);
404 mAudioEndpoint->setDataWriteCounter(readCounter);
405 result = configureDataInformation(mCallbackFrames);
406 if (result != AAUDIO_OK) {
407 ALOGE("Failed to configure data information after exiting standby, error=%d", result);
408 goto exit;
409 }
410 // Write data from previous data buffer to new endpoint.
411 if (android::fifo_frames_t framesWritten =
412 mAudioEndpoint->write(buffer, fullFramesAvailable);
413 framesWritten != fullFramesAvailable) {
414 ALOGW("Some data lost after exiting standby, frames written: %d, "
415 "frames to write: %d", framesWritten, fullFramesAvailable);
416 }
417 // Reset previous buffer size as it may be requested by the client.
418 setBufferSize(previousBufferSize);
419
420 exit:
421 return result;
422 }
423
424 /*
425 * It normally takes about 20-30 msec to start a stream on the server.
426 * But the first time can take as much as 200-300 msec. The HW
427 * starts right away so by the time the client gets a chance to write into
428 * the buffer, it is already in a deep underflow state. That can cause the
429 * XRunCount to be non-zero, which could lead an app to tune its latency higher.
430 * To avoid this problem, we set a request for the processing code to start the
431 * client stream at the same position as the server stream.
432 * The processing code will then save the current offset
433 * between client and server and apply that to any position given to the app.
434 */
requestStart_l()435 aaudio_result_t AudioStreamInternal::requestStart_l()
436 {
437 int64_t startTime;
438 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
439 ALOGD("requestStart() mServiceStreamHandle invalid");
440 return AAUDIO_ERROR_INVALID_STATE;
441 }
442 if (isActive()) {
443 ALOGD("requestStart() already active");
444 return AAUDIO_ERROR_INVALID_STATE;
445 }
446
447 if (isDisconnected()) {
448 ALOGD("requestStart() but DISCONNECTED");
449 return AAUDIO_ERROR_DISCONNECTED;
450 }
451 aaudio_stream_state_t originalState = getState();
452 setState(AAUDIO_STREAM_STATE_STARTING);
453
454 // Clear any stale timestamps from the previous run.
455 drainTimestampsFromService();
456
457 prepareBuffersForStart(); // tell subclasses to get ready
458
459 aaudio_result_t result = mServiceInterface.startStream(mServiceStreamHandleInfo);
460 if (result == AAUDIO_ERROR_STANDBY) {
461 // The stream is at standby mode. Need to exit standby before starting the stream.
462 result = exitStandby_l();
463 if (result == AAUDIO_OK) {
464 result = mServiceInterface.startStream(mServiceStreamHandleInfo);
465 }
466 }
467 if (result != AAUDIO_OK) {
468 ALOGD("%s() error = %d, stream was probably stolen", __func__, result);
469 // Stealing was added in R. Coerce result to improve backward compatibility.
470 result = AAUDIO_ERROR_DISCONNECTED;
471 setDisconnected();
472 }
473
474 startTime = AudioClock::getNanoseconds();
475 mClockModel.start(startTime);
476 mNeedCatchUp.request(); // Ask data processing code to catch up when first timestamp received.
477
478 // Start data callback thread.
479 if (result == AAUDIO_OK && isDataCallbackSet()) {
480 // Launch the callback loop thread.
481 int64_t periodNanos = mCallbackFrames
482 * AAUDIO_NANOS_PER_SECOND
483 / getSampleRate();
484 mCallbackEnabled.store(true);
485 result = createThread_l(periodNanos, aaudio_callback_thread_proc, this);
486 }
487 if (result != AAUDIO_OK) {
488 setState(originalState);
489 }
490 return result;
491 }
492
calculateReasonableTimeout(int32_t framesPerOperation)493 int64_t AudioStreamInternal::calculateReasonableTimeout(int32_t framesPerOperation) {
494
495 // Wait for at least a second or some number of callbacks to join the thread.
496 int64_t timeoutNanoseconds = (MIN_TIMEOUT_OPERATIONS
497 * framesPerOperation
498 * AAUDIO_NANOS_PER_SECOND)
499 / getSampleRate();
500 if (timeoutNanoseconds < MIN_TIMEOUT_NANOS) { // arbitrary number of seconds
501 timeoutNanoseconds = MIN_TIMEOUT_NANOS;
502 }
503 return timeoutNanoseconds;
504 }
505
calculateReasonableTimeout()506 int64_t AudioStreamInternal::calculateReasonableTimeout() {
507 return calculateReasonableTimeout(getFramesPerBurst());
508 }
509
510 // This must be called under mStreamLock.
stopCallback_l()511 aaudio_result_t AudioStreamInternal::stopCallback_l()
512 {
513 if (isDataCallbackSet() && (isActive() || isDisconnected())) {
514 mCallbackEnabled.store(false);
515 aaudio_result_t result = joinThread_l(nullptr); // may temporarily unlock mStreamLock
516 if (result == AAUDIO_ERROR_INVALID_HANDLE) {
517 ALOGD("%s() INVALID_HANDLE, stream was probably stolen", __func__);
518 result = AAUDIO_OK;
519 }
520 return result;
521 } else {
522 ALOGD("%s() skipped, isDataCallbackSet() = %d, isActive() = %d, getState() = %d", __func__,
523 isDataCallbackSet(), isActive(), getState());
524 return AAUDIO_OK;
525 }
526 }
527
requestStop_l()528 aaudio_result_t AudioStreamInternal::requestStop_l() {
529 aaudio_result_t result = stopCallback_l();
530 if (result != AAUDIO_OK) {
531 ALOGW("%s() stop callback returned %d, returning early", __func__, result);
532 return result;
533 }
534 // The stream may have been unlocked temporarily to let a callback finish
535 // and the callback may have stopped the stream.
536 // Check to make sure the stream still needs to be stopped.
537 // See also AudioStream::safeStop_l().
538 if (!(isActive() || isDisconnected())) {
539 ALOGD("%s() returning early, not active or disconnected", __func__);
540 return AAUDIO_OK;
541 }
542
543 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
544 ALOGW("%s() mServiceStreamHandle invalid = 0x%08X",
545 __func__, getServiceHandle());
546 return AAUDIO_ERROR_INVALID_STATE;
547 }
548
549 mClockModel.stop(AudioClock::getNanoseconds());
550 setState(AAUDIO_STREAM_STATE_STOPPING);
551 mAtomicInternalTimestamp.clear();
552
553 result = mServiceInterface.stopStream(mServiceStreamHandleInfo);
554 if (result == AAUDIO_ERROR_INVALID_HANDLE) {
555 ALOGD("%s() INVALID_HANDLE, stream was probably stolen", __func__);
556 result = AAUDIO_OK;
557 }
558 return result;
559 }
560
registerThread()561 aaudio_result_t AudioStreamInternal::registerThread() {
562 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
563 ALOGW("%s() mServiceStreamHandle invalid", __func__);
564 return AAUDIO_ERROR_INVALID_STATE;
565 }
566 return mServiceInterface.registerAudioThread(mServiceStreamHandleInfo,
567 gettid(),
568 getPeriodNanoseconds());
569 }
570
unregisterThread()571 aaudio_result_t AudioStreamInternal::unregisterThread() {
572 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
573 ALOGW("%s() mServiceStreamHandle invalid", __func__);
574 return AAUDIO_ERROR_INVALID_STATE;
575 }
576 return mServiceInterface.unregisterAudioThread(mServiceStreamHandleInfo, gettid());
577 }
578
startClient(const android::AudioClient & client,const audio_attributes_t * attr,audio_port_handle_t * portHandle)579 aaudio_result_t AudioStreamInternal::startClient(const android::AudioClient& client,
580 const audio_attributes_t *attr,
581 audio_port_handle_t *portHandle) {
582 ALOGV("%s() called", __func__);
583 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
584 return AAUDIO_ERROR_INVALID_STATE;
585 }
586 aaudio_result_t result = mServiceInterface.startClient(mServiceStreamHandleInfo,
587 client, attr, portHandle);
588 ALOGV("%s(%d) returning %d", __func__, *portHandle, result);
589 return result;
590 }
591
stopClient(audio_port_handle_t portHandle)592 aaudio_result_t AudioStreamInternal::stopClient(audio_port_handle_t portHandle) {
593 ALOGV("%s(%d) called", __func__, portHandle);
594 if (getServiceHandle() == AAUDIO_HANDLE_INVALID) {
595 return AAUDIO_ERROR_INVALID_STATE;
596 }
597 aaudio_result_t result = mServiceInterface.stopClient(mServiceStreamHandleInfo, portHandle);
598 ALOGV("%s(%d) returning %d", __func__, portHandle, result);
599 return result;
600 }
601
getTimestamp(clockid_t,int64_t * framePosition,int64_t * timeNanoseconds)602 aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t /*clockId*/,
603 int64_t *framePosition,
604 int64_t *timeNanoseconds) {
605 // Generated in server and passed to client. Return latest.
606 if (mAtomicInternalTimestamp.isValid()) {
607 Timestamp timestamp = mAtomicInternalTimestamp.read();
608 int64_t position = timestamp.getPosition() + mFramesOffsetFromService;
609 if (position >= 0) {
610 *framePosition = position;
611 *timeNanoseconds = timestamp.getNanoseconds();
612 return AAUDIO_OK;
613 }
614 }
615 return AAUDIO_ERROR_INVALID_STATE;
616 }
617
logTimestamp(AAudioServiceMessage & command)618 void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
619 static int64_t oldPosition = 0;
620 static int64_t oldTime = 0;
621 int64_t framePosition = command.timestamp.position;
622 int64_t nanoTime = command.timestamp.timestamp;
623 ALOGD("logTimestamp: timestamp says framePosition = %8lld at nanoTime %lld",
624 (long long) framePosition,
625 (long long) nanoTime);
626 int64_t nanosDelta = nanoTime - oldTime;
627 if (nanosDelta > 0 && oldTime > 0) {
628 int64_t framesDelta = framePosition - oldPosition;
629 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
630 ALOGD("logTimestamp: framesDelta = %8lld, nanosDelta = %8lld, rate = %lld",
631 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
632 }
633 oldPosition = framePosition;
634 oldTime = nanoTime;
635 }
636
onTimestampService(AAudioServiceMessage * message)637 aaudio_result_t AudioStreamInternal::onTimestampService(AAudioServiceMessage *message) {
638 #if LOG_TIMESTAMPS
639 logTimestamp(*message);
640 #endif
641 processTimestamp(message->timestamp.position,
642 message->timestamp.timestamp + mTimeOffsetNanos);
643 return AAUDIO_OK;
644 }
645
onTimestampHardware(AAudioServiceMessage * message)646 aaudio_result_t AudioStreamInternal::onTimestampHardware(AAudioServiceMessage *message) {
647 Timestamp timestamp(message->timestamp.position, message->timestamp.timestamp);
648 mAtomicInternalTimestamp.write(timestamp);
649 return AAUDIO_OK;
650 }
651
onEventFromServer(AAudioServiceMessage * message)652 aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
653 aaudio_result_t result = AAUDIO_OK;
654 switch (message->event.event) {
655 case AAUDIO_SERVICE_EVENT_STARTED:
656 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STARTED", __func__);
657 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
658 setState(AAUDIO_STREAM_STATE_STARTED);
659 }
660 mPlayerBase->triggerPortIdUpdate(static_cast<audio_port_handle_t>(
661 message->event.dataLong));
662 break;
663 case AAUDIO_SERVICE_EVENT_PAUSED:
664 ALOGD("%s - got AAUDIO_SERVICE_EVENT_PAUSED", __func__);
665 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
666 setState(AAUDIO_STREAM_STATE_PAUSED);
667 }
668 break;
669 case AAUDIO_SERVICE_EVENT_STOPPED:
670 ALOGD("%s - got AAUDIO_SERVICE_EVENT_STOPPED", __func__);
671 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
672 setState(AAUDIO_STREAM_STATE_STOPPED);
673 }
674 break;
675 case AAUDIO_SERVICE_EVENT_FLUSHED:
676 ALOGD("%s - got AAUDIO_SERVICE_EVENT_FLUSHED", __func__);
677 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
678 setState(AAUDIO_STREAM_STATE_FLUSHED);
679 onFlushFromServer();
680 }
681 break;
682 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
683 // Prevent hardware from looping on old data and making buzzing sounds.
684 if (getDirection() == AAUDIO_DIRECTION_OUTPUT) {
685 mAudioEndpoint->eraseDataMemory();
686 }
687 result = AAUDIO_ERROR_DISCONNECTED;
688 setDisconnected();
689 ALOGW("%s - AAUDIO_SERVICE_EVENT_DISCONNECTED - FIFO cleared", __func__);
690 break;
691 case AAUDIO_SERVICE_EVENT_VOLUME:
692 ALOGD("%s - AAUDIO_SERVICE_EVENT_VOLUME %lf", __func__, message->event.dataDouble);
693 mStreamVolume = (float)message->event.dataDouble;
694 doSetVolume();
695 break;
696 case AAUDIO_SERVICE_EVENT_XRUN:
697 mXRunCount = static_cast<int32_t>(message->event.dataLong);
698 break;
699 default:
700 ALOGE("%s - Unrecognized event = %d", __func__, (int) message->event.event);
701 break;
702 }
703 return result;
704 }
705
drainTimestampsFromService()706 aaudio_result_t AudioStreamInternal::drainTimestampsFromService() {
707 aaudio_result_t result = AAUDIO_OK;
708
709 while (result == AAUDIO_OK) {
710 AAudioServiceMessage message;
711 if (!mAudioEndpoint) {
712 break;
713 }
714 if (mAudioEndpoint->readUpCommand(&message) != 1) {
715 break; // no command this time, no problem
716 }
717 switch (message.what) {
718 // ignore most messages
719 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
720 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
721 break;
722
723 case AAudioServiceMessage::code::EVENT:
724 result = onEventFromServer(&message);
725 break;
726
727 default:
728 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
729 result = AAUDIO_ERROR_INTERNAL;
730 break;
731 }
732 }
733 return result;
734 }
735
736 // Process all the commands coming from the server.
processCommands()737 aaudio_result_t AudioStreamInternal::processCommands() {
738 aaudio_result_t result = AAUDIO_OK;
739
740 while (result == AAUDIO_OK) {
741 AAudioServiceMessage message;
742 if (!mAudioEndpoint) {
743 break;
744 }
745 if (mAudioEndpoint->readUpCommand(&message) != 1) {
746 break; // no command this time, no problem
747 }
748 switch (message.what) {
749 case AAudioServiceMessage::code::TIMESTAMP_SERVICE:
750 result = onTimestampService(&message);
751 break;
752
753 case AAudioServiceMessage::code::TIMESTAMP_HARDWARE:
754 result = onTimestampHardware(&message);
755 break;
756
757 case AAudioServiceMessage::code::EVENT:
758 result = onEventFromServer(&message);
759 break;
760
761 default:
762 ALOGE("%s - unrecognized message.what = %d", __func__, (int) message.what);
763 result = AAUDIO_ERROR_INTERNAL;
764 break;
765 }
766 }
767 return result;
768 }
769
770 // Read or write the data, block if needed and timeoutMillis > 0
processData(void * buffer,int32_t numFrames,int64_t timeoutNanoseconds)771 aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
772 int64_t timeoutNanoseconds)
773 {
774 if (isDisconnected()) {
775 return AAUDIO_ERROR_DISCONNECTED;
776 }
777 if (!mInService &&
778 AAudioBinderClient::getInstance().getServiceLifetimeId() != getServiceLifetimeId()) {
779 // The service lifetime id will be changed whenever the binder died. In that case, if
780 // the service lifetime id from AAudioBinderClient is different from the cached one,
781 // returns AAUDIO_ERROR_DISCONNECTED.
782 // Note that only compare the service lifetime id if it is not in service as the streams
783 // in service will all be gone when aaudio service dies.
784 mClockModel.stop(AudioClock::getNanoseconds());
785 // Set the stream as disconnected as the service lifetime id will only change when
786 // the binder dies.
787 setDisconnected();
788 return AAUDIO_ERROR_DISCONNECTED;
789 }
790 const char * traceName = "aaProc";
791 const char * fifoName = "aaRdy";
792 ATRACE_BEGIN(traceName);
793 if (ATRACE_ENABLED()) {
794 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
795 ATRACE_INT(fifoName, fullFrames);
796 }
797
798 aaudio_result_t result = AAUDIO_OK;
799 int32_t loopCount = 0;
800 uint8_t* audioData = (uint8_t*)buffer;
801 int64_t currentTimeNanos = AudioClock::getNanoseconds();
802 const int64_t entryTimeNanos = currentTimeNanos;
803 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
804 int32_t framesLeft = numFrames;
805
806 // Loop until all the data has been processed or until a timeout occurs.
807 while (framesLeft > 0) {
808 // The call to processDataNow() will not block. It will just process as much as it can.
809 int64_t wakeTimeNanos = 0;
810 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
811 currentTimeNanos, &wakeTimeNanos);
812 if (framesProcessed < 0) {
813 result = framesProcessed;
814 break;
815 }
816 framesLeft -= (int32_t) framesProcessed;
817 audioData += framesProcessed * getBytesPerFrame();
818
819 // Should we block?
820 if (timeoutNanoseconds == 0) {
821 break; // don't block
822 } else if (wakeTimeNanos != 0) {
823 if (!mAudioEndpoint->isFreeRunning()) {
824 // If there is software on the other end of the FIFO then it may get delayed.
825 // So wake up just a little after we expect it to be ready.
826 wakeTimeNanos += mWakeupDelayNanos;
827 }
828
829 currentTimeNanos = AudioClock::getNanoseconds();
830 int64_t earliestWakeTime = currentTimeNanos + mMinimumSleepNanos;
831 // Guarantee a minimum sleep time.
832 if (wakeTimeNanos < earliestWakeTime) {
833 wakeTimeNanos = earliestWakeTime;
834 }
835
836 if (wakeTimeNanos > deadlineNanos) {
837 // If we time out, just return the framesWritten so far.
838 ALOGW("processData(): entered at %lld nanos, currently %lld",
839 (long long) entryTimeNanos, (long long) currentTimeNanos);
840 ALOGW("processData(): TIMEOUT after %lld nanos",
841 (long long) timeoutNanoseconds);
842 ALOGW("processData(): wakeTime = %lld, deadline = %lld nanos",
843 (long long) wakeTimeNanos, (long long) deadlineNanos);
844 ALOGW("processData(): past deadline by %d micros",
845 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
846 mClockModel.dump();
847 mAudioEndpoint->dump();
848 break;
849 }
850
851 if (ATRACE_ENABLED()) {
852 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
853 ATRACE_INT(fifoName, fullFrames);
854 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
855 ATRACE_INT("aaSlpNs", (int32_t)sleepForNanos);
856 }
857
858 AudioClock::sleepUntilNanoTime(wakeTimeNanos);
859 currentTimeNanos = AudioClock::getNanoseconds();
860 }
861 }
862
863 if (ATRACE_ENABLED()) {
864 int32_t fullFrames = mAudioEndpoint->getFullFramesAvailable();
865 ATRACE_INT(fifoName, fullFrames);
866 }
867
868 // return error or framesProcessed
869 (void) loopCount;
870 ATRACE_END();
871 return (result < 0) ? result : numFrames - framesLeft;
872 }
873
processTimestamp(uint64_t position,int64_t time)874 void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
875 mClockModel.processTimestamp(position, time);
876 }
877
setBufferSize(int32_t requestedFrames)878 aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
879 int32_t adjustedFrames = requestedFrames;
880 const int32_t maximumSize = getBufferCapacity() - getFramesPerBurst();
881 // Minimum size should be a multiple number of bursts.
882 const int32_t minimumSize = 1 * getFramesPerBurst();
883
884 // Clip to minimum size so that rounding up will work better.
885 adjustedFrames = std::max(minimumSize, adjustedFrames);
886
887 // Prevent arithmetic overflow by clipping before we round.
888 if (adjustedFrames >= maximumSize) {
889 adjustedFrames = maximumSize;
890 } else {
891 // Round to the next highest burst size.
892 int32_t numBursts = (adjustedFrames + getFramesPerBurst() - 1) / getFramesPerBurst();
893 adjustedFrames = numBursts * getFramesPerBurst();
894 // Clip just in case maximumSize is not a multiple of getFramesPerBurst().
895 adjustedFrames = std::min(maximumSize, adjustedFrames);
896 }
897
898 if (mAudioEndpoint) {
899 // Clip against the actual size from the endpoint.
900 int32_t actualFrames = 0;
901 // Set to maximum size so we can write extra data when ready in order to reduce glitches.
902 // The amount we keep in the buffer is controlled by mBufferSizeInFrames.
903 mAudioEndpoint->setBufferSizeInFrames(maximumSize, &actualFrames);
904 // actualFrames should be <= actual maximum size of endpoint
905 adjustedFrames = std::min(actualFrames, adjustedFrames);
906 }
907
908 if (adjustedFrames != mBufferSizeInFrames) {
909 android::mediametrics::LogItem(mMetricsId)
910 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETBUFFERSIZE)
911 .set(AMEDIAMETRICS_PROP_BUFFERSIZEFRAMES, adjustedFrames)
912 .set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t) getXRunCount())
913 .record();
914 }
915
916 mBufferSizeInFrames = adjustedFrames;
917 ALOGV("%s(%d) returns %d", __func__, requestedFrames, adjustedFrames);
918 return (aaudio_result_t) adjustedFrames;
919 }
920
getBufferSize() const921 int32_t AudioStreamInternal::getBufferSize() const {
922 return mBufferSizeInFrames;
923 }
924
getBufferCapacity() const925 int32_t AudioStreamInternal::getBufferCapacity() const {
926 return mBufferCapacityInFrames;
927 }
928
isClockModelInControl() const929 bool AudioStreamInternal::isClockModelInControl() const {
930 return isActive() && mAudioEndpoint->isFreeRunning() && mClockModel.isRunning();
931 }
932