• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #define LOG_TAG "AAudioServiceStreamShared"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20 
21 #include <iomanip>
22 #include <iostream>
23 #include <mutex>
24 
25 #include <aaudio/AAudio.h>
26 
27 #include "binding/IAAudioService.h"
28 
29 #include "binding/AAudioServiceMessage.h"
30 #include "AAudioServiceStreamBase.h"
31 #include "AAudioServiceStreamShared.h"
32 #include "AAudioEndpointManager.h"
33 #include "AAudioService.h"
34 #include "AAudioServiceEndpoint.h"
35 
36 using namespace android;
37 using namespace aaudio;
38 
39 #define MIN_BURSTS_PER_BUFFER       2
40 #define DEFAULT_BURSTS_PER_BUFFER   16
41 // This is an arbitrary range. TODO review.
42 #define MAX_FRAMES_PER_BUFFER       (32 * 1024)
43 
AAudioServiceStreamShared(AAudioService & audioService)44 AAudioServiceStreamShared::AAudioServiceStreamShared(AAudioService &audioService)
45     : AAudioServiceStreamBase(audioService)
46     , mTimestampPositionOffset(0)
47     , mXRunCount(0) {
48 }
49 
dumpHeader()50 std::string AAudioServiceStreamShared::dumpHeader() {
51     std::stringstream result;
52     result << AAudioServiceStreamBase::dumpHeader();
53     result << "    Write#     Read#   Avail   XRuns";
54     return result.str();
55 }
56 
dump() const57 std::string AAudioServiceStreamShared::dump() const {
58     std::stringstream result;
59 
60     result << AAudioServiceStreamBase::dump();
61 
62     auto fifo = mAudioDataQueue->getFifoBuffer();
63     int32_t readCounter = fifo->getReadCounter();
64     int32_t writeCounter = fifo->getWriteCounter();
65     result << std::setw(10) << writeCounter;
66     result << std::setw(10) << readCounter;
67     result << std::setw(8) << (writeCounter - readCounter);
68     result << std::setw(8) << getXRunCount();
69 
70     return result.str();
71 }
72 
calculateBufferCapacity(int32_t requestedCapacityFrames,int32_t framesPerBurst)73 int32_t AAudioServiceStreamShared::calculateBufferCapacity(int32_t requestedCapacityFrames,
74                                                            int32_t framesPerBurst) {
75 
76     if (requestedCapacityFrames > MAX_FRAMES_PER_BUFFER) {
77         ALOGE("AAudioServiceStreamShared::calculateBufferCapacity() requested capacity %d > max %d",
78               requestedCapacityFrames, MAX_FRAMES_PER_BUFFER);
79         return AAUDIO_ERROR_OUT_OF_RANGE;
80     }
81 
82     // Determine how many bursts will fit in the buffer.
83     int32_t numBursts;
84     if (requestedCapacityFrames == AAUDIO_UNSPECIFIED) {
85         // Use fewer bursts if default is too many.
86         if ((DEFAULT_BURSTS_PER_BUFFER * framesPerBurst) > MAX_FRAMES_PER_BUFFER) {
87             numBursts = MAX_FRAMES_PER_BUFFER / framesPerBurst;
88         } else {
89             numBursts = DEFAULT_BURSTS_PER_BUFFER;
90         }
91     } else {
92         // round up to nearest burst boundary
93         numBursts = (requestedCapacityFrames + framesPerBurst - 1) / framesPerBurst;
94     }
95 
96     // Clip to bare minimum.
97     if (numBursts < MIN_BURSTS_PER_BUFFER) {
98         numBursts = MIN_BURSTS_PER_BUFFER;
99     }
100     // Check for numeric overflow.
101     if (numBursts > 0x8000 || framesPerBurst > 0x8000) {
102         ALOGE("AAudioServiceStreamShared::calculateBufferCapacity() overflow, capacity = %d * %d",
103               numBursts, framesPerBurst);
104         return AAUDIO_ERROR_OUT_OF_RANGE;
105     }
106     int32_t capacityInFrames = numBursts * framesPerBurst;
107 
108     // Final sanity check.
109     if (capacityInFrames > MAX_FRAMES_PER_BUFFER) {
110         ALOGE("AAudioServiceStreamShared::calculateBufferCapacity() calc capacity %d > max %d",
111               capacityInFrames, MAX_FRAMES_PER_BUFFER);
112         return AAUDIO_ERROR_OUT_OF_RANGE;
113     }
114     ALOGD("AAudioServiceStreamShared::calculateBufferCapacity() requested %d frames, actual = %d",
115           requestedCapacityFrames, capacityInFrames);
116     return capacityInFrames;
117 }
118 
open(const aaudio::AAudioStreamRequest & request)119 aaudio_result_t AAudioServiceStreamShared::open(const aaudio::AAudioStreamRequest &request)  {
120 
121     sp<AAudioServiceStreamShared> keep(this);
122 
123     aaudio_result_t result = AAudioServiceStreamBase::open(request, AAUDIO_SHARING_MODE_SHARED);
124     if (result != AAUDIO_OK) {
125         ALOGE("AAudioServiceStreamBase open() returned %d", result);
126         return result;
127     }
128 
129     const AAudioStreamConfiguration &configurationInput = request.getConstantConfiguration();
130 
131     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
132     if (endpoint == nullptr) {
133         result = AAUDIO_ERROR_INVALID_STATE;
134         goto error;
135     }
136 
137     // Is the request compatible with the shared endpoint?
138     setFormat(configurationInput.getFormat());
139     if (getFormat() == AAUDIO_FORMAT_UNSPECIFIED) {
140         setFormat(AAUDIO_FORMAT_PCM_FLOAT);
141     } else if (getFormat() != AAUDIO_FORMAT_PCM_FLOAT) {
142         ALOGE("AAudioServiceStreamShared::open() mAudioFormat = %d, need FLOAT", getFormat());
143         result = AAUDIO_ERROR_INVALID_FORMAT;
144         goto error;
145     }
146 
147     setSampleRate(configurationInput.getSampleRate());
148     if (getSampleRate() == AAUDIO_UNSPECIFIED) {
149         setSampleRate(endpoint->getSampleRate());
150     } else if (getSampleRate() != endpoint->getSampleRate()) {
151         ALOGE("AAudioServiceStreamShared::open() mSampleRate = %d, need %d",
152               getSampleRate(), endpoint->getSampleRate());
153         result = AAUDIO_ERROR_INVALID_RATE;
154         goto error;
155     }
156 
157     setSamplesPerFrame(configurationInput.getSamplesPerFrame());
158     if (getSamplesPerFrame() == AAUDIO_UNSPECIFIED) {
159         setSamplesPerFrame(endpoint->getSamplesPerFrame());
160     } else if (getSamplesPerFrame() != endpoint->getSamplesPerFrame()) {
161         ALOGE("AAudioServiceStreamShared::open() mSamplesPerFrame = %d, need %d",
162               getSamplesPerFrame(), endpoint->getSamplesPerFrame());
163         result = AAUDIO_ERROR_OUT_OF_RANGE;
164         goto error;
165     }
166 
167     setBufferCapacity(calculateBufferCapacity(configurationInput.getBufferCapacity(),
168                                      mFramesPerBurst));
169     if (getBufferCapacity() < 0) {
170         result = getBufferCapacity(); // negative error code
171         setBufferCapacity(0);
172         goto error;
173     }
174 
175     {
176         std::lock_guard<std::mutex> lock(mAudioDataQueueLock);
177         // Create audio data shared memory buffer for client.
178         mAudioDataQueue = new SharedRingBuffer();
179         result = mAudioDataQueue->allocate(calculateBytesPerFrame(), getBufferCapacity());
180         if (result != AAUDIO_OK) {
181             ALOGE("AAudioServiceStreamShared::open() could not allocate FIFO with %d frames",
182                   getBufferCapacity());
183             result = AAUDIO_ERROR_NO_MEMORY;
184             goto error;
185         }
186     }
187 
188     ALOGD("AAudioServiceStreamShared::open() actual rate = %d, channels = %d, deviceId = %d",
189           getSampleRate(), getSamplesPerFrame(), endpoint->getDeviceId());
190 
191     result = endpoint->registerStream(keep);
192     if (result != AAUDIO_OK) {
193         goto error;
194     }
195 
196     setState(AAUDIO_STREAM_STATE_OPEN);
197     return AAUDIO_OK;
198 
199 error:
200     close();
201     return result;
202 }
203 
204 
close()205 aaudio_result_t AAudioServiceStreamShared::close()  {
206     aaudio_result_t result = AAudioServiceStreamBase::close();
207 
208     {
209         std::lock_guard<std::mutex> lock(mAudioDataQueueLock);
210         delete mAudioDataQueue;
211         mAudioDataQueue = nullptr;
212     }
213 
214     return result;
215 }
216 
217 /**
218  * Get an immutable description of the data queue created by this service.
219  */
getAudioDataDescription(AudioEndpointParcelable & parcelable)220 aaudio_result_t AAudioServiceStreamShared::getAudioDataDescription(
221         AudioEndpointParcelable &parcelable)
222 {
223     std::lock_guard<std::mutex> lock(mAudioDataQueueLock);
224     if (mAudioDataQueue == nullptr) {
225         ALOGE("getAudioDataDescription(): mUpMessageQueue null! - stream not open");
226         return AAUDIO_ERROR_NULL;
227     }
228     // Gather information on the data queue.
229     mAudioDataQueue->fillParcelable(parcelable,
230                                     parcelable.mDownDataQueueParcelable);
231     parcelable.mDownDataQueueParcelable.setFramesPerBurst(getFramesPerBurst());
232     return AAUDIO_OK;
233 }
234 
markTransferTime(Timestamp & timestamp)235 void AAudioServiceStreamShared::markTransferTime(Timestamp &timestamp) {
236     mAtomicTimestamp.write(timestamp);
237 }
238 
239 // Get timestamp that was written by mixer or distributor.
getFreeRunningPosition(int64_t * positionFrames,int64_t * timeNanos)240 aaudio_result_t AAudioServiceStreamShared::getFreeRunningPosition(int64_t *positionFrames,
241                                                                   int64_t *timeNanos) {
242     // TODO Get presentation timestamp from the HAL
243     if (mAtomicTimestamp.isValid()) {
244         Timestamp timestamp = mAtomicTimestamp.read();
245         *positionFrames = timestamp.getPosition();
246         *timeNanos = timestamp.getNanoseconds();
247         return AAUDIO_OK;
248     } else {
249         return AAUDIO_ERROR_UNAVAILABLE;
250     }
251 }
252 
253 // Get timestamp from lower level service.
getHardwareTimestamp(int64_t * positionFrames,int64_t * timeNanos)254 aaudio_result_t AAudioServiceStreamShared::getHardwareTimestamp(int64_t *positionFrames,
255                                                                 int64_t *timeNanos) {
256 
257     int64_t position = 0;
258     sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
259     if (endpoint == nullptr) {
260         ALOGE("%s() has no endpoint", __func__);
261         return AAUDIO_ERROR_INVALID_STATE;
262     }
263 
264     aaudio_result_t result = endpoint->getTimestamp(&position, timeNanos);
265     if (result == AAUDIO_OK) {
266         int64_t offset = mTimestampPositionOffset.load();
267         // TODO, do not go below starting value
268         position -= offset; // Offset from shared MMAP stream
269         ALOGV("getHardwareTimestamp() %8lld = %8lld - %8lld",
270               (long long) position, (long long) (position + offset), (long long) offset);
271     }
272     *positionFrames = position;
273     return result;
274 }
275