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_NDEBUG 0
18 #include <utils/Log.h>
19
20 #include <algorithm>
21 #include <audio_utils/primitives.h>
22 #include <aaudio/AAudio.h>
23
24 #include "client/AudioStreamInternalCapture.h"
25 #include "utility/AudioClock.h"
26
27 #define ATRACE_TAG ATRACE_TAG_AUDIO
28 #include <utils/Trace.h>
29
30 // We do this after the #includes because if a header uses ALOG.
31 // it would fail on the reference to mInService.
32 #undef LOG_TAG
33 // This file is used in both client and server processes.
34 // This is needed to make sense of the logs more easily.
35 #define LOG_TAG (mInService ? "AudioStreamInternalCapture_Service" \
36 : "AudioStreamInternalCapture_Client")
37
38 using android::WrappingBuffer;
39
40 using namespace aaudio;
41
AudioStreamInternalCapture(AAudioServiceInterface & serviceInterface,bool inService)42 AudioStreamInternalCapture::AudioStreamInternalCapture(AAudioServiceInterface &serviceInterface,
43 bool inService)
44 : AudioStreamInternal(serviceInterface, inService) {
45
46 }
47
~AudioStreamInternalCapture()48 AudioStreamInternalCapture::~AudioStreamInternalCapture() {}
49
advanceClientToMatchServerPosition()50 void AudioStreamInternalCapture::advanceClientToMatchServerPosition() {
51 int64_t readCounter = mAudioEndpoint->getDataReadCounter();
52 int64_t writeCounter = mAudioEndpoint->getDataWriteCounter();
53
54 // Bump offset so caller does not see the retrograde motion in getFramesRead().
55 int64_t offset = readCounter - writeCounter;
56 mFramesOffsetFromService += offset;
57 ALOGD("advanceClientToMatchServerPosition() readN = %lld, writeN = %lld, offset = %lld",
58 (long long)readCounter, (long long)writeCounter, (long long)mFramesOffsetFromService);
59
60 // Force readCounter to match writeCounter.
61 // This is because we cannot change the write counter in the hardware.
62 mAudioEndpoint->setDataReadCounter(writeCounter);
63 }
64
65 // Write the data, block if needed and timeoutMillis > 0
read(void * buffer,int32_t numFrames,int64_t timeoutNanoseconds)66 aaudio_result_t AudioStreamInternalCapture::read(void *buffer, int32_t numFrames,
67 int64_t timeoutNanoseconds)
68 {
69 return processData(buffer, numFrames, timeoutNanoseconds);
70 }
71
72 // Read as much data as we can without blocking.
processDataNow(void * buffer,int32_t numFrames,int64_t currentNanoTime,int64_t * wakeTimePtr)73 aaudio_result_t AudioStreamInternalCapture::processDataNow(void *buffer, int32_t numFrames,
74 int64_t currentNanoTime, int64_t *wakeTimePtr) {
75 aaudio_result_t result = processCommands();
76 if (result != AAUDIO_OK) {
77 return result;
78 }
79
80 const char *traceName = "aaRdNow";
81 ATRACE_BEGIN(traceName);
82
83 if (mClockModel.isStarting()) {
84 // Still haven't got any timestamps from server.
85 // Keep waiting until we get some valid timestamps then start writing to the
86 // current buffer position.
87 ALOGD("processDataNow() wait for valid timestamps");
88 // Sleep very briefly and hope we get a timestamp soon.
89 *wakeTimePtr = currentNanoTime + (2000 * AAUDIO_NANOS_PER_MICROSECOND);
90 ATRACE_END();
91 return 0;
92 }
93 // If we have gotten this far then we have at least one timestamp from server.
94
95 if (mAudioEndpoint->isFreeRunning()) {
96 //ALOGD("AudioStreamInternalCapture::processDataNow() - update remote counter");
97 // Update data queue based on the timing model.
98 // Jitter in the DSP can cause late writes to the FIFO.
99 // This might be caused by resampling.
100 // We want to read the FIFO after the latest possible time
101 // that the DSP could have written the data.
102 int64_t estimatedRemoteCounter = mClockModel.convertLatestTimeToPosition(currentNanoTime);
103 // TODO refactor, maybe use setRemoteCounter()
104 mAudioEndpoint->setDataWriteCounter(estimatedRemoteCounter);
105 }
106
107 // This code assumes that we have already received valid timestamps.
108 if (mNeedCatchUp.isRequested()) {
109 // Catch an MMAP pointer that is already advancing.
110 // This will avoid initial underruns caused by a slow cold start.
111 advanceClientToMatchServerPosition();
112 mNeedCatchUp.acknowledge();
113 }
114
115 // If the capture buffer is full beyond capacity then consider it an overrun.
116 // For shared streams, the xRunCount is passed up from the service.
117 if (mAudioEndpoint->isFreeRunning()
118 && mAudioEndpoint->getFullFramesAvailable() > mAudioEndpoint->getBufferCapacityInFrames()) {
119 mXRunCount++;
120 if (ATRACE_ENABLED()) {
121 ATRACE_INT("aaOverRuns", mXRunCount);
122 }
123 }
124
125 // Read some data from the buffer.
126 //ALOGD("AudioStreamInternalCapture::processDataNow() - readNowWithConversion(%d)", numFrames);
127 int32_t framesProcessed = readNowWithConversion(buffer, numFrames);
128 //ALOGD("AudioStreamInternalCapture::processDataNow() - tried to read %d frames, read %d",
129 // numFrames, framesProcessed);
130 if (ATRACE_ENABLED()) {
131 ATRACE_INT("aaRead", framesProcessed);
132 }
133
134 // Calculate an ideal time to wake up.
135 if (wakeTimePtr != nullptr && framesProcessed >= 0) {
136 // By default wake up a few milliseconds from now. // TODO review
137 int64_t wakeTime = currentNanoTime + (1 * AAUDIO_NANOS_PER_MILLISECOND);
138 aaudio_stream_state_t state = getState();
139 //ALOGD("AudioStreamInternalCapture::processDataNow() - wakeTime based on %s",
140 // AAudio_convertStreamStateToText(state));
141 switch (state) {
142 case AAUDIO_STREAM_STATE_OPEN:
143 case AAUDIO_STREAM_STATE_STARTING:
144 break;
145 case AAUDIO_STREAM_STATE_STARTED:
146 {
147 // When do we expect the next write burst to occur?
148
149 // Calculate frame position based off of the readCounter because
150 // the writeCounter might have just advanced in the background,
151 // causing us to sleep until a later burst.
152 int64_t nextPosition = mAudioEndpoint->getDataReadCounter() + mFramesPerBurst;
153 wakeTime = mClockModel.convertPositionToLatestTime(nextPosition);
154 }
155 break;
156 default:
157 break;
158 }
159 *wakeTimePtr = wakeTime;
160
161 }
162
163 ATRACE_END();
164 return framesProcessed;
165 }
166
readNowWithConversion(void * buffer,int32_t numFrames)167 aaudio_result_t AudioStreamInternalCapture::readNowWithConversion(void *buffer,
168 int32_t numFrames) {
169 // ALOGD("readNowWithConversion(%p, %d)",
170 // buffer, numFrames);
171 WrappingBuffer wrappingBuffer;
172 uint8_t *destination = (uint8_t *) buffer;
173 int32_t framesLeft = numFrames;
174
175 mAudioEndpoint->getFullFramesAvailable(&wrappingBuffer);
176
177 // Read data in one or two parts.
178 for (int partIndex = 0; framesLeft > 0 && partIndex < WrappingBuffer::SIZE; partIndex++) {
179 int32_t framesToProcess = framesLeft;
180 const int32_t framesAvailable = wrappingBuffer.numFrames[partIndex];
181 if (framesAvailable <= 0) break;
182
183 if (framesToProcess > framesAvailable) {
184 framesToProcess = framesAvailable;
185 }
186
187 const int32_t numBytes = getBytesPerFrame() * framesToProcess;
188 const int32_t numSamples = framesToProcess * getSamplesPerFrame();
189
190 const audio_format_t sourceFormat = getDeviceFormat();
191 const audio_format_t destinationFormat = getFormat();
192 // TODO factor this out into a utility function
193 if (sourceFormat == destinationFormat) {
194 memcpy(destination, wrappingBuffer.data[partIndex], numBytes);
195 } else if (sourceFormat == AUDIO_FORMAT_PCM_16_BIT
196 && destinationFormat == AUDIO_FORMAT_PCM_FLOAT) {
197 memcpy_to_float_from_i16(
198 (float *) destination,
199 (const int16_t *) wrappingBuffer.data[partIndex],
200 numSamples);
201 } else if (sourceFormat == AUDIO_FORMAT_PCM_FLOAT
202 && destinationFormat == AUDIO_FORMAT_PCM_16_BIT) {
203 memcpy_to_i16_from_float(
204 (int16_t *) destination,
205 (const float *) wrappingBuffer.data[partIndex],
206 numSamples);
207 } else {
208 ALOGE("%s() - Format conversion not supported! audio_format_t source = %u, dest = %u",
209 __func__, sourceFormat, destinationFormat);
210 return AAUDIO_ERROR_INVALID_FORMAT;
211 }
212 destination += numBytes;
213 framesLeft -= framesToProcess;
214 }
215
216 int32_t framesProcessed = numFrames - framesLeft;
217 mAudioEndpoint->advanceReadIndex(framesProcessed);
218
219 //ALOGD("readNowWithConversion() returns %d", framesProcessed);
220 return framesProcessed;
221 }
222
getFramesWritten()223 int64_t AudioStreamInternalCapture::getFramesWritten() {
224 if (mAudioEndpoint) {
225 const int64_t framesWrittenHardware = isClockModelInControl()
226 ? mClockModel.convertTimeToPosition(AudioClock::getNanoseconds())
227 : mAudioEndpoint->getDataWriteCounter();
228 // Add service offset and prevent retrograde motion.
229 mLastFramesWritten = std::max(mLastFramesWritten,
230 framesWrittenHardware + mFramesOffsetFromService);
231 }
232 return mLastFramesWritten;
233 }
234
getFramesRead()235 int64_t AudioStreamInternalCapture::getFramesRead() {
236 if (mAudioEndpoint) {
237 mLastFramesRead = mAudioEndpoint->getDataReadCounter() + mFramesOffsetFromService;
238 }
239 return mLastFramesRead;
240 }
241
242 // Read data from the stream and pass it to the callback for processing.
callbackLoop()243 void *AudioStreamInternalCapture::callbackLoop() {
244 aaudio_result_t result = AAUDIO_OK;
245 aaudio_data_callback_result_t callbackResult = AAUDIO_CALLBACK_RESULT_CONTINUE;
246 if (!isDataCallbackSet()) return NULL;
247
248 // result might be a frame count
249 while (mCallbackEnabled.load() && isActive() && (result >= 0)) {
250
251 // Read audio data from stream.
252 int64_t timeoutNanos = calculateReasonableTimeout(mCallbackFrames);
253
254 // This is a BLOCKING READ!
255 result = read(mCallbackBuffer.get(), mCallbackFrames, timeoutNanos);
256 if ((result != mCallbackFrames)) {
257 ALOGE("callbackLoop: read() returned %d", result);
258 if (result >= 0) {
259 // Only read some of the frames requested. Must have timed out.
260 result = AAUDIO_ERROR_TIMEOUT;
261 }
262 maybeCallErrorCallback(result);
263 break;
264 }
265
266 // Call application using the AAudio callback interface.
267 callbackResult = maybeCallDataCallback(mCallbackBuffer.get(), mCallbackFrames);
268
269 if (callbackResult == AAUDIO_CALLBACK_RESULT_STOP) {
270 ALOGD("%s(): callback returned AAUDIO_CALLBACK_RESULT_STOP", __func__);
271 result = systemStopFromCallback();
272 break;
273 }
274 }
275
276 ALOGD("callbackLoop() exiting, result = %d, isActive() = %d",
277 result, (int) isActive());
278 return NULL;
279 }
280