blob: 91d32ec8e67e522d54ff88c60a9649755aa01b03 [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 Burkc0c70e32017-02-09 13:18:38 -080025#include "binding/IAAudioService.h"
26#include "binding/AAudioServiceMessage.h"
27#include "utility/AudioClock.h"
28
Phil Burk39f02dd2017-08-04 09:13:31 -070029#include "AAudioEndpointManager.h"
30#include "AAudioService.h"
31#include "AAudioServiceEndpoint.h"
Phil Burkc0c70e32017-02-09 13:18:38 -080032#include "AAudioServiceStreamBase.h"
33#include "TimestampScheduler.h"
34
35using namespace android; // TODO just import names needed
36using namespace aaudio; // TODO just import names needed
Phil Burk2355edb2016-12-26 13:54:02 -080037
38/**
Phil Burkc0c70e32017-02-09 13:18:38 -080039 * Base class for streams in the service.
40 * @return
Phil Burk2355edb2016-12-26 13:54:02 -080041 */
42
Phil Burk39f02dd2017-08-04 09:13:31 -070043AAudioServiceStreamBase::AAudioServiceStreamBase(AAudioService &audioService)
Phil Burk2355edb2016-12-26 13:54:02 -080044 : mUpMessageQueue(nullptr)
Phil Burkbcc36742017-08-31 17:24:51 -070045 , mTimestampThread()
Phil Burk39f02dd2017-08-04 09:13:31 -070046 , mAtomicTimestamp()
47 , mAudioService(audioService) {
Eric Laurentcb4dae22017-07-01 19:39:32 -070048 mMmapClient.clientUid = -1;
49 mMmapClient.clientPid = -1;
50 mMmapClient.packageName = String16("");
Phil Burk2355edb2016-12-26 13:54:02 -080051}
52
Phil Burk5ed503c2017-02-01 09:38:15 -080053AAudioServiceStreamBase::~AAudioServiceStreamBase() {
Phil Burkfbf031e2017-10-12 15:58:31 -070054 ALOGD("~AAudioServiceStreamBase() destroying %p", this);
Phil Burk5a26e662017-07-07 12:44:48 -070055 // If the stream is deleted when OPEN or in use then audio resources will leak.
56 // This would indicate an internal error. So we want to find this ASAP.
Phil Burkbcc36742017-08-31 17:24:51 -070057 LOG_ALWAYS_FATAL_IF(!(getState() == AAUDIO_STREAM_STATE_CLOSED
58 || getState() == AAUDIO_STREAM_STATE_UNINITIALIZED
59 || getState() == AAUDIO_STREAM_STATE_DISCONNECTED),
60 "service stream still open, state = %d", getState());
Phil Burk2355edb2016-12-26 13:54:02 -080061}
62
Phil Burka5222e22017-07-28 13:31:14 -070063std::string AAudioServiceStreamBase::dumpHeader() {
64 return std::string(" T Handle UId Run State Format Burst Chan Capacity");
65}
66
Phil Burk4501b352017-06-29 18:12:36 -070067std::string AAudioServiceStreamBase::dump() const {
68 std::stringstream result;
69
Phil Burka5222e22017-07-28 13:31:14 -070070 result << " 0x" << std::setfill('0') << std::setw(8) << std::hex << mHandle
71 << std::dec << std::setfill(' ') ;
72 result << std::setw(6) << mMmapClient.clientUid;
73 result << std::setw(4) << (isRunning() ? "yes" : " no");
Phil Burkbcc36742017-08-31 17:24:51 -070074 result << std::setw(6) << getState();
Phil Burk39f02dd2017-08-04 09:13:31 -070075 result << std::setw(7) << getFormat();
Phil Burka5222e22017-07-28 13:31:14 -070076 result << std::setw(6) << mFramesPerBurst;
Phil Burk39f02dd2017-08-04 09:13:31 -070077 result << std::setw(5) << getSamplesPerFrame();
78 result << std::setw(9) << getBufferCapacity();
Phil Burk4501b352017-06-29 18:12:36 -070079
80 return result.str();
81}
82
Phil Burkc0c70e32017-02-09 13:18:38 -080083aaudio_result_t AAudioServiceStreamBase::open(const aaudio::AAudioStreamRequest &request,
Phil Burk39f02dd2017-08-04 09:13:31 -070084 aaudio_sharing_mode_t sharingMode) {
85 AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
86 aaudio_result_t result = AAUDIO_OK;
Eric Laurentcb4dae22017-07-01 19:39:32 -070087
88 mMmapClient.clientUid = request.getUserId();
89 mMmapClient.clientPid = request.getProcessId();
Phil Burk39f02dd2017-08-04 09:13:31 -070090 mMmapClient.packageName.setTo(String16("")); // TODO What should we do here?
Eric Laurentcb4dae22017-07-01 19:39:32 -070091
Phil Burk39f02dd2017-08-04 09:13:31 -070092 // Limit scope of lock to avoid recursive lock in close().
93 {
94 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
95 if (mUpMessageQueue != nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -070096 ALOGE("open() called twice");
Phil Burk39f02dd2017-08-04 09:13:31 -070097 return AAUDIO_ERROR_INVALID_STATE;
98 }
99
Phil Burkc0c70e32017-02-09 13:18:38 -0800100 mUpMessageQueue = new SharedRingBuffer();
Phil Burk39f02dd2017-08-04 09:13:31 -0700101 result = mUpMessageQueue->allocate(sizeof(AAudioServiceMessage),
102 QUEUE_UP_CAPACITY_COMMANDS);
103 if (result != AAUDIO_OK) {
104 goto error;
105 }
106
107 mServiceEndpoint = mEndpointManager.openEndpoint(mAudioService,
108 request,
109 sharingMode);
110 if (mServiceEndpoint == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700111 ALOGE("open() openEndpoint() failed");
Phil Burk39f02dd2017-08-04 09:13:31 -0700112 result = AAUDIO_ERROR_UNAVAILABLE;
113 goto error;
114 }
115 mFramesPerBurst = mServiceEndpoint->getFramesPerBurst();
116 copyFrom(*mServiceEndpoint);
Phil Burkc0c70e32017-02-09 13:18:38 -0800117 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700118 return result;
119
120error:
121 close();
122 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800123}
Phil Burkdec33ab2017-01-17 14:48:16 -0800124
Phil Burkc0c70e32017-02-09 13:18:38 -0800125aaudio_result_t AAudioServiceStreamBase::close() {
Phil Burk39f02dd2017-08-04 09:13:31 -0700126 aaudio_result_t result = AAUDIO_OK;
Phil Burkbcc36742017-08-31 17:24:51 -0700127 if (getState() == AAUDIO_STREAM_STATE_CLOSED) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700128 return AAUDIO_OK;
129 }
130
131 stop();
132
133 if (mServiceEndpoint == nullptr) {
134 result = AAUDIO_ERROR_INVALID_STATE;
135 } else {
136 mServiceEndpoint->unregisterStream(this);
137 AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
138 mEndpointManager.closeEndpoint(mServiceEndpoint);
139 mServiceEndpoint.clear();
140 }
141
142 {
143 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
Phil Burk98d6d922017-07-06 11:52:45 -0700144 stopTimestampThread();
Phil Burk98d6d922017-07-06 11:52:45 -0700145 delete mUpMessageQueue;
146 mUpMessageQueue = nullptr;
Phil Burk98d6d922017-07-06 11:52:45 -0700147 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700148
Phil Burkbcc36742017-08-31 17:24:51 -0700149 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burk39f02dd2017-08-04 09:13:31 -0700150 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800151}
152
Phil Burkbcc36742017-08-31 17:24:51 -0700153aaudio_result_t AAudioServiceStreamBase::startDevice() {
154 mClientHandle = AUDIO_PORT_HANDLE_NONE;
155 return mServiceEndpoint->startStream(this, &mClientHandle);
156}
157
Phil Burk39f02dd2017-08-04 09:13:31 -0700158/**
159 * Start the flow of audio data.
160 *
161 * An AAUDIO_SERVICE_EVENT_STARTED will be sent to the client when complete.
162 */
Phil Burkc0c70e32017-02-09 13:18:38 -0800163aaudio_result_t AAudioServiceStreamBase::start() {
Phil Burkbcc36742017-08-31 17:24:51 -0700164 aaudio_result_t result = AAUDIO_OK;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700165 if (isRunning()) {
166 return AAUDIO_OK;
167 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700168
169 if (mServiceEndpoint == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700170 ALOGE("start() missing endpoint");
Phil Burkbcc36742017-08-31 17:24:51 -0700171 result = AAUDIO_ERROR_INVALID_STATE;
172 goto error;
Phil Burk39f02dd2017-08-04 09:13:31 -0700173 }
Phil Burkbcc36742017-08-31 17:24:51 -0700174
175 // Start with fresh presentation timestamps.
176 mAtomicTimestamp.clear();
177
Phil Burk39f02dd2017-08-04 09:13:31 -0700178 mClientHandle = AUDIO_PORT_HANDLE_NONE;
Phil Burkbcc36742017-08-31 17:24:51 -0700179 result = startDevice();
180 if (result != AAUDIO_OK) goto error;
181
182 // This should happen at the end of the start.
183 sendServiceEvent(AAUDIO_SERVICE_EVENT_STARTED);
184 setState(AAUDIO_STREAM_STATE_STARTED);
185 mThreadEnabled.store(true);
186 result = mTimestampThread.start(this);
187 if (result != AAUDIO_OK) goto error;
188
189 return result;
190
191error:
192 disconnect();
Phil Burk39f02dd2017-08-04 09:13:31 -0700193 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800194}
195
196aaudio_result_t AAudioServiceStreamBase::pause() {
Phil Burk11e8d332017-05-24 09:59:02 -0700197 aaudio_result_t result = AAUDIO_OK;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700198 if (!isRunning()) {
199 return result;
Phil Burkc0c70e32017-02-09 13:18:38 -0800200 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700201 if (mServiceEndpoint == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700202 ALOGE("pause() missing endpoint");
Phil Burk39f02dd2017-08-04 09:13:31 -0700203 return AAUDIO_ERROR_INVALID_STATE;
204 }
205 result = mServiceEndpoint->stopStream(this, mClientHandle);
206 if (result != AAUDIO_OK) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700207 ALOGE("pause() mServiceEndpoint returned %d", result);
Phil Burk39f02dd2017-08-04 09:13:31 -0700208 disconnect(); // TODO should we return or pause Base first?
209 }
210
Eric Laurentcb4dae22017-07-01 19:39:32 -0700211 sendCurrentTimestamp();
212 mThreadEnabled.store(false);
Phil Burkbcc36742017-08-31 17:24:51 -0700213 result = mTimestampThread.stop();
Eric Laurentcb4dae22017-07-01 19:39:32 -0700214 if (result != AAUDIO_OK) {
215 disconnect();
216 return result;
217 }
218 sendServiceEvent(AAUDIO_SERVICE_EVENT_PAUSED);
Phil Burkbcc36742017-08-31 17:24:51 -0700219 setState(AAUDIO_STREAM_STATE_PAUSED);
Phil Burkc0c70e32017-02-09 13:18:38 -0800220 return result;
221}
222
Phil Burk71f35bb2017-04-13 16:05:07 -0700223aaudio_result_t AAudioServiceStreamBase::stop() {
Phil Burk11e8d332017-05-24 09:59:02 -0700224 aaudio_result_t result = AAUDIO_OK;
Eric Laurentcb4dae22017-07-01 19:39:32 -0700225 if (!isRunning()) {
226 return result;
Phil Burk71f35bb2017-04-13 16:05:07 -0700227 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700228
229 if (mServiceEndpoint == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700230 ALOGE("stop() missing endpoint");
Phil Burk39f02dd2017-08-04 09:13:31 -0700231 return AAUDIO_ERROR_INVALID_STATE;
232 }
233
Phil Burk83fb8442017-10-05 16:55:17 -0700234 setState(AAUDIO_STREAM_STATE_STOPPING);
235
Eric Laurentcb4dae22017-07-01 19:39:32 -0700236 sendCurrentTimestamp(); // warning - this calls a virtual function
237 result = stopTimestampThread();
238 if (result != AAUDIO_OK) {
239 disconnect();
240 return result;
241 }
Phil Burk39f02dd2017-08-04 09:13:31 -0700242
243 // TODO wait for data to be played out
244 result = mServiceEndpoint->stopStream(this, mClientHandle);
245 if (result != AAUDIO_OK) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700246 ALOGE("stop() mServiceEndpoint returned %d", result);
Phil Burk39f02dd2017-08-04 09:13:31 -0700247 disconnect();
248 // TODO what to do with result here?
249 }
250
Eric Laurentcb4dae22017-07-01 19:39:32 -0700251 sendServiceEvent(AAUDIO_SERVICE_EVENT_STOPPED);
Phil Burkbcc36742017-08-31 17:24:51 -0700252 setState(AAUDIO_STREAM_STATE_STOPPED);
Phil Burk71f35bb2017-04-13 16:05:07 -0700253 return result;
254}
255
Phil Burk98d6d922017-07-06 11:52:45 -0700256aaudio_result_t AAudioServiceStreamBase::stopTimestampThread() {
257 aaudio_result_t result = AAUDIO_OK;
258 // clear flag that tells thread to loop
259 if (mThreadEnabled.exchange(false)) {
Phil Burkbcc36742017-08-31 17:24:51 -0700260 result = mTimestampThread.stop();
Phil Burk98d6d922017-07-06 11:52:45 -0700261 }
262 return result;
263}
264
Phil Burk71f35bb2017-04-13 16:05:07 -0700265aaudio_result_t AAudioServiceStreamBase::flush() {
Phil Burkbcc36742017-08-31 17:24:51 -0700266 if (getState() != AAUDIO_STREAM_STATE_PAUSED) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700267 ALOGE("flush() stream not paused, state = %s",
Phil Burk39f02dd2017-08-04 09:13:31 -0700268 AAudio_convertStreamStateToText(mState));
269 return AAUDIO_ERROR_INVALID_STATE;
270 }
271 // Data will get flushed when the client receives the FLUSHED event.
Phil Burk71f35bb2017-04-13 16:05:07 -0700272 sendServiceEvent(AAUDIO_SERVICE_EVENT_FLUSHED);
Phil Burkbcc36742017-08-31 17:24:51 -0700273 setState(AAUDIO_STREAM_STATE_FLUSHED);
Phil Burk71f35bb2017-04-13 16:05:07 -0700274 return AAUDIO_OK;
275}
276
Phil Burkcf5f6d22017-05-26 12:35:07 -0700277// implement Runnable, periodically send timestamps to client
Phil Burkc0c70e32017-02-09 13:18:38 -0800278void AAudioServiceStreamBase::run() {
Phil Burkfbf031e2017-10-12 15:58:31 -0700279 ALOGD("run() entering ----------------");
Phil Burkc0c70e32017-02-09 13:18:38 -0800280 TimestampScheduler timestampScheduler;
Phil Burk39f02dd2017-08-04 09:13:31 -0700281 timestampScheduler.setBurstPeriod(mFramesPerBurst, getSampleRate());
Phil Burkc0c70e32017-02-09 13:18:38 -0800282 timestampScheduler.start(AudioClock::getNanoseconds());
283 int64_t nextTime = timestampScheduler.nextAbsoluteTime();
284 while(mThreadEnabled.load()) {
285 if (AudioClock::getNanoseconds() >= nextTime) {
286 aaudio_result_t result = sendCurrentTimestamp();
287 if (result != AAUDIO_OK) {
288 break;
289 }
290 nextTime = timestampScheduler.nextAbsoluteTime();
291 } else {
292 // Sleep until it is time to send the next timestamp.
Phil Burk98d6d922017-07-06 11:52:45 -0700293 // TODO Wait for a signal with a timeout so that we can stop more quickly.
Phil Burkc0c70e32017-02-09 13:18:38 -0800294 AudioClock::sleepUntilNanoTime(nextTime);
295 }
296 }
Phil Burkfbf031e2017-10-12 15:58:31 -0700297 ALOGD("run() exiting ----------------");
Phil Burkc0c70e32017-02-09 13:18:38 -0800298}
299
Phil Burk5ef003b2017-06-30 11:43:37 -0700300void AAudioServiceStreamBase::disconnect() {
Phil Burkbcc36742017-08-31 17:24:51 -0700301 if (getState() != AAUDIO_STREAM_STATE_DISCONNECTED) {
Phil Burk5ef003b2017-06-30 11:43:37 -0700302 sendServiceEvent(AAUDIO_SERVICE_EVENT_DISCONNECTED);
Phil Burkbcc36742017-08-31 17:24:51 -0700303 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
Phil Burk5ef003b2017-06-30 11:43:37 -0700304 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800305}
306
307aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
308 double dataDouble,
309 int64_t dataLong) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800310 AAudioServiceMessage command;
311 command.what = AAudioServiceMessage::code::EVENT;
Phil Burk2355edb2016-12-26 13:54:02 -0800312 command.event.event = event;
Phil Burkc0c70e32017-02-09 13:18:38 -0800313 command.event.dataDouble = dataDouble;
314 command.event.dataLong = dataLong;
315 return writeUpMessageQueue(&command);
316}
317
318aaudio_result_t AAudioServiceStreamBase::writeUpMessageQueue(AAudioServiceMessage *command) {
Phil Burk39f02dd2017-08-04 09:13:31 -0700319 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
Phil Burk71f35bb2017-04-13 16:05:07 -0700320 if (mUpMessageQueue == nullptr) {
321 ALOGE("writeUpMessageQueue(): mUpMessageQueue null! - stream not open");
322 return AAUDIO_ERROR_NULL;
323 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800324 int32_t count = mUpMessageQueue->getFifoBuffer()->write(command, 1);
325 if (count != 1) {
326 ALOGE("writeUpMessageQueue(): Queue full. Did client die?");
327 return AAUDIO_ERROR_WOULD_BLOCK;
328 } else {
329 return AAUDIO_OK;
330 }
331}
332
333aaudio_result_t AAudioServiceStreamBase::sendCurrentTimestamp() {
334 AAudioServiceMessage command;
Phil Burk97350f92017-07-21 15:59:44 -0700335 // Send a timestamp for the clock model.
Phil Burkc0c70e32017-02-09 13:18:38 -0800336 aaudio_result_t result = getFreeRunningPosition(&command.timestamp.position,
337 &command.timestamp.timestamp);
338 if (result == AAUDIO_OK) {
Phil Burkbcc36742017-08-31 17:24:51 -0700339 ALOGV("sendCurrentTimestamp() SERVICE %8lld at %lld",
340 (long long) command.timestamp.position,
341 (long long) command.timestamp.timestamp);
Phil Burk97350f92017-07-21 15:59:44 -0700342 command.what = AAudioServiceMessage::code::TIMESTAMP_SERVICE;
Phil Burkc0c70e32017-02-09 13:18:38 -0800343 result = writeUpMessageQueue(&command);
Phil Burk97350f92017-07-21 15:59:44 -0700344
345 if (result == AAUDIO_OK) {
346 // Send a hardware timestamp for presentation time.
347 result = getHardwareTimestamp(&command.timestamp.position,
348 &command.timestamp.timestamp);
349 if (result == AAUDIO_OK) {
Phil Burkbcc36742017-08-31 17:24:51 -0700350 ALOGV("sendCurrentTimestamp() HARDWARE %8lld at %lld",
351 (long long) command.timestamp.position,
352 (long long) command.timestamp.timestamp);
Phil Burk97350f92017-07-21 15:59:44 -0700353 command.what = AAudioServiceMessage::code::TIMESTAMP_HARDWARE;
354 result = writeUpMessageQueue(&command);
355 }
356 }
357 }
358
Phil Burkbcc36742017-08-31 17:24:51 -0700359 if (result == AAUDIO_ERROR_UNAVAILABLE) { // TODO review best error code
Phil Burk940083c2017-07-17 17:00:02 -0700360 result = AAUDIO_OK; // just not available yet, try again later
Phil Burkc0c70e32017-02-09 13:18:38 -0800361 }
362 return result;
Phil Burk2355edb2016-12-26 13:54:02 -0800363}
364
Phil Burkc0c70e32017-02-09 13:18:38 -0800365/**
366 * Get an immutable description of the in-memory queues
367 * used to communicate with the underlying HAL or Service.
368 */
369aaudio_result_t AAudioServiceStreamBase::getDescription(AudioEndpointParcelable &parcelable) {
Phil Burk523b3042017-09-13 13:03:08 -0700370 {
371 std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
372 if (mUpMessageQueue == nullptr) {
373 ALOGE("getDescription(): mUpMessageQueue null! - stream not open");
374 return AAUDIO_ERROR_NULL;
375 }
376 // Gather information on the message queue.
377 mUpMessageQueue->fillParcelable(parcelable,
378 parcelable.mUpMessageQueueParcelable);
379 }
380 return getAudioDataDescription(parcelable);
Phil Burk11e8d332017-05-24 09:59:02 -0700381}
Phil Burk39f02dd2017-08-04 09:13:31 -0700382
383void AAudioServiceStreamBase::onVolumeChanged(float volume) {
384 sendServiceEvent(AAUDIO_SERVICE_EVENT_VOLUME, volume);
385}