blob: 8b30aa646baa0fbbf89a5bf2c516318a16a90cee [file] [log] [blame]
Phil Burk204a1632017-01-03 17:23:43 -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
Phil Burkcf5f6d22017-05-26 12:35:07 -070017// This file is used in both client and server processes.
18// This is needed to make sense of the logs more easily.
19#define LOG_TAG (mInService ? "AAudioService" : "AAudio")
Phil Burk204a1632017-01-03 17:23:43 -080020//#define LOG_NDEBUG 0
21#include <utils/Log.h>
22
Phil Burk4485d412017-05-09 15:55:02 -070023#define ATRACE_TAG ATRACE_TAG_AUDIO
24
Phil Burkc0c70e32017-02-09 13:18:38 -080025#include <stdint.h>
Phil Burk204a1632017-01-03 17:23:43 -080026#include <assert.h>
27
28#include <binder/IServiceManager.h>
29
Phil Burk5ed503c2017-02-01 09:38:15 -080030#include <aaudio/AAudio.h>
Phil Burke4d7bb42017-03-28 11:32:39 -070031#include <utils/String16.h>
Phil Burk4485d412017-05-09 15:55:02 -070032#include <utils/Trace.h>
Phil Burk204a1632017-01-03 17:23:43 -080033
Phil Burkc0c70e32017-02-09 13:18:38 -080034#include "AudioClock.h"
35#include "AudioEndpointParcelable.h"
36#include "binding/AAudioStreamRequest.h"
37#include "binding/AAudioStreamConfiguration.h"
38#include "binding/IAAudioService.h"
Phil Burk5ed503c2017-02-01 09:38:15 -080039#include "binding/AAudioServiceMessage.h"
Phil Burk3df348f2017-02-08 11:41:55 -080040#include "core/AudioStreamBuilder.h"
Phil Burke572f462017-04-20 13:03:19 -070041#include "fifo/FifoBuffer.h"
42#include "utility/LinearRamp.h"
43
Phil Burkc0c70e32017-02-09 13:18:38 -080044#include "AudioStreamInternal.h"
Phil Burk204a1632017-01-03 17:23:43 -080045
Phil Burk204a1632017-01-03 17:23:43 -080046using android::String16;
Phil Burkdec33ab2017-01-17 14:48:16 -080047using android::Mutex;
Phil Burkc0c70e32017-02-09 13:18:38 -080048using android::WrappingBuffer;
Phil Burk204a1632017-01-03 17:23:43 -080049
Phil Burk5ed503c2017-02-01 09:38:15 -080050using namespace aaudio;
Phil Burk204a1632017-01-03 17:23:43 -080051
Phil Burke4d7bb42017-03-28 11:32:39 -070052#define MIN_TIMEOUT_NANOS (1000 * AAUDIO_NANOS_PER_MILLISECOND)
53
54// Wait at least this many times longer than the operation should take.
55#define MIN_TIMEOUT_OPERATIONS 4
56
Phil Burk87c9f642017-05-17 07:22:39 -070057#define LOG_TIMESTAMPS 0
58
Phil Burkc0c70e32017-02-09 13:18:38 -080059AudioStreamInternal::AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService)
Phil Burk204a1632017-01-03 17:23:43 -080060 : AudioStream()
61 , mClockModel()
62 , mAudioEndpoint()
Phil Burk5ed503c2017-02-01 09:38:15 -080063 , mServiceStreamHandle(AAUDIO_HANDLE_INVALID)
Phil Burk204a1632017-01-03 17:23:43 -080064 , mFramesPerBurst(16)
Eric Laurenta2f296e2017-06-21 18:51:47 -070065 , mStreamVolume(1.0f)
Phil Burkec89b2e2017-06-20 15:05:06 -070066 , mInService(inService)
67 , mServiceInterface(serviceInterface) {
Phil Burk204a1632017-01-03 17:23:43 -080068}
69
70AudioStreamInternal::~AudioStreamInternal() {
71}
72
Phil Burk5ed503c2017-02-01 09:38:15 -080073aaudio_result_t AudioStreamInternal::open(const AudioStreamBuilder &builder) {
Phil Burk204a1632017-01-03 17:23:43 -080074
Phil Burk5ed503c2017-02-01 09:38:15 -080075 aaudio_result_t result = AAUDIO_OK;
76 AAudioStreamRequest request;
77 AAudioStreamConfiguration configuration;
Phil Burk204a1632017-01-03 17:23:43 -080078
79 result = AudioStream::open(builder);
80 if (result < 0) {
81 return result;
82 }
83
Phil Burkc0c70e32017-02-09 13:18:38 -080084 // We have to do volume scaling. So we prefer FLOAT format.
Glenn Kasten37a466a2017-05-30 15:53:14 -070085 if (getFormat() == AAUDIO_FORMAT_UNSPECIFIED) {
Phil Burkc0c70e32017-02-09 13:18:38 -080086 setFormat(AAUDIO_FORMAT_PCM_FLOAT);
87 }
Phil Burk71f35bb2017-04-13 16:05:07 -070088 // Request FLOAT for the shared mixer.
89 request.getConfiguration().setAudioFormat(AAUDIO_FORMAT_PCM_FLOAT);
Phil Burkc0c70e32017-02-09 13:18:38 -080090
Phil Burkdec33ab2017-01-17 14:48:16 -080091 // Build the request to send to the server.
Phil Burk204a1632017-01-03 17:23:43 -080092 request.setUserId(getuid());
93 request.setProcessId(getpid());
Phil Burkc0c70e32017-02-09 13:18:38 -080094 request.setDirection(getDirection());
Phil Burk71f35bb2017-04-13 16:05:07 -070095 request.setSharingModeMatchRequired(isSharingModeMatchRequired());
Phil Burkc0c70e32017-02-09 13:18:38 -080096
Phil Burk204a1632017-01-03 17:23:43 -080097 request.getConfiguration().setDeviceId(getDeviceId());
98 request.getConfiguration().setSampleRate(getSampleRate());
99 request.getConfiguration().setSamplesPerFrame(getSamplesPerFrame());
Phil Burk71f35bb2017-04-13 16:05:07 -0700100 request.getConfiguration().setSharingMode(getSharingMode());
101
Phil Burk3df348f2017-02-08 11:41:55 -0800102 request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
Phil Burk204a1632017-01-03 17:23:43 -0800103
Phil Burkc0c70e32017-02-09 13:18:38 -0800104 mServiceStreamHandle = mServiceInterface.openStream(request, configuration);
Phil Burk204a1632017-01-03 17:23:43 -0800105 if (mServiceStreamHandle < 0) {
106 result = mServiceStreamHandle;
Phil Burkcf5f6d22017-05-26 12:35:07 -0700107 ALOGE("AudioStreamInternal.open(): openStream() returned %d", result);
Phil Burk204a1632017-01-03 17:23:43 -0800108 } else {
109 result = configuration.validate();
Phil Burk5ed503c2017-02-01 09:38:15 -0800110 if (result != AAUDIO_OK) {
Phil Burk204a1632017-01-03 17:23:43 -0800111 close();
112 return result;
113 }
114 // Save results of the open.
115 setSampleRate(configuration.getSampleRate());
116 setSamplesPerFrame(configuration.getSamplesPerFrame());
Phil Burkc0c70e32017-02-09 13:18:38 -0800117 setDeviceId(configuration.getDeviceId());
Eric Laurentd51329e2017-06-30 16:06:16 -0700118 setSharingMode(configuration.getSharingMode());
Phil Burk204a1632017-01-03 17:23:43 -0800119
Phil Burkc0c70e32017-02-09 13:18:38 -0800120 // Save device format so we can do format conversion and volume scaling together.
121 mDeviceFormat = configuration.getAudioFormat();
122
123 result = mServiceInterface.getStreamDescription(mServiceStreamHandle, mEndPointParcelable);
Phil Burk5ed503c2017-02-01 09:38:15 -0800124 if (result != AAUDIO_OK) {
Phil Burkc0c70e32017-02-09 13:18:38 -0800125 mServiceInterface.closeStream(mServiceStreamHandle);
Phil Burk204a1632017-01-03 17:23:43 -0800126 return result;
127 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800128
Phil Burk204a1632017-01-03 17:23:43 -0800129 // resolve parcelable into a descriptor
Phil Burkc0c70e32017-02-09 13:18:38 -0800130 result = mEndPointParcelable.resolve(&mEndpointDescriptor);
131 if (result != AAUDIO_OK) {
Phil Burkc0c70e32017-02-09 13:18:38 -0800132 mServiceInterface.closeStream(mServiceStreamHandle);
133 return result;
134 }
Phil Burk204a1632017-01-03 17:23:43 -0800135
136 // Configure endpoint based on descriptor.
137 mAudioEndpoint.configure(&mEndpointDescriptor);
138
Phil Burk87c9f642017-05-17 07:22:39 -0700139 mFramesPerBurst = mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
140 int32_t capacity = mEndpointDescriptor.dataQueueDescriptor.capacityInFrames;
Phil Burk71f35bb2017-04-13 16:05:07 -0700141
Phil Burk71f35bb2017-04-13 16:05:07 -0700142 // Validate result from server.
143 if (mFramesPerBurst < 16 || mFramesPerBurst > 16 * 1024) {
144 ALOGE("AudioStream::open(): framesPerBurst out of range = %d", mFramesPerBurst);
145 return AAUDIO_ERROR_OUT_OF_RANGE;
146 }
147 if (capacity < mFramesPerBurst || capacity > 32 * 1024) {
148 ALOGE("AudioStream::open(): bufferCapacity out of range = %d", capacity);
149 return AAUDIO_ERROR_OUT_OF_RANGE;
150 }
Phil Burk204a1632017-01-03 17:23:43 -0800151
152 mClockModel.setSampleRate(getSampleRate());
153 mClockModel.setFramesPerBurst(mFramesPerBurst);
154
Phil Burke4d7bb42017-03-28 11:32:39 -0700155 if (getDataCallbackProc()) {
156 mCallbackFrames = builder.getFramesPerDataCallback();
157 if (mCallbackFrames > getBufferCapacity() / 2) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700158 ALOGE("AudioStreamInternal::open(): framesPerCallback too big = %d, capacity = %d",
Phil Burk71f35bb2017-04-13 16:05:07 -0700159 mCallbackFrames, getBufferCapacity());
Phil Burkc0c70e32017-02-09 13:18:38 -0800160 mServiceInterface.closeStream(mServiceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700161 return AAUDIO_ERROR_OUT_OF_RANGE;
162
163 } else if (mCallbackFrames < 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700164 ALOGE("AudioStreamInternal::open(): framesPerCallback negative");
Phil Burkc0c70e32017-02-09 13:18:38 -0800165 mServiceInterface.closeStream(mServiceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700166 return AAUDIO_ERROR_OUT_OF_RANGE;
167
168 }
169 if (mCallbackFrames == AAUDIO_UNSPECIFIED) {
170 mCallbackFrames = mFramesPerBurst;
171 }
172
173 int32_t bytesPerFrame = getSamplesPerFrame()
174 * AAudioConvert_formatToSizeInBytes(getFormat());
175 int32_t callbackBufferSize = mCallbackFrames * bytesPerFrame;
176 mCallbackBuffer = new uint8_t[callbackBufferSize];
177 }
178
Phil Burk5ed503c2017-02-01 09:38:15 -0800179 setState(AAUDIO_STREAM_STATE_OPEN);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700180 // only connect to AudioManager if this is a playback stream running in client process
181 if (!mInService && getDirection() == AAUDIO_DIRECTION_OUTPUT) {
182 init(android::PLAYER_TYPE_AAUDIO, AUDIO_USAGE_MEDIA);
183 }
Phil Burk204a1632017-01-03 17:23:43 -0800184 }
185 return result;
186}
187
Phil Burk5ed503c2017-02-01 09:38:15 -0800188aaudio_result_t AudioStreamInternal::close() {
Phil Burkec89b2e2017-06-20 15:05:06 -0700189 ALOGD("AudioStreamInternal::close(): mServiceStreamHandle = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700190 mServiceStreamHandle);
Phil Burk5ed503c2017-02-01 09:38:15 -0800191 if (mServiceStreamHandle != AAUDIO_HANDLE_INVALID) {
Phil Burk4485d412017-05-09 15:55:02 -0700192 // Don't close a stream while it is running.
193 aaudio_stream_state_t currentState = getState();
Phil Burk87c9f642017-05-17 07:22:39 -0700194 if (isActive()) {
Phil Burk4485d412017-05-09 15:55:02 -0700195 requestStop();
196 aaudio_stream_state_t nextState;
197 int64_t timeoutNanoseconds = MIN_TIMEOUT_NANOS;
198 aaudio_result_t result = waitForStateChange(currentState, &nextState,
199 timeoutNanoseconds);
200 if (result != AAUDIO_OK) {
201 ALOGE("AudioStreamInternal::close() waitForStateChange() returned %d %s",
202 result, AAudio_convertResultToText(result));
203 }
204 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700205 setState(AAUDIO_STREAM_STATE_CLOSING);
Phil Burk5ed503c2017-02-01 09:38:15 -0800206 aaudio_handle_t serviceStreamHandle = mServiceStreamHandle;
207 mServiceStreamHandle = AAUDIO_HANDLE_INVALID;
Phil Burkc0c70e32017-02-09 13:18:38 -0800208
209 mServiceInterface.closeStream(serviceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700210 delete[] mCallbackBuffer;
Phil Burk4485d412017-05-09 15:55:02 -0700211 mCallbackBuffer = nullptr;
Phil Burkec89b2e2017-06-20 15:05:06 -0700212 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burkc0c70e32017-02-09 13:18:38 -0800213 return mEndPointParcelable.close();
Phil Burk204a1632017-01-03 17:23:43 -0800214 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800215 return AAUDIO_ERROR_INVALID_HANDLE;
Phil Burk204a1632017-01-03 17:23:43 -0800216 }
217}
218
Phil Burkc0c70e32017-02-09 13:18:38 -0800219
Phil Burke4d7bb42017-03-28 11:32:39 -0700220static void *aaudio_callback_thread_proc(void *context)
221{
222 AudioStreamInternal *stream = (AudioStreamInternal *)context;
Phil Burk677d7912017-04-07 12:17:12 -0700223 //LOGD("AudioStreamInternal(): oboe_callback_thread, stream = %p", stream);
Phil Burke4d7bb42017-03-28 11:32:39 -0700224 if (stream != NULL) {
225 return stream->callbackLoop();
226 } else {
227 return NULL;
228 }
229}
230
Phil Burk5ed503c2017-02-01 09:38:15 -0800231aaudio_result_t AudioStreamInternal::requestStart()
Phil Burk204a1632017-01-03 17:23:43 -0800232{
Phil Burk3316d5e2017-02-15 11:23:01 -0800233 int64_t startTime;
Phil Burkec89b2e2017-06-20 15:05:06 -0700234 ALOGD("AudioStreamInternal()::requestStart()");
Phil Burk5ed503c2017-02-01 09:38:15 -0800235 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
236 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800237 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700238 if (isActive()) {
239 return AAUDIO_ERROR_INVALID_STATE;
240 }
241 aaudio_stream_state_t originalState = getState();
242
243 setState(AAUDIO_STREAM_STATE_STARTING);
244 aaudio_result_t result = AAudioConvert_androidToAAudioResult(startWithStatus());
Phil Burkc0c70e32017-02-09 13:18:38 -0800245
Phil Burk3316d5e2017-02-15 11:23:01 -0800246 startTime = AudioClock::getNanoseconds();
Phil Burk204a1632017-01-03 17:23:43 -0800247 mClockModel.start(startTime);
Phil Burke4d7bb42017-03-28 11:32:39 -0700248
249 if (result == AAUDIO_OK && getDataCallbackProc() != nullptr) {
250 // Launch the callback loop thread.
251 int64_t periodNanos = mCallbackFrames
252 * AAUDIO_NANOS_PER_SECOND
253 / getSampleRate();
254 mCallbackEnabled.store(true);
255 result = createThread(periodNanos, aaudio_callback_thread_proc, this);
256 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700257 if (result != AAUDIO_OK) {
258 setState(originalState);
259 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700260 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800261}
262
Phil Burke4d7bb42017-03-28 11:32:39 -0700263int64_t AudioStreamInternal::calculateReasonableTimeout(int32_t framesPerOperation) {
264
265 // Wait for at least a second or some number of callbacks to join the thread.
Phil Burk71f35bb2017-04-13 16:05:07 -0700266 int64_t timeoutNanoseconds = (MIN_TIMEOUT_OPERATIONS
267 * framesPerOperation
268 * AAUDIO_NANOS_PER_SECOND)
269 / getSampleRate();
Phil Burke4d7bb42017-03-28 11:32:39 -0700270 if (timeoutNanoseconds < MIN_TIMEOUT_NANOS) { // arbitrary number of seconds
271 timeoutNanoseconds = MIN_TIMEOUT_NANOS;
272 }
273 return timeoutNanoseconds;
274}
275
Phil Burk87c9f642017-05-17 07:22:39 -0700276int64_t AudioStreamInternal::calculateReasonableTimeout() {
277 return calculateReasonableTimeout(getFramesPerBurst());
278}
279
Phil Burke4d7bb42017-03-28 11:32:39 -0700280aaudio_result_t AudioStreamInternal::stopCallback()
281{
282 if (isDataCallbackActive()) {
283 mCallbackEnabled.store(false);
Phil Burk87c9f642017-05-17 07:22:39 -0700284 return joinThread(NULL);
Phil Burke4d7bb42017-03-28 11:32:39 -0700285 } else {
286 return AAUDIO_OK;
287 }
288}
289
290aaudio_result_t AudioStreamInternal::requestPauseInternal()
Phil Burk204a1632017-01-03 17:23:43 -0800291{
Phil Burk5ed503c2017-02-01 09:38:15 -0800292 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700293 ALOGE("AudioStreamInternal::requestPauseInternal() mServiceStreamHandle invalid = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700294 mServiceStreamHandle);
Phil Burk5ed503c2017-02-01 09:38:15 -0800295 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800296 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800297
Phil Burk3316d5e2017-02-15 11:23:01 -0800298 mClockModel.stop(AudioClock::getNanoseconds());
Phil Burk5ed503c2017-02-01 09:38:15 -0800299 setState(AAUDIO_STREAM_STATE_PAUSING);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700300 return AAudioConvert_androidToAAudioResult(pauseWithStatus());
Phil Burk204a1632017-01-03 17:23:43 -0800301}
302
Phil Burke4d7bb42017-03-28 11:32:39 -0700303aaudio_result_t AudioStreamInternal::requestPause()
304{
305 aaudio_result_t result = stopCallback();
306 if (result != AAUDIO_OK) {
307 return result;
308 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700309 result = requestPauseInternal();
Phil Burk71f35bb2017-04-13 16:05:07 -0700310 return result;
Phil Burke4d7bb42017-03-28 11:32:39 -0700311}
312
Phil Burk5ed503c2017-02-01 09:38:15 -0800313aaudio_result_t AudioStreamInternal::requestFlush() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800314 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700315 ALOGE("AudioStreamInternal::requestFlush() mServiceStreamHandle invalid = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700316 mServiceStreamHandle);
Phil Burk5ed503c2017-02-01 09:38:15 -0800317 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800318 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800319
Phil Burke4d7bb42017-03-28 11:32:39 -0700320 setState(AAUDIO_STREAM_STATE_FLUSHING);
Phil Burkc0c70e32017-02-09 13:18:38 -0800321 return mServiceInterface.flushStream(mServiceStreamHandle);
Phil Burk204a1632017-01-03 17:23:43 -0800322}
323
Phil Burk87c9f642017-05-17 07:22:39 -0700324// TODO for Play only
Phil Burk204a1632017-01-03 17:23:43 -0800325void AudioStreamInternal::onFlushFromServer() {
Phil Burk87c9f642017-05-17 07:22:39 -0700326 int64_t readCounter = mAudioEndpoint.getDataReadCounter();
327 int64_t writeCounter = mAudioEndpoint.getDataWriteCounter();
Phil Burk71f35bb2017-04-13 16:05:07 -0700328
Phil Burk204a1632017-01-03 17:23:43 -0800329 // Bump offset so caller does not see the retrograde motion in getFramesRead().
Phil Burk3316d5e2017-02-15 11:23:01 -0800330 int64_t framesFlushed = writeCounter - readCounter;
Phil Burk204a1632017-01-03 17:23:43 -0800331 mFramesOffsetFromService += framesFlushed;
Phil Burkec89b2e2017-06-20 15:05:06 -0700332 ALOGD("AudioStreamInternal::onFlushFromServer() readN = %lld, writeN = %lld, offset = %lld",
333 (long long)readCounter, (long long)writeCounter, (long long)mFramesOffsetFromService);
Phil Burk71f35bb2017-04-13 16:05:07 -0700334
Phil Burk204a1632017-01-03 17:23:43 -0800335 // Flush written frames by forcing writeCounter to readCounter.
336 // This is because we cannot move the read counter in the hardware.
Phil Burk87c9f642017-05-17 07:22:39 -0700337 mAudioEndpoint.setDataWriteCounter(readCounter);
Phil Burk204a1632017-01-03 17:23:43 -0800338}
339
Phil Burk71f35bb2017-04-13 16:05:07 -0700340aaudio_result_t AudioStreamInternal::requestStopInternal()
341{
342 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700343 ALOGE("AudioStreamInternal::requestStopInternal() mServiceStreamHandle invalid = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700344 mServiceStreamHandle);
345 return AAUDIO_ERROR_INVALID_STATE;
346 }
347
348 mClockModel.stop(AudioClock::getNanoseconds());
349 setState(AAUDIO_STREAM_STATE_STOPPING);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700350 return AAudioConvert_androidToAAudioResult(stopWithStatus());
Phil Burk71f35bb2017-04-13 16:05:07 -0700351}
352
Phil Burk5ed503c2017-02-01 09:38:15 -0800353aaudio_result_t AudioStreamInternal::requestStop()
Phil Burk204a1632017-01-03 17:23:43 -0800354{
Phil Burk71f35bb2017-04-13 16:05:07 -0700355 aaudio_result_t result = stopCallback();
356 if (result != AAUDIO_OK) {
357 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800358 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700359 result = requestStopInternal();
Phil Burk204a1632017-01-03 17:23:43 -0800360 return result;
361}
362
Phil Burk5ed503c2017-02-01 09:38:15 -0800363aaudio_result_t AudioStreamInternal::registerThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800364 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
365 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800366 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800367 return mServiceInterface.registerAudioThread(mServiceStreamHandle,
Phil Burkc0c70e32017-02-09 13:18:38 -0800368 gettid(),
369 getPeriodNanoseconds());
Phil Burk204a1632017-01-03 17:23:43 -0800370}
371
Phil Burk5ed503c2017-02-01 09:38:15 -0800372aaudio_result_t AudioStreamInternal::unregisterThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800373 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
374 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800375 }
Phil Burk2ac035f2017-06-23 14:51:14 -0700376 return mServiceInterface.unregisterAudioThread(mServiceStreamHandle, gettid());
Phil Burk204a1632017-01-03 17:23:43 -0800377}
378
Phil Burk5ed503c2017-02-01 09:38:15 -0800379aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t clockId,
Phil Burk3316d5e2017-02-15 11:23:01 -0800380 int64_t *framePosition,
381 int64_t *timeNanoseconds) {
Phil Burk5204d312017-05-04 17:16:13 -0700382 // TODO Generate in server and pass to client. Return latest.
Phil Burk3316d5e2017-02-15 11:23:01 -0800383 int64_t time = AudioClock::getNanoseconds();
Phil Burkec89b2e2017-06-20 15:05:06 -0700384 *framePosition = mClockModel.convertTimeToPosition(time) + mFramesOffsetFromService;
Phil Burk87c9f642017-05-17 07:22:39 -0700385 // TODO Get a more accurate timestamp from the service. This code just adds a fudge factor.
386 *timeNanoseconds = time + (6 * AAUDIO_NANOS_PER_MILLISECOND);
Phil Burk5ed503c2017-02-01 09:38:15 -0800387 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800388}
389
Phil Burke4d7bb42017-03-28 11:32:39 -0700390aaudio_result_t AudioStreamInternal::updateStateWhileWaiting() {
391 if (isDataCallbackActive()) {
392 return AAUDIO_OK; // state is getting updated by the callback thread read/write call
393 }
Phil Burk204a1632017-01-03 17:23:43 -0800394 return processCommands();
395}
396
Phil Burkec89b2e2017-06-20 15:05:06 -0700397void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
Phil Burk204a1632017-01-03 17:23:43 -0800398 static int64_t oldPosition = 0;
Phil Burk3316d5e2017-02-15 11:23:01 -0800399 static int64_t oldTime = 0;
Phil Burk204a1632017-01-03 17:23:43 -0800400 int64_t framePosition = command.timestamp.position;
Phil Burk3316d5e2017-02-15 11:23:01 -0800401 int64_t nanoTime = command.timestamp.timestamp;
Phil Burkec89b2e2017-06-20 15:05:06 -0700402 ALOGD("AudioStreamInternal: timestamp says framePosition = %08lld at nanoTime %lld",
Phil Burk204a1632017-01-03 17:23:43 -0800403 (long long) framePosition,
404 (long long) nanoTime);
405 int64_t nanosDelta = nanoTime - oldTime;
406 if (nanosDelta > 0 && oldTime > 0) {
407 int64_t framesDelta = framePosition - oldPosition;
Phil Burk5ed503c2017-02-01 09:38:15 -0800408 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
Phil Burkec89b2e2017-06-20 15:05:06 -0700409 ALOGD("AudioStreamInternal: framesDelta = %08lld, nanosDelta = %08lld, rate = %lld",
410 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
Phil Burk204a1632017-01-03 17:23:43 -0800411 }
412 oldPosition = framePosition;
413 oldTime = nanoTime;
414}
Phil Burk204a1632017-01-03 17:23:43 -0800415
Phil Burk5ed503c2017-02-01 09:38:15 -0800416aaudio_result_t AudioStreamInternal::onTimestampFromServer(AAudioServiceMessage *message) {
Phil Burk204a1632017-01-03 17:23:43 -0800417#if LOG_TIMESTAMPS
Phil Burkec89b2e2017-06-20 15:05:06 -0700418 logTimestamp(*message);
Phil Burk204a1632017-01-03 17:23:43 -0800419#endif
Phil Burk87c9f642017-05-17 07:22:39 -0700420 processTimestamp(message->timestamp.position, message->timestamp.timestamp);
Phil Burk5ed503c2017-02-01 09:38:15 -0800421 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800422}
423
Phil Burk5ed503c2017-02-01 09:38:15 -0800424aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
425 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800426 switch (message->event.event) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800427 case AAUDIO_SERVICE_EVENT_STARTED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700428 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_STARTED");
Phil Burk87c9f642017-05-17 07:22:39 -0700429 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
430 setState(AAUDIO_STREAM_STATE_STARTED);
431 }
Phil Burk204a1632017-01-03 17:23:43 -0800432 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800433 case AAUDIO_SERVICE_EVENT_PAUSED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700434 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_PAUSED");
Phil Burk87c9f642017-05-17 07:22:39 -0700435 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
436 setState(AAUDIO_STREAM_STATE_PAUSED);
437 }
Phil Burk204a1632017-01-03 17:23:43 -0800438 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700439 case AAUDIO_SERVICE_EVENT_STOPPED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700440 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_STOPPED");
Phil Burk87c9f642017-05-17 07:22:39 -0700441 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
442 setState(AAUDIO_STREAM_STATE_STOPPED);
443 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700444 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800445 case AAUDIO_SERVICE_EVENT_FLUSHED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700446 ALOGD("AudioStreamInternal::onEventFromServer() got AAUDIO_SERVICE_EVENT_FLUSHED");
Phil Burk87c9f642017-05-17 07:22:39 -0700447 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
448 setState(AAUDIO_STREAM_STATE_FLUSHED);
449 onFlushFromServer();
450 }
Phil Burk204a1632017-01-03 17:23:43 -0800451 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800452 case AAUDIO_SERVICE_EVENT_CLOSED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700453 ALOGD("AudioStreamInternal::onEventFromServer() got AAUDIO_SERVICE_EVENT_CLOSED");
Phil Burk5ed503c2017-02-01 09:38:15 -0800454 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burk204a1632017-01-03 17:23:43 -0800455 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800456 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
457 result = AAUDIO_ERROR_DISCONNECTED;
Phil Burkc0c70e32017-02-09 13:18:38 -0800458 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
Phil Burkec89b2e2017-06-20 15:05:06 -0700459 ALOGW("WARNING - AudioStreamInternal::onEventFromServer()"
460 " AAUDIO_SERVICE_EVENT_DISCONNECTED");
Phil Burk204a1632017-01-03 17:23:43 -0800461 break;
Phil Burkc0c70e32017-02-09 13:18:38 -0800462 case AAUDIO_SERVICE_EVENT_VOLUME:
Eric Laurenta2f296e2017-06-21 18:51:47 -0700463 mStreamVolume = (float)message->event.dataDouble;
464 doSetVolume();
Phil Burkec89b2e2017-06-20 15:05:06 -0700465 ALOGD("AudioStreamInternal::onEventFromServer() AAUDIO_SERVICE_EVENT_VOLUME %lf",
Phil Burke572f462017-04-20 13:03:19 -0700466 message->event.dataDouble);
Phil Burkc0c70e32017-02-09 13:18:38 -0800467 break;
Phil Burk204a1632017-01-03 17:23:43 -0800468 default:
Phil Burkec89b2e2017-06-20 15:05:06 -0700469 ALOGW("WARNING - AudioStreamInternal::onEventFromServer() Unrecognized event = %d",
Phil Burk204a1632017-01-03 17:23:43 -0800470 (int) message->event.event);
471 break;
472 }
473 return result;
474}
475
476// Process all the commands coming from the server.
Phil Burk5ed503c2017-02-01 09:38:15 -0800477aaudio_result_t AudioStreamInternal::processCommands() {
478 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800479
Phil Burk5ed503c2017-02-01 09:38:15 -0800480 while (result == AAUDIO_OK) {
Phil Burkcf5f6d22017-05-26 12:35:07 -0700481 //ALOGD("AudioStreamInternal::processCommands() - looping, %d", result);
Phil Burk5ed503c2017-02-01 09:38:15 -0800482 AAudioServiceMessage message;
Phil Burk204a1632017-01-03 17:23:43 -0800483 if (mAudioEndpoint.readUpCommand(&message) != 1) {
484 break; // no command this time, no problem
485 }
486 switch (message.what) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800487 case AAudioServiceMessage::code::TIMESTAMP:
Phil Burk204a1632017-01-03 17:23:43 -0800488 result = onTimestampFromServer(&message);
489 break;
490
Phil Burk5ed503c2017-02-01 09:38:15 -0800491 case AAudioServiceMessage::code::EVENT:
Phil Burk204a1632017-01-03 17:23:43 -0800492 result = onEventFromServer(&message);
493 break;
494
495 default:
Phil Burk71f35bb2017-04-13 16:05:07 -0700496 ALOGE("WARNING - AudioStreamInternal::processCommands() Unrecognized what = %d",
Phil Burk204a1632017-01-03 17:23:43 -0800497 (int) message.what);
Phil Burk17fff382017-05-16 14:06:45 -0700498 result = AAUDIO_ERROR_INTERNAL;
Phil Burk204a1632017-01-03 17:23:43 -0800499 break;
500 }
501 }
502 return result;
503}
504
Phil Burk87c9f642017-05-17 07:22:39 -0700505// Read or write the data, block if needed and timeoutMillis > 0
506aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
507 int64_t timeoutNanoseconds)
Phil Burk204a1632017-01-03 17:23:43 -0800508{
Phil Burk4485d412017-05-09 15:55:02 -0700509 const char * traceName = (mInService) ? "aaWrtS" : "aaWrtC";
510 ATRACE_BEGIN(traceName);
Phil Burk4485d412017-05-09 15:55:02 -0700511 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
512 if (ATRACE_ENABLED()) {
513 const char * traceName = (mInService) ? "aaFullS" : "aaFullC";
514 ATRACE_INT(traceName, fullFrames);
515 }
516
Phil Burkec89b2e2017-06-20 15:05:06 -0700517 aaudio_result_t result = AAUDIO_OK;
518 int32_t loopCount = 0;
519 uint8_t* audioData = (uint8_t*)buffer;
520 int64_t currentTimeNanos = AudioClock::getNanoseconds();
521 const int64_t entryTimeNanos = currentTimeNanos;
522 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
523 int32_t framesLeft = numFrames;
524
Phil Burk87c9f642017-05-17 07:22:39 -0700525 // Loop until all the data has been processed or until a timeout occurs.
Phil Burk204a1632017-01-03 17:23:43 -0800526 while (framesLeft > 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700527 // The call to processDataNow() will not block. It will just process as much as it can.
Phil Burk3316d5e2017-02-15 11:23:01 -0800528 int64_t wakeTimeNanos = 0;
Phil Burk87c9f642017-05-17 07:22:39 -0700529 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
530 currentTimeNanos, &wakeTimeNanos);
531 if (framesProcessed < 0) {
Phil Burk87c9f642017-05-17 07:22:39 -0700532 result = framesProcessed;
Phil Burk204a1632017-01-03 17:23:43 -0800533 break;
534 }
Phil Burk87c9f642017-05-17 07:22:39 -0700535 framesLeft -= (int32_t) framesProcessed;
536 audioData += framesProcessed * getBytesPerFrame();
Phil Burk204a1632017-01-03 17:23:43 -0800537
538 // Should we block?
539 if (timeoutNanoseconds == 0) {
540 break; // don't block
541 } else if (framesLeft > 0) {
Phil Burk204a1632017-01-03 17:23:43 -0800542 // clip the wake time to something reasonable
543 if (wakeTimeNanos < currentTimeNanos) {
544 wakeTimeNanos = currentTimeNanos;
545 }
546 if (wakeTimeNanos > deadlineNanos) {
547 // If we time out, just return the framesWritten so far.
Phil Burkcf5f6d22017-05-26 12:35:07 -0700548 // TODO remove after we fix the deadline bug
Phil Burkec89b2e2017-06-20 15:05:06 -0700549 ALOGW("AudioStreamInternal::processData(): entered at %lld nanos, currently %lld",
550 (long long) entryTimeNanos, (long long) currentTimeNanos);
551 ALOGW("AudioStreamInternal::processData(): timed out after %lld nanos",
Phil Burkc0c70e32017-02-09 13:18:38 -0800552 (long long) timeoutNanoseconds);
Phil Burkec89b2e2017-06-20 15:05:06 -0700553 ALOGW("AudioStreamInternal::processData(): wakeTime = %lld, deadline = %lld nanos",
Phil Burk87c9f642017-05-17 07:22:39 -0700554 (long long) wakeTimeNanos, (long long) deadlineNanos);
Phil Burkec89b2e2017-06-20 15:05:06 -0700555 ALOGW("AudioStreamInternal::processData(): past deadline by %d micros",
Phil Burk87c9f642017-05-17 07:22:39 -0700556 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
Phil Burkec89b2e2017-06-20 15:05:06 -0700557 mClockModel.dump();
558 mAudioEndpoint.dump();
Phil Burk204a1632017-01-03 17:23:43 -0800559 break;
560 }
561
Phil Burk71f35bb2017-04-13 16:05:07 -0700562 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
563 AudioClock::sleepForNanos(sleepForNanos);
Phil Burk204a1632017-01-03 17:23:43 -0800564 currentTimeNanos = AudioClock::getNanoseconds();
565 }
566 }
567
Phil Burk87c9f642017-05-17 07:22:39 -0700568 // return error or framesProcessed
Phil Burkc0c70e32017-02-09 13:18:38 -0800569 (void) loopCount;
Phil Burk4485d412017-05-09 15:55:02 -0700570 ATRACE_END();
Phil Burk204a1632017-01-03 17:23:43 -0800571 return (result < 0) ? result : numFrames - framesLeft;
572}
573
Phil Burk3316d5e2017-02-15 11:23:01 -0800574void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
Phil Burk87c9f642017-05-17 07:22:39 -0700575 mClockModel.processTimestamp(position, time);
Phil Burk204a1632017-01-03 17:23:43 -0800576}
577
Phil Burk3316d5e2017-02-15 11:23:01 -0800578aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
579 int32_t actualFrames = 0;
Phil Burk71f35bb2017-04-13 16:05:07 -0700580 // Round to the next highest burst size.
581 if (getFramesPerBurst() > 0) {
582 int32_t numBursts = (requestedFrames + getFramesPerBurst() - 1) / getFramesPerBurst();
583 requestedFrames = numBursts * getFramesPerBurst();
584 }
585
Phil Burk3316d5e2017-02-15 11:23:01 -0800586 aaudio_result_t result = mAudioEndpoint.setBufferSizeInFrames(requestedFrames, &actualFrames);
Phil Burkcf5f6d22017-05-26 12:35:07 -0700587 ALOGD("AudioStreamInternal::setBufferSize() req = %d => %d", requestedFrames, actualFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800588 if (result < 0) {
589 return result;
590 } else {
591 return (aaudio_result_t) actualFrames;
592 }
Phil Burk204a1632017-01-03 17:23:43 -0800593}
594
Phil Burk87c9f642017-05-17 07:22:39 -0700595int32_t AudioStreamInternal::getBufferSize() const {
Phil Burk204a1632017-01-03 17:23:43 -0800596 return mAudioEndpoint.getBufferSizeInFrames();
597}
598
Phil Burk87c9f642017-05-17 07:22:39 -0700599int32_t AudioStreamInternal::getBufferCapacity() const {
Phil Burk204a1632017-01-03 17:23:43 -0800600 return mAudioEndpoint.getBufferCapacityInFrames();
601}
602
Phil Burk87c9f642017-05-17 07:22:39 -0700603int32_t AudioStreamInternal::getFramesPerBurst() const {
604 return mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
Phil Burk204a1632017-01-03 17:23:43 -0800605}
606
Phil Burk87c9f642017-05-17 07:22:39 -0700607aaudio_result_t AudioStreamInternal::joinThread(void** returnArg) {
608 return AudioStream::joinThread(returnArg, calculateReasonableTimeout(getFramesPerBurst()));
Phil Burk4c5129b2017-04-28 15:17:32 -0700609}
Eric Laurenta2f296e2017-06-21 18:51:47 -0700610
611void AudioStreamInternal::doSetVolume() {
612 // No pan and only left volume is taken into account from IPLayer interface
613 mVolumeRamp.setTarget(mStreamVolume * mVolumeMultiplierL /* * mPanMultiplierL */);
614}
615
616
617//------------------------------------------------------------------------------
618// Implementation of PlayerBase
619status_t AudioStreamInternal::playerStart() {
620 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.startStream(mServiceStreamHandle));
621}
622
623status_t AudioStreamInternal::playerPause() {
624 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.pauseStream(mServiceStreamHandle));
625}
626
627status_t AudioStreamInternal::playerStop() {
628 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.stopStream(mServiceStreamHandle));
629}
630
631status_t AudioStreamInternal::playerSetVolume() {
632 doSetVolume();
633 return NO_ERROR;
634}
635
636void AudioStreamInternal::destroy() {
637 baseDestroy();
638}