blob: 31d6e1516b5107929aa1740cbc9327f7cb0bae0a [file] [log] [blame]
Phil Burk2355edb2016-12-26 13:54:02 -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
Eric Laurentcb4dae22017-07-01 19:39:32 -070017#define LOG_TAG "AAudioServiceStreamBase"
Phil Burk2355edb2016-12-26 13:54:02 -080018//#define LOG_NDEBUG 0
19#include <utils/Log.h>
20
Phil Burka5222e22017-07-28 13:31:14 -070021#include <iomanip>
22#include <iostream>
Phil Burkc0c70e32017-02-09 13:18:38 -080023#include <mutex>
Phil Burk2355edb2016-12-26 13:54:02 -080024
Phil Burka9876702020-04-20 18:16:15 -070025#include <media/MediaMetricsItem.h>
26#include <media/TypeConverter.h>
Phil Burk7ebbc112020-05-13 15:55:17 -070027#include <mediautils/SchedulingPolicyService.h>
Phil Burka9876702020-04-20 18:16:15 -070028
Phil Burkc0c70e32017-02-09 13:18:38 -080029#include "binding/AAudioServiceMessage.h"
Phil Burka9876702020-04-20 18:16:15 -070030#include "core/AudioGlobal.h"
Phil Burkc0c70e32017-02-09 13:18:38 -080031#include "utility/AudioClock.h"
32
Phil Burk39f02dd2017-08-04 09:13:31 -070033#include "AAudioEndpointManager.h"
34#include "AAudioService.h"
35#include "AAudioServiceEndpoint.h"
Phil Burkc0c70e32017-02-09 13:18:38 -080036#include "AAudioServiceStreamBase.h"
37#include "TimestampScheduler.h"
38
39using namespace android; // TODO just import names needed
40using namespace aaudio; // TODO just import names needed
Phil Burk2355edb2016-12-26 13:54:02 -080041
Philip P. Moltmannbda45752020-07-17 16:41:18 -070042using media::permission::Identity;
43
Phil Burk2355edb2016-12-26 13:54:02 -080044/**
Phil Burkc0c70e32017-02-09 13:18:38 -080045 * Base class for streams in the service.
46 * @return
Phil Burk2355edb2016-12-26 13:54:02 -080047 */
48
Phil Burk39f02dd2017-08-04 09:13:31 -070049AAudioServiceStreamBase::AAudioServiceStreamBase(AAudioService &audioService)
Phil Burk8f4fe502020-07-15 23:54:50 +000050 : mTimestampThread("AATime")
Phil Burka53ffa62018-10-10 16:21:37 -070051 , mAtomicStreamTimestamp()
Phil Burk39f02dd2017-08-04 09:13:31 -070052 , mAudioService(audioService) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -070053 mMmapClient.identity = Identity();
Phil Burk2355edb2016-12-26 13:54:02 -080054}
55
Phil Burk5ed503c2017-02-01 09:38:15 -080056AAudioServiceStreamBase::~AAudioServiceStreamBase() {
Phil Burk8f4fe502020-07-15 23:54:50 +000057 ALOGD("%s() called", __func__);
58
Phil Burka9876702020-04-20 18:16:15 -070059 // May not be set if open failed.
60 if (mMetricsId.size() > 0) {
61 mediametrics::LogItem(mMetricsId)
62 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_DTOR)
63 .set(AMEDIAMETRICS_PROP_STATE, AudioGlobal_convertStreamStateToText(getState()))
64 .record();
65 }
66
Phil Burk5a26e662017-07-07 12:44:48 -070067 // If the stream is deleted when OPEN or in use then audio resources will leak.
68 // This would indicate an internal error. So we want to find this ASAP.
Phil Burkbcc36742017-08-31 17:24:51 -070069 LOG_ALWAYS_FATAL_IF(!(getState() == AAUDIO_STREAM_STATE_CLOSED
Phil Burkdb466142021-04-16 16:50:00 +000070 || getState() == AAUDIO_STREAM_STATE_UNINITIALIZED),
Phil Burk8b4e05e2019-12-17 12:12:09 -080071 "service stream %p still open, state = %d",
72 this, getState());
Phil Burk2355edb2016-12-26 13:54:02 -080073}
74
Phil Burka5222e22017-07-28 13:31:14 -070075std::string AAudioServiceStreamBase::dumpHeader() {
Phil Burkbbd52862018-04-13 11:37:42 -070076 return std::string(" T Handle UId Port Run State Format Burst Chan Capacity");
Phil Burka5222e22017-07-28 13:31:14 -070077}
78
Phil Burk4501b352017-06-29 18:12:36 -070079std::string AAudioServiceStreamBase::dump() const {
80 std::stringstream result;
81
Phil Burka5222e22017-07-28 13:31:14 -070082 result << " 0x" << std::setfill('0') << std::setw(8) << std::hex << mHandle
83 << std::dec << std::setfill(' ') ;
Philip P. Moltmannbda45752020-07-17 16:41:18 -070084 result << std::setw(6) << mMmapClient.identity.uid;
Phil Burkbbd52862018-04-13 11:37:42 -070085 result << std::setw(7) << mClientHandle;
Phil Burka5222e22017-07-28 13:31:14 -070086 result << std::setw(4) << (isRunning() ? "yes" : " no");
Phil Burkbcc36742017-08-31 17:24:51 -070087 result << std::setw(6) << getState();
Phil Burk39f02dd2017-08-04 09:13:31 -070088 result << std::setw(7) << getFormat();
Phil Burka5222e22017-07-28 13:31:14 -070089 result << std::setw(6) << mFramesPerBurst;
Phil Burk39f02dd2017-08-04 09:13:31 -070090 result << std::setw(5) << getSamplesPerFrame();
91 result << std::setw(9) << getBufferCapacity();
Phil Burk4501b352017-06-29 18:12:36 -070092
93 return result.str();
94}
95
Phil Burka9876702020-04-20 18:16:15 -070096void AAudioServiceStreamBase::logOpen(aaudio_handle_t streamHandle) {
97 // This is the first log sent from the AAudio Service for a stream.
98 mMetricsId = std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_STREAM)
99 + std::to_string(streamHandle);
100
101 audio_attributes_t attributes = AAudioServiceEndpoint::getAudioAttributesFrom(this);
102
103 // Once this item is logged by the server, the client with the same PID, UID
104 // can also log properties.
105 mediametrics::LogItem(mMetricsId)
106 .setPid(getOwnerProcessId())
107 .setUid(getOwnerUserId())
Andy Hungd203eb62020-04-27 09:12:46 -0700108 .set(AMEDIAMETRICS_PROP_ALLOWUID, (int32_t)getOwnerUserId())
Phil Burka9876702020-04-20 18:16:15 -0700109 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_OPEN)
110 // the following are immutable
111 .set(AMEDIAMETRICS_PROP_BUFFERCAPACITYFRAMES, (int32_t)getBufferCapacity())
112 .set(AMEDIAMETRICS_PROP_BURSTFRAMES, (int32_t)getFramesPerBurst())
113 .set(AMEDIAMETRICS_PROP_CHANNELCOUNT, (int32_t)getSamplesPerFrame())
114 .set(AMEDIAMETRICS_PROP_CONTENTTYPE, toString(attributes.content_type).c_str())
115 .set(AMEDIAMETRICS_PROP_DIRECTION,
116 AudioGlobal_convertDirectionToText(getDirection()))
117 .set(AMEDIAMETRICS_PROP_ENCODING, toString(getFormat()).c_str())
118 .set(AMEDIAMETRICS_PROP_ROUTEDDEVICEID, (int32_t)getDeviceId())
119 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)getSampleRate())
120 .set(AMEDIAMETRICS_PROP_SESSIONID, (int32_t)getSessionId())
121 .set(AMEDIAMETRICS_PROP_SOURCE, toString(attributes.source).c_str())
122 .set(AMEDIAMETRICS_PROP_USAGE, toString(attributes.usage).c_str())
123 .record();
124}
125
Phil Burk15f97c92018-09-04 14:06:27 -0700126aaudio_result_t AAudioServiceStreamBase::open(const aaudio::AAudioStreamRequest &request) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700127 AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
128 aaudio_result_t result = AAUDIO_OK;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700129
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700130 mMmapClient.identity = request.getIdentity();
131 // TODO b/182392769: use identity util
132 mMmapClient.identity.uid = VALUE_OR_FATAL(
133 legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
134 mMmapClient.identity.pid = VALUE_OR_FATAL(
135 legacy2aidl_pid_t_int32_t(IPCThreadState::self()->getCallingPid()));
Eric Laurentcb4dae22017-07-01 19:39:32 -0700136
Phil Burk39f02dd2017-08-04 09:13:31 -0700137 // Limit scope of lock to avoid recursive lock in close().
138 {
139 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
140 if (mUpMessageQueue != nullptr) {
Phil Burk19e990e2018-03-22 13:59:34 -0700141 ALOGE("%s() called twice", __func__);
Phil Burk39f02dd2017-08-04 09:13:31 -0700142 return AAUDIO_ERROR_INVALID_STATE;
143 }
144
Phil Burk8f4fe502020-07-15 23:54:50 +0000145 mUpMessageQueue = std::make_shared<SharedRingBuffer>();
Phil Burk39f02dd2017-08-04 09:13:31 -0700146 result = mUpMessageQueue->allocate(sizeof(AAudioServiceMessage),
147 QUEUE_UP_CAPACITY_COMMANDS);
148 if (result != AAUDIO_OK) {
149 goto error;
150 }
151
Phil Burk6e2770e2018-05-01 13:03:52 -0700152 // This is not protected by a lock because the stream cannot be
153 // referenced until the service returns a handle to the client.
154 // So only one thread can open a stream.
Phil Burk39f02dd2017-08-04 09:13:31 -0700155 mServiceEndpoint = mEndpointManager.openEndpoint(mAudioService,
Phil Burk15f97c92018-09-04 14:06:27 -0700156 request);
Phil Burk39f02dd2017-08-04 09:13:31 -0700157 if (mServiceEndpoint == nullptr) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700158 result = AAUDIO_ERROR_UNAVAILABLE;
159 goto error;
160 }
Phil Burk6e2770e2018-05-01 13:03:52 -0700161 // Save a weak pointer that we will use to access the endpoint.
162 mServiceEndpointWeak = mServiceEndpoint;
163
Phil Burk39f02dd2017-08-04 09:13:31 -0700164 mFramesPerBurst = mServiceEndpoint->getFramesPerBurst();
165 copyFrom(*mServiceEndpoint);
Phil Burkc0c70e32017-02-09 13:18:38 -0800166 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700167 return result;
168
169error:
170 close();
171 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800172}
Phil Burkdec33ab2017-01-17 14:48:16 -0800173
Phil Burkc0c70e32017-02-09 13:18:38 -0800174aaudio_result_t AAudioServiceStreamBase::close() {
Phil Burk7ebbc112020-05-13 15:55:17 -0700175 std::lock_guard<std::mutex> lock(mLock);
176 return close_l();
177}
178
179aaudio_result_t AAudioServiceStreamBase::close_l() {
Phil Burkbcc36742017-08-31 17:24:51 -0700180 if (getState() == AAUDIO_STREAM_STATE_CLOSED) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700181 return AAUDIO_OK;
182 }
183
Phil Burk8f4fe502020-07-15 23:54:50 +0000184 // This will call stopTimestampThread() and also stop the stream,
185 // just in case it was not already stopped.
Phil Burk7ebbc112020-05-13 15:55:17 -0700186 stop_l();
Phil Burk39f02dd2017-08-04 09:13:31 -0700187
Phil Burk8b4e05e2019-12-17 12:12:09 -0800188 aaudio_result_t result = AAUDIO_OK;
Phil Burk6e2770e2018-05-01 13:03:52 -0700189 sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
190 if (endpoint == nullptr) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700191 result = AAUDIO_ERROR_INVALID_STATE;
192 } else {
Phil Burk6e2770e2018-05-01 13:03:52 -0700193 endpoint->unregisterStream(this);
194 AAudioEndpointManager &endpointManager = AAudioEndpointManager::getInstance();
195 endpointManager.closeEndpoint(endpoint);
196
197 // AAudioService::closeStream() prevents two threads from closing at the same time.
Phil Burk7ebbc112020-05-13 15:55:17 -0700198 mServiceEndpoint.clear(); // endpoint will hold the pointer after this method returns.
Phil Burk39f02dd2017-08-04 09:13:31 -0700199 }
200
Phil Burkbcc36742017-08-31 17:24:51 -0700201 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burka9876702020-04-20 18:16:15 -0700202
203 mediametrics::LogItem(mMetricsId)
204 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CLOSE)
205 .record();
Phil Burk39f02dd2017-08-04 09:13:31 -0700206 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800207}
208
Phil Burkbcc36742017-08-31 17:24:51 -0700209aaudio_result_t AAudioServiceStreamBase::startDevice() {
210 mClientHandle = AUDIO_PORT_HANDLE_NONE;
Phil Burk6e2770e2018-05-01 13:03:52 -0700211 sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
212 if (endpoint == nullptr) {
213 ALOGE("%s() has no endpoint", __func__);
214 return AAUDIO_ERROR_INVALID_STATE;
215 }
216 return endpoint->startStream(this, &mClientHandle);
Phil Burkbcc36742017-08-31 17:24:51 -0700217}
218
Phil Burk39f02dd2017-08-04 09:13:31 -0700219/**
220 * Start the flow of audio data.
221 *
222 * An AAUDIO_SERVICE_EVENT_STARTED will be sent to the client when complete.
223 */
Phil Burkc0c70e32017-02-09 13:18:38 -0800224aaudio_result_t AAudioServiceStreamBase::start() {
Phil Burk7ebbc112020-05-13 15:55:17 -0700225 std::lock_guard<std::mutex> lock(mLock);
226
Phil Burka9876702020-04-20 18:16:15 -0700227 const int64_t beginNs = AudioClock::getNanoseconds();
Phil Burkbcc36742017-08-31 17:24:51 -0700228 aaudio_result_t result = AAUDIO_OK;
Phil Burk6e2770e2018-05-01 13:03:52 -0700229
Phil Burk7ebbc112020-05-13 15:55:17 -0700230 if (auto state = getState();
Phil Burkdb466142021-04-16 16:50:00 +0000231 state == AAUDIO_STREAM_STATE_CLOSED || isDisconnected_l()) {
Phil Burk7ebbc112020-05-13 15:55:17 -0700232 ALOGW("%s() already CLOSED, returns INVALID_STATE, handle = %d",
233 __func__, getHandle());
234 return AAUDIO_ERROR_INVALID_STATE;
235 }
236
Phil Burka9876702020-04-20 18:16:15 -0700237 mediametrics::Defer defer([&] {
238 mediametrics::LogItem(mMetricsId)
239 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_START)
Andy Hungea840382020-05-05 21:50:17 -0700240 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(AudioClock::getNanoseconds() - beginNs))
Phil Burka9876702020-04-20 18:16:15 -0700241 .set(AMEDIAMETRICS_PROP_STATE, AudioGlobal_convertStreamStateToText(getState()))
242 .set(AMEDIAMETRICS_PROP_STATUS, (int32_t)result)
243 .record(); });
244
Eric Laurentcb4dae22017-07-01 19:39:32 -0700245 if (isRunning()) {
Phil Burk7ebbc112020-05-13 15:55:17 -0700246 return result;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700247 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700248
Phil Burk23296382017-11-20 15:45:11 -0800249 setFlowing(false);
Phil Burk762365c2018-12-10 16:02:16 -0800250 setSuspended(false);
Phil Burk23296382017-11-20 15:45:11 -0800251
Phil Burkbcc36742017-08-31 17:24:51 -0700252 // Start with fresh presentation timestamps.
Phil Burka53ffa62018-10-10 16:21:37 -0700253 mAtomicStreamTimestamp.clear();
Phil Burkbcc36742017-08-31 17:24:51 -0700254
Phil Burk39f02dd2017-08-04 09:13:31 -0700255 mClientHandle = AUDIO_PORT_HANDLE_NONE;
Phil Burkbcc36742017-08-31 17:24:51 -0700256 result = startDevice();
257 if (result != AAUDIO_OK) goto error;
258
259 // This should happen at the end of the start.
260 sendServiceEvent(AAUDIO_SERVICE_EVENT_STARTED);
261 setState(AAUDIO_STREAM_STATE_STARTED);
262 mThreadEnabled.store(true);
263 result = mTimestampThread.start(this);
264 if (result != AAUDIO_OK) goto error;
265
266 return result;
267
268error:
Phil Burk7ebbc112020-05-13 15:55:17 -0700269 disconnect_l();
Phil Burk39f02dd2017-08-04 09:13:31 -0700270 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800271}
272
273aaudio_result_t AAudioServiceStreamBase::pause() {
Phil Burk7ebbc112020-05-13 15:55:17 -0700274 std::lock_guard<std::mutex> lock(mLock);
275 return pause_l();
276}
277
278aaudio_result_t AAudioServiceStreamBase::pause_l() {
Phil Burk11e8d332017-05-24 09:59:02 -0700279 aaudio_result_t result = AAUDIO_OK;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700280 if (!isRunning()) {
281 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800282 }
Phil Burk7ebbc112020-05-13 15:55:17 -0700283 const int64_t beginNs = AudioClock::getNanoseconds();
Phil Burk73af62a2017-10-26 12:11:47 -0700284
Phil Burka9876702020-04-20 18:16:15 -0700285 mediametrics::Defer defer([&] {
286 mediametrics::LogItem(mMetricsId)
287 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_PAUSE)
Andy Hungea840382020-05-05 21:50:17 -0700288 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(AudioClock::getNanoseconds() - beginNs))
Phil Burka9876702020-04-20 18:16:15 -0700289 .set(AMEDIAMETRICS_PROP_STATE, AudioGlobal_convertStreamStateToText(getState()))
290 .set(AMEDIAMETRICS_PROP_STATUS, (int32_t)result)
291 .record(); });
292
Phil Burk73af62a2017-10-26 12:11:47 -0700293 result = stopTimestampThread();
294 if (result != AAUDIO_OK) {
Phil Burk7ebbc112020-05-13 15:55:17 -0700295 disconnect_l();
Phil Burk73af62a2017-10-26 12:11:47 -0700296 return result;
297 }
298
Phil Burk6e2770e2018-05-01 13:03:52 -0700299 sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
300 if (endpoint == nullptr) {
301 ALOGE("%s() has no endpoint", __func__);
Phil Burka9876702020-04-20 18:16:15 -0700302 result = AAUDIO_ERROR_INVALID_STATE; // for MediaMetric tracking
303 return result;
Phil Burk6e2770e2018-05-01 13:03:52 -0700304 }
305 result = endpoint->stopStream(this, mClientHandle);
Phil Burk39f02dd2017-08-04 09:13:31 -0700306 if (result != AAUDIO_OK) {
Phil Burk19e990e2018-03-22 13:59:34 -0700307 ALOGE("%s() mServiceEndpoint returned %d, %s", __func__, result, getTypeText());
Phil Burk7ebbc112020-05-13 15:55:17 -0700308 disconnect_l(); // TODO should we return or pause Base first?
Phil Burk39f02dd2017-08-04 09:13:31 -0700309 }
310
Eric Laurentcb4dae22017-07-01 19:39:32 -0700311 sendServiceEvent(AAUDIO_SERVICE_EVENT_PAUSED);
Phil Burkbcc36742017-08-31 17:24:51 -0700312 setState(AAUDIO_STREAM_STATE_PAUSED);
Phil Burkc0c70e32017-02-09 13:18:38 -0800313 return result;
314}
315
Phil Burk71f35bb2017-04-13 16:05:07 -0700316aaudio_result_t AAudioServiceStreamBase::stop() {
Phil Burk7ebbc112020-05-13 15:55:17 -0700317 std::lock_guard<std::mutex> lock(mLock);
318 return stop_l();
319}
320
321aaudio_result_t AAudioServiceStreamBase::stop_l() {
Phil Burk11e8d332017-05-24 09:59:02 -0700322 aaudio_result_t result = AAUDIO_OK;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700323 if (!isRunning()) {
324 return result;
Phil Burk71f35bb2017-04-13 16:05:07 -0700325 }
Phil Burk7ebbc112020-05-13 15:55:17 -0700326 const int64_t beginNs = AudioClock::getNanoseconds();
Phil Burk39f02dd2017-08-04 09:13:31 -0700327
Phil Burka9876702020-04-20 18:16:15 -0700328 mediametrics::Defer defer([&] {
329 mediametrics::LogItem(mMetricsId)
330 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_STOP)
Andy Hungea840382020-05-05 21:50:17 -0700331 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(AudioClock::getNanoseconds() - beginNs))
Phil Burka9876702020-04-20 18:16:15 -0700332 .set(AMEDIAMETRICS_PROP_STATE, AudioGlobal_convertStreamStateToText(getState()))
333 .set(AMEDIAMETRICS_PROP_STATUS, (int32_t)result)
334 .record(); });
335
Phil Burk83fb8442017-10-05 16:55:17 -0700336 setState(AAUDIO_STREAM_STATE_STOPPING);
337
Phil Burkd50ae622021-04-15 23:40:25 +0000338 // Temporarily unlock because we are joining the timestamp thread and it may try
339 // to acquire mLock.
340 mLock.unlock();
Eric Laurentcb4dae22017-07-01 19:39:32 -0700341 result = stopTimestampThread();
Phil Burkd50ae622021-04-15 23:40:25 +0000342 mLock.lock();
343
Eric Laurentcb4dae22017-07-01 19:39:32 -0700344 if (result != AAUDIO_OK) {
Phil Burk7ebbc112020-05-13 15:55:17 -0700345 disconnect_l();
Eric Laurentcb4dae22017-07-01 19:39:32 -0700346 return result;
347 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700348
Phil Burk6e2770e2018-05-01 13:03:52 -0700349 sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
350 if (endpoint == nullptr) {
351 ALOGE("%s() has no endpoint", __func__);
Phil Burka9876702020-04-20 18:16:15 -0700352 result = AAUDIO_ERROR_INVALID_STATE; // for MediaMetric tracking
353 return result;
Phil Burk6e2770e2018-05-01 13:03:52 -0700354 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700355 // TODO wait for data to be played out
Phil Burk6e2770e2018-05-01 13:03:52 -0700356 result = endpoint->stopStream(this, mClientHandle);
Phil Burk39f02dd2017-08-04 09:13:31 -0700357 if (result != AAUDIO_OK) {
Phil Burk6e2770e2018-05-01 13:03:52 -0700358 ALOGE("%s() stopStream returned %d, %s", __func__, result, getTypeText());
Phil Burk7ebbc112020-05-13 15:55:17 -0700359 disconnect_l();
Phil Burk39f02dd2017-08-04 09:13:31 -0700360 // TODO what to do with result here?
361 }
362
Eric Laurentcb4dae22017-07-01 19:39:32 -0700363 sendServiceEvent(AAUDIO_SERVICE_EVENT_STOPPED);
Phil Burkbcc36742017-08-31 17:24:51 -0700364 setState(AAUDIO_STREAM_STATE_STOPPED);
Phil Burk71f35bb2017-04-13 16:05:07 -0700365 return result;
366}
367
Phil Burk98d6d922017-07-06 11:52:45 -0700368aaudio_result_t AAudioServiceStreamBase::stopTimestampThread() {
369 aaudio_result_t result = AAUDIO_OK;
370 // clear flag that tells thread to loop
371 if (mThreadEnabled.exchange(false)) {
Phil Burkbcc36742017-08-31 17:24:51 -0700372 result = mTimestampThread.stop();
Phil Burk98d6d922017-07-06 11:52:45 -0700373 }
374 return result;
375}
376
Phil Burk71f35bb2017-04-13 16:05:07 -0700377aaudio_result_t AAudioServiceStreamBase::flush() {
Phil Burk7ebbc112020-05-13 15:55:17 -0700378 std::lock_guard<std::mutex> lock(mLock);
Phil Burk5cc83c32017-11-28 15:43:18 -0800379 aaudio_result_t result = AAudio_isFlushAllowed(getState());
380 if (result != AAUDIO_OK) {
381 return result;
Phil Burk39f02dd2017-08-04 09:13:31 -0700382 }
Phil Burk7ebbc112020-05-13 15:55:17 -0700383 const int64_t beginNs = AudioClock::getNanoseconds();
Phil Burk5cc83c32017-11-28 15:43:18 -0800384
Phil Burka9876702020-04-20 18:16:15 -0700385 mediametrics::Defer defer([&] {
386 mediametrics::LogItem(mMetricsId)
387 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_FLUSH)
Andy Hungea840382020-05-05 21:50:17 -0700388 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(AudioClock::getNanoseconds() - beginNs))
Phil Burka9876702020-04-20 18:16:15 -0700389 .set(AMEDIAMETRICS_PROP_STATE, AudioGlobal_convertStreamStateToText(getState()))
390 .set(AMEDIAMETRICS_PROP_STATUS, (int32_t)result)
391 .record(); });
392
Phil Burk39f02dd2017-08-04 09:13:31 -0700393 // Data will get flushed when the client receives the FLUSHED event.
Phil Burk71f35bb2017-04-13 16:05:07 -0700394 sendServiceEvent(AAUDIO_SERVICE_EVENT_FLUSHED);
Phil Burkbcc36742017-08-31 17:24:51 -0700395 setState(AAUDIO_STREAM_STATE_FLUSHED);
Phil Burk71f35bb2017-04-13 16:05:07 -0700396 return AAUDIO_OK;
397}
398
Phil Burkcf5f6d22017-05-26 12:35:07 -0700399// implement Runnable, periodically send timestamps to client
Phil Burka53ffa62018-10-10 16:21:37 -0700400__attribute__((no_sanitize("integer")))
Phil Burkc0c70e32017-02-09 13:18:38 -0800401void AAudioServiceStreamBase::run() {
Phil Burk19e990e2018-03-22 13:59:34 -0700402 ALOGD("%s() %s entering >>>>>>>>>>>>>> TIMESTAMPS", __func__, getTypeText());
Phil Burkc0c70e32017-02-09 13:18:38 -0800403 TimestampScheduler timestampScheduler;
Phil Burk39f02dd2017-08-04 09:13:31 -0700404 timestampScheduler.setBurstPeriod(mFramesPerBurst, getSampleRate());
Phil Burkc0c70e32017-02-09 13:18:38 -0800405 timestampScheduler.start(AudioClock::getNanoseconds());
406 int64_t nextTime = timestampScheduler.nextAbsoluteTime();
Phil Burka53ffa62018-10-10 16:21:37 -0700407 int32_t loopCount = 0;
Phil Burk45da1b72021-04-07 06:30:50 +0000408 aaudio_result_t result = AAUDIO_OK;
Phil Burkc0c70e32017-02-09 13:18:38 -0800409 while(mThreadEnabled.load()) {
Phil Burka53ffa62018-10-10 16:21:37 -0700410 loopCount++;
Phil Burkc0c70e32017-02-09 13:18:38 -0800411 if (AudioClock::getNanoseconds() >= nextTime) {
Phil Burk45da1b72021-04-07 06:30:50 +0000412 result = sendCurrentTimestamp();
Phil Burkc0c70e32017-02-09 13:18:38 -0800413 if (result != AAUDIO_OK) {
Phil Burka53ffa62018-10-10 16:21:37 -0700414 ALOGE("%s() timestamp thread got result = %d", __func__, result);
Phil Burkc0c70e32017-02-09 13:18:38 -0800415 break;
416 }
417 nextTime = timestampScheduler.nextAbsoluteTime();
418 } else {
419 // Sleep until it is time to send the next timestamp.
Phil Burk98d6d922017-07-06 11:52:45 -0700420 // TODO Wait for a signal with a timeout so that we can stop more quickly.
Phil Burkc0c70e32017-02-09 13:18:38 -0800421 AudioClock::sleepUntilNanoTime(nextTime);
422 }
423 }
Phil Burk45da1b72021-04-07 06:30:50 +0000424 // This was moved from the calls in stop_l() and pause_l(), which could cause a deadlock
425 // if it resulted in a call to disconnect.
426 if (result == AAUDIO_OK) {
427 (void) sendCurrentTimestamp();
428 }
Phil Burka53ffa62018-10-10 16:21:37 -0700429 ALOGD("%s() %s exiting after %d loops <<<<<<<<<<<<<< TIMESTAMPS",
430 __func__, getTypeText(), loopCount);
Phil Burkc0c70e32017-02-09 13:18:38 -0800431}
432
Phil Burk5ef003b2017-06-30 11:43:37 -0700433void AAudioServiceStreamBase::disconnect() {
Phil Burk7ebbc112020-05-13 15:55:17 -0700434 std::lock_guard<std::mutex> lock(mLock);
435 disconnect_l();
436}
437
438void AAudioServiceStreamBase::disconnect_l() {
Phil Burkdb466142021-04-16 16:50:00 +0000439 if (!isDisconnected_l() && getState() != AAUDIO_STREAM_STATE_CLOSED) {
Phil Burk7ebbc112020-05-13 15:55:17 -0700440
Phil Burka9876702020-04-20 18:16:15 -0700441 mediametrics::LogItem(mMetricsId)
442 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_DISCONNECT)
443 .set(AMEDIAMETRICS_PROP_STATE, AudioGlobal_convertStreamStateToText(getState()))
444 .record();
Phil Burk7ebbc112020-05-13 15:55:17 -0700445
Phil Burk5ef003b2017-06-30 11:43:37 -0700446 sendServiceEvent(AAUDIO_SERVICE_EVENT_DISCONNECTED);
Phil Burkdb466142021-04-16 16:50:00 +0000447 setDisconnected_l(true);
Phil Burk5ef003b2017-06-30 11:43:37 -0700448 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800449}
450
Phil Burk7ebbc112020-05-13 15:55:17 -0700451aaudio_result_t AAudioServiceStreamBase::registerAudioThread(pid_t clientThreadId,
452 int priority) {
453 std::lock_guard<std::mutex> lock(mLock);
454 aaudio_result_t result = AAUDIO_OK;
455 if (getRegisteredThread() != AAudioServiceStreamBase::ILLEGAL_THREAD_ID) {
456 ALOGE("AAudioService::registerAudioThread(), thread already registered");
457 result = AAUDIO_ERROR_INVALID_STATE;
458 } else {
459 const pid_t ownerPid = IPCThreadState::self()->getCallingPid(); // TODO review
460 setRegisteredThread(clientThreadId);
461 int err = android::requestPriority(ownerPid, clientThreadId,
462 priority, true /* isForApp */);
463 if (err != 0) {
464 ALOGE("AAudioService::registerAudioThread(%d) failed, errno = %d, priority = %d",
465 clientThreadId, errno, priority);
466 result = AAUDIO_ERROR_INTERNAL;
467 }
468 }
469 return result;
470}
471
472aaudio_result_t AAudioServiceStreamBase::unregisterAudioThread(pid_t clientThreadId) {
473 std::lock_guard<std::mutex> lock(mLock);
474 aaudio_result_t result = AAUDIO_OK;
475 if (getRegisteredThread() != clientThreadId) {
476 ALOGE("%s(), wrong thread", __func__);
477 result = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
478 } else {
479 setRegisteredThread(0);
480 }
481 return result;
482}
483
484void AAudioServiceStreamBase::setState(aaudio_stream_state_t state) {
485 // CLOSED is a final state.
486 if (mState != AAUDIO_STREAM_STATE_CLOSED) {
487 mState = state;
488 } else {
489 ALOGW_IF(mState != state, "%s(%d) when already CLOSED", __func__, state);
490 }
491}
492
Phil Burkc0c70e32017-02-09 13:18:38 -0800493aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
Phil Burk23296382017-11-20 15:45:11 -0800494 double dataDouble) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800495 AAudioServiceMessage command;
496 command.what = AAudioServiceMessage::code::EVENT;
Phil Burk2355edb2016-12-26 13:54:02 -0800497 command.event.event = event;
Phil Burkc0c70e32017-02-09 13:18:38 -0800498 command.event.dataDouble = dataDouble;
Phil Burk23296382017-11-20 15:45:11 -0800499 return writeUpMessageQueue(&command);
500}
501
502aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
503 int64_t dataLong) {
504 AAudioServiceMessage command;
505 command.what = AAudioServiceMessage::code::EVENT;
506 command.event.event = event;
Phil Burkc0c70e32017-02-09 13:18:38 -0800507 command.event.dataLong = dataLong;
508 return writeUpMessageQueue(&command);
509}
510
Phil Burkf878a8d2019-03-29 17:23:00 -0700511bool AAudioServiceStreamBase::isUpMessageQueueBusy() {
512 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
513 if (mUpMessageQueue == nullptr) {
514 ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
515 return true;
516 }
Phil Burkf878a8d2019-03-29 17:23:00 -0700517 // Is it half full or more
Phil Burk8f4fe502020-07-15 23:54:50 +0000518 return mUpMessageQueue->getFractionalFullness() >= 0.5;
Phil Burkf878a8d2019-03-29 17:23:00 -0700519}
520
Phil Burkc0c70e32017-02-09 13:18:38 -0800521aaudio_result_t AAudioServiceStreamBase::writeUpMessageQueue(AAudioServiceMessage *command) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700522 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
Phil Burk71f35bb2017-04-13 16:05:07 -0700523 if (mUpMessageQueue == nullptr) {
Phil Burk19e990e2018-03-22 13:59:34 -0700524 ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
Phil Burk71f35bb2017-04-13 16:05:07 -0700525 return AAUDIO_ERROR_NULL;
526 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800527 int32_t count = mUpMessageQueue->getFifoBuffer()->write(command, 1);
528 if (count != 1) {
Phil Burk762365c2018-12-10 16:02:16 -0800529 ALOGW("%s(): Queue full. Did client stop? Suspending stream. what = %u, %s",
530 __func__, command->what, getTypeText());
531 setSuspended(true);
Phil Burkc0c70e32017-02-09 13:18:38 -0800532 return AAUDIO_ERROR_WOULD_BLOCK;
533 } else {
534 return AAUDIO_OK;
535 }
536}
537
Phil Burk23296382017-11-20 15:45:11 -0800538aaudio_result_t AAudioServiceStreamBase::sendXRunCount(int32_t xRunCount) {
539 return sendServiceEvent(AAUDIO_SERVICE_EVENT_XRUN, (int64_t) xRunCount);
540}
541
Phil Burkc0c70e32017-02-09 13:18:38 -0800542aaudio_result_t AAudioServiceStreamBase::sendCurrentTimestamp() {
543 AAudioServiceMessage command;
Phil Burkf878a8d2019-03-29 17:23:00 -0700544 // It is not worth filling up the queue with timestamps.
545 // That can cause the stream to get suspended.
546 // So just drop the timestamp if the queue is getting full.
547 if (isUpMessageQueueBusy()) {
548 return AAUDIO_OK;
549 }
550
Phil Burk97350f92017-07-21 15:59:44 -0700551 // Send a timestamp for the clock model.
Phil Burkc0c70e32017-02-09 13:18:38 -0800552 aaudio_result_t result = getFreeRunningPosition(&command.timestamp.position,
553 &command.timestamp.timestamp);
554 if (result == AAUDIO_OK) {
Phil Burk19e990e2018-03-22 13:59:34 -0700555 ALOGV("%s() SERVICE %8lld at %lld", __func__,
Phil Burkbcc36742017-08-31 17:24:51 -0700556 (long long) command.timestamp.position,
557 (long long) command.timestamp.timestamp);
Phil Burk97350f92017-07-21 15:59:44 -0700558 command.what = AAudioServiceMessage::code::TIMESTAMP_SERVICE;
Phil Burkc0c70e32017-02-09 13:18:38 -0800559 result = writeUpMessageQueue(&command);
Phil Burk97350f92017-07-21 15:59:44 -0700560
561 if (result == AAUDIO_OK) {
562 // Send a hardware timestamp for presentation time.
563 result = getHardwareTimestamp(&command.timestamp.position,
564 &command.timestamp.timestamp);
565 if (result == AAUDIO_OK) {
Phil Burk19e990e2018-03-22 13:59:34 -0700566 ALOGV("%s() HARDWARE %8lld at %lld", __func__,
Phil Burkbcc36742017-08-31 17:24:51 -0700567 (long long) command.timestamp.position,
568 (long long) command.timestamp.timestamp);
Phil Burk97350f92017-07-21 15:59:44 -0700569 command.what = AAudioServiceMessage::code::TIMESTAMP_HARDWARE;
570 result = writeUpMessageQueue(&command);
571 }
572 }
573 }
574
Phil Burkbcc36742017-08-31 17:24:51 -0700575 if (result == AAUDIO_ERROR_UNAVAILABLE) { // TODO review best error code
Phil Burk940083c2017-07-17 17:00:02 -0700576 result = AAUDIO_OK; // just not available yet, try again later
Phil Burkc0c70e32017-02-09 13:18:38 -0800577 }
578 return result;
Phil Burk2355edb2016-12-26 13:54:02 -0800579}
580
Phil Burkc0c70e32017-02-09 13:18:38 -0800581/**
582 * Get an immutable description of the in-memory queues
583 * used to communicate with the underlying HAL or Service.
584 */
585aaudio_result_t AAudioServiceStreamBase::getDescription(AudioEndpointParcelable &parcelable) {
Phil Burk7ebbc112020-05-13 15:55:17 -0700586 std::lock_guard<std::mutex> lock(mLock);
Phil Burk523b3042017-09-13 13:03:08 -0700587 {
588 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
589 if (mUpMessageQueue == nullptr) {
Phil Burk19e990e2018-03-22 13:59:34 -0700590 ALOGE("%s(): mUpMessageQueue null! - stream not open", __func__);
Phil Burk523b3042017-09-13 13:03:08 -0700591 return AAUDIO_ERROR_NULL;
592 }
593 // Gather information on the message queue.
594 mUpMessageQueue->fillParcelable(parcelable,
595 parcelable.mUpMessageQueueParcelable);
596 }
597 return getAudioDataDescription(parcelable);
Phil Burk11e8d332017-05-24 09:59:02 -0700598}
Phil Burk39f02dd2017-08-04 09:13:31 -0700599
600void AAudioServiceStreamBase::onVolumeChanged(float volume) {
601 sendServiceEvent(AAUDIO_SERVICE_EVENT_VOLUME, volume);
602}