1 /*
2 * Copyright (C) 2017 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
18 #define LOG_TAG "AAudioServiceEndpointShared"
19 //#define LOG_NDEBUG 0
20 #include <utils/Log.h>
21
22 #include <iomanip>
23 #include <iostream>
24 #include <sstream>
25
26 #include "binding/AAudioServiceMessage.h"
27 #include "client/AudioStreamInternal.h"
28 #include "client/AudioStreamInternalPlay.h"
29 #include "core/AudioStreamBuilder.h"
30
31 #include "AAudioServiceEndpointShared.h"
32 #include "AAudioServiceStreamShared.h"
33 #include "AAudioServiceStreamMMAP.h"
34 #include "AAudioMixer.h"
35 #include "AAudioService.h"
36
37 using namespace android;
38 using namespace aaudio;
39
40 // This is the maximum size in frames. The effective size can be tuned smaller at runtime.
41 #define DEFAULT_BUFFER_CAPACITY (48 * 8)
42
AAudioServiceEndpointShared(AudioStreamInternal * streamInternal)43 AAudioServiceEndpointShared::AAudioServiceEndpointShared(AudioStreamInternal *streamInternal)
44 : mStreamInternal(streamInternal) {}
45
dump() const46 std::string AAudioServiceEndpointShared::dump() const {
47 std::stringstream result;
48
49 result << " SHARED: sharing exclusive stream with handle = 0x"
50 << std::setfill('0') << std::setw(8)
51 << std::hex << mStreamInternal->getServiceHandle()
52 << std::dec << std::setfill(' ');
53 result << ", XRuns = " << mStreamInternal->getXRunCount();
54 result << "\n";
55 result << " Running Stream Count: " << mRunningStreamCount << "\n";
56
57 result << AAudioServiceEndpoint::dump();
58 return result.str();
59 }
60
61 // Share an AudioStreamInternal.
open(const aaudio::AAudioStreamRequest & request)62 aaudio_result_t AAudioServiceEndpointShared::open(const aaudio::AAudioStreamRequest &request) {
63 aaudio_result_t result = AAUDIO_OK;
64 const AAudioStreamConfiguration &configuration = request.getConstantConfiguration();
65
66 copyFrom(configuration);
67 mRequestedDeviceId = configuration.getDeviceId();
68
69 AudioStreamBuilder builder;
70 builder.copyFrom(configuration);
71
72 builder.setSharingMode(AAUDIO_SHARING_MODE_EXCLUSIVE);
73 // Don't fall back to SHARED because that would cause recursion.
74 builder.setSharingModeMatchRequired(true);
75
76 builder.setBufferCapacity(DEFAULT_BUFFER_CAPACITY);
77
78 result = mStreamInternal->open(builder);
79
80 setSampleRate(mStreamInternal->getSampleRate());
81 setChannelMask(mStreamInternal->getChannelMask());
82 setDeviceId(mStreamInternal->getDeviceId());
83 setSessionId(mStreamInternal->getSessionId());
84 setFormat(AUDIO_FORMAT_PCM_FLOAT); // force for mixer
85 setHardwareSampleRate(mStreamInternal->getHardwareSampleRate());
86 setHardwareFormat(mStreamInternal->getHardwareFormat());
87 setHardwareSamplesPerFrame(mStreamInternal->getHardwareSamplesPerFrame());
88 mFramesPerBurst = mStreamInternal->getFramesPerBurst();
89
90 return result;
91 }
92
close()93 void AAudioServiceEndpointShared::close() {
94 stopSharingThread();
95 getStreamInternal()->safeReleaseClose();
96 }
97
98 // Glue between C and C++ callbacks.
aaudio_endpoint_thread_proc(void * arg)99 static void *aaudio_endpoint_thread_proc(void *arg) {
100 assert(arg != nullptr);
101 ALOGD("%s() called", __func__);
102
103 // Prevent the stream from being deleted while being used.
104 // This is just for extra safety. It is probably not needed because
105 // this callback should be joined before the stream is closed.
106 auto endpointPtr = static_cast<AAudioServiceEndpointShared *>(arg);
107 android::sp<AAudioServiceEndpointShared> endpoint(endpointPtr);
108 // Balance the incStrong() in startSharingThread_l().
109 endpoint->decStrong(nullptr);
110
111 void *result = endpoint->callbackLoop();
112 // Close now so that the HW resource is freed and we can open a new device.
113 if (!endpoint->isConnected()) {
114 ALOGD("%s() call safeReleaseCloseFromCallback()", __func__);
115 // Release and close under a lock with no check for callback collisions.
116 endpoint->getStreamInternal()->safeReleaseCloseInternal();
117 }
118
119 return result;
120 }
121
startSharingThread_l()122 aaudio_result_t aaudio::AAudioServiceEndpointShared::startSharingThread_l() {
123 // Launch the callback loop thread.
124 int64_t periodNanos = getStreamInternal()->getFramesPerBurst()
125 * AAUDIO_NANOS_PER_SECOND
126 / getSampleRate();
127 mCallbackEnabled.store(true);
128 // Prevent this object from getting deleted before the thread has a chance to create
129 // its strong pointer. Assume the thread will call decStrong().
130 this->incStrong(nullptr);
131 aaudio_result_t result = getStreamInternal()->createThread(periodNanos,
132 aaudio_endpoint_thread_proc,
133 this);
134 if (result != AAUDIO_OK) {
135 this->decStrong(nullptr); // Because the thread won't do it.
136 }
137 return result;
138 }
139
stopSharingThread()140 aaudio_result_t aaudio::AAudioServiceEndpointShared::stopSharingThread() {
141 mCallbackEnabled.store(false);
142 return getStreamInternal()->joinThread(nullptr);
143 }
144
startStream(sp<AAudioServiceStreamBase> sharedStream,audio_port_handle_t * clientHandle)145 aaudio_result_t AAudioServiceEndpointShared::startStream(
146 sp<AAudioServiceStreamBase> sharedStream,
147 audio_port_handle_t *clientHandle)
148 NO_THREAD_SAFETY_ANALYSIS {
149 aaudio_result_t result = AAUDIO_OK;
150
151 {
152 std::lock_guard<std::mutex> lock(mLockStreams);
153 if (++mRunningStreamCount == 1) { // atomic
154 result = getStreamInternal()->systemStart();
155 if (result != AAUDIO_OK) {
156 --mRunningStreamCount;
157 } else {
158 result = startSharingThread_l();
159 if (result != AAUDIO_OK) {
160 getStreamInternal()->systemStopFromApp();
161 --mRunningStreamCount;
162 }
163 }
164 }
165 }
166
167 if (result == AAUDIO_OK) {
168 const audio_attributes_t attr = getAudioAttributesFrom(sharedStream.get());
169 result = getStreamInternal()->startClient(
170 sharedStream->getAudioClient(), &attr, clientHandle);
171 if (result != AAUDIO_OK) {
172 if (--mRunningStreamCount == 0) { // atomic
173 stopSharingThread();
174 getStreamInternal()->systemStopFromApp();
175 }
176 }
177 }
178
179 return result;
180 }
181
stopStream(sp<AAudioServiceStreamBase>,audio_port_handle_t clientHandle)182 aaudio_result_t AAudioServiceEndpointShared::stopStream(
183 sp<AAudioServiceStreamBase> /*sharedStream*/, audio_port_handle_t clientHandle) {
184 // Ignore result.
185 (void) getStreamInternal()->stopClient(clientHandle);
186
187 if (--mRunningStreamCount == 0) { // atomic
188 stopSharingThread(); // the sharing thread locks mLockStreams
189 getStreamInternal()->systemStopFromApp();
190 }
191 return AAUDIO_OK;
192 }
193
194 // Get timestamp that was written by the real-time service thread, eg. mixer.
getFreeRunningPosition(int64_t * positionFrames,int64_t * timeNanos)195 aaudio_result_t AAudioServiceEndpointShared::getFreeRunningPosition(int64_t *positionFrames,
196 int64_t *timeNanos) {
197 if (mAtomicEndpointTimestamp.isValid()) {
198 Timestamp timestamp = mAtomicEndpointTimestamp.read();
199 *positionFrames = timestamp.getPosition();
200 *timeNanos = timestamp.getNanoseconds();
201 return AAUDIO_OK;
202 } else {
203 return AAUDIO_ERROR_UNAVAILABLE;
204 }
205 }
206
getTimestamp(int64_t * positionFrames,int64_t * timeNanos)207 aaudio_result_t AAudioServiceEndpointShared::getTimestamp(int64_t *positionFrames,
208 int64_t *timeNanos) {
209 aaudio_result_t result = mStreamInternal->getTimestamp(CLOCK_MONOTONIC, positionFrames, timeNanos);
210 if (result == AAUDIO_ERROR_INVALID_STATE) {
211 // getTimestamp() can return AAUDIO_ERROR_INVALID_STATE if the stream has
212 // not completely started. This can cause a race condition that kills the
213 // timestamp service thread. So we reduce the error to a less serious one
214 // that allows the timestamp thread to continue.
215 result = AAUDIO_ERROR_UNAVAILABLE;
216 }
217 return result;
218 }
219
handleDisconnectRegisteredStreamsAsync()220 void AAudioServiceEndpointShared::handleDisconnectRegisteredStreamsAsync() {
221 android::sp<AAudioServiceEndpointShared> holdEndpoint(this);
222 // When there is a routing changed, mmap stream should be disconnected. Set `mConnected`
223 // as false here so that there won't be a new stream connect to this endpoint.
224 mConnected.store(false);
225 std::thread asyncTask([holdEndpoint]() {
226 // When handling disconnection, the service side has disconnected. In that case,
227 // it should be safe to release all registered streams.
228 holdEndpoint->releaseRegisteredStreams();
229 });
230 asyncTask.detach();
231 }
232