blob: ff13fc2a0be06a5b2f09142b7408414b8961131c [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
Phil Burk71f35bb2017-04-13 16:05:07 -0700290aaudio_result_t AudioStreamInternal::requestStopInternal()
291{
292 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700293 ALOGE("AudioStreamInternal::requestStopInternal() mServiceStreamHandle invalid = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700294 mServiceStreamHandle);
295 return AAUDIO_ERROR_INVALID_STATE;
296 }
297
298 mClockModel.stop(AudioClock::getNanoseconds());
299 setState(AAUDIO_STREAM_STATE_STOPPING);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700300 return AAudioConvert_androidToAAudioResult(stopWithStatus());
Phil Burk71f35bb2017-04-13 16:05:07 -0700301}
302
Phil Burk5ed503c2017-02-01 09:38:15 -0800303aaudio_result_t AudioStreamInternal::requestStop()
Phil Burk204a1632017-01-03 17:23:43 -0800304{
Phil Burk71f35bb2017-04-13 16:05:07 -0700305 aaudio_result_t result = stopCallback();
306 if (result != AAUDIO_OK) {
307 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800308 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700309 result = requestStopInternal();
Phil Burk204a1632017-01-03 17:23:43 -0800310 return result;
311}
312
Phil Burk5ed503c2017-02-01 09:38:15 -0800313aaudio_result_t AudioStreamInternal::registerThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800314 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
315 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800316 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800317 return mServiceInterface.registerAudioThread(mServiceStreamHandle,
Phil Burkc0c70e32017-02-09 13:18:38 -0800318 gettid(),
319 getPeriodNanoseconds());
Phil Burk204a1632017-01-03 17:23:43 -0800320}
321
Phil Burk5ed503c2017-02-01 09:38:15 -0800322aaudio_result_t AudioStreamInternal::unregisterThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800323 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
324 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800325 }
Phil Burk2ac035f2017-06-23 14:51:14 -0700326 return mServiceInterface.unregisterAudioThread(mServiceStreamHandle, gettid());
Phil Burk204a1632017-01-03 17:23:43 -0800327}
328
Phil Burk5ed503c2017-02-01 09:38:15 -0800329aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t clockId,
Phil Burk3316d5e2017-02-15 11:23:01 -0800330 int64_t *framePosition,
331 int64_t *timeNanoseconds) {
Phil Burk5204d312017-05-04 17:16:13 -0700332 // TODO Generate in server and pass to client. Return latest.
Phil Burk3316d5e2017-02-15 11:23:01 -0800333 int64_t time = AudioClock::getNanoseconds();
Phil Burkec89b2e2017-06-20 15:05:06 -0700334 *framePosition = mClockModel.convertTimeToPosition(time) + mFramesOffsetFromService;
Phil Burk87c9f642017-05-17 07:22:39 -0700335 // TODO Get a more accurate timestamp from the service. This code just adds a fudge factor.
336 *timeNanoseconds = time + (6 * AAUDIO_NANOS_PER_MILLISECOND);
Phil Burk5ed503c2017-02-01 09:38:15 -0800337 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800338}
339
Phil Burke4d7bb42017-03-28 11:32:39 -0700340aaudio_result_t AudioStreamInternal::updateStateWhileWaiting() {
341 if (isDataCallbackActive()) {
342 return AAUDIO_OK; // state is getting updated by the callback thread read/write call
343 }
Phil Burk204a1632017-01-03 17:23:43 -0800344 return processCommands();
345}
346
Phil Burkec89b2e2017-06-20 15:05:06 -0700347void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
Phil Burk204a1632017-01-03 17:23:43 -0800348 static int64_t oldPosition = 0;
Phil Burk3316d5e2017-02-15 11:23:01 -0800349 static int64_t oldTime = 0;
Phil Burk204a1632017-01-03 17:23:43 -0800350 int64_t framePosition = command.timestamp.position;
Phil Burk3316d5e2017-02-15 11:23:01 -0800351 int64_t nanoTime = command.timestamp.timestamp;
Phil Burkec89b2e2017-06-20 15:05:06 -0700352 ALOGD("AudioStreamInternal: timestamp says framePosition = %08lld at nanoTime %lld",
Phil Burk204a1632017-01-03 17:23:43 -0800353 (long long) framePosition,
354 (long long) nanoTime);
355 int64_t nanosDelta = nanoTime - oldTime;
356 if (nanosDelta > 0 && oldTime > 0) {
357 int64_t framesDelta = framePosition - oldPosition;
Phil Burk5ed503c2017-02-01 09:38:15 -0800358 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
Phil Burkec89b2e2017-06-20 15:05:06 -0700359 ALOGD("AudioStreamInternal: framesDelta = %08lld, nanosDelta = %08lld, rate = %lld",
360 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
Phil Burk204a1632017-01-03 17:23:43 -0800361 }
362 oldPosition = framePosition;
363 oldTime = nanoTime;
364}
Phil Burk204a1632017-01-03 17:23:43 -0800365
Phil Burk5ed503c2017-02-01 09:38:15 -0800366aaudio_result_t AudioStreamInternal::onTimestampFromServer(AAudioServiceMessage *message) {
Phil Burk204a1632017-01-03 17:23:43 -0800367#if LOG_TIMESTAMPS
Phil Burkec89b2e2017-06-20 15:05:06 -0700368 logTimestamp(*message);
Phil Burk204a1632017-01-03 17:23:43 -0800369#endif
Phil Burk87c9f642017-05-17 07:22:39 -0700370 processTimestamp(message->timestamp.position, message->timestamp.timestamp);
Phil Burk5ed503c2017-02-01 09:38:15 -0800371 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800372}
373
Phil Burk5ed503c2017-02-01 09:38:15 -0800374aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
375 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800376 switch (message->event.event) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800377 case AAUDIO_SERVICE_EVENT_STARTED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700378 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_STARTED");
Phil Burk87c9f642017-05-17 07:22:39 -0700379 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
380 setState(AAUDIO_STREAM_STATE_STARTED);
381 }
Phil Burk204a1632017-01-03 17:23:43 -0800382 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800383 case AAUDIO_SERVICE_EVENT_PAUSED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700384 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_PAUSED");
Phil Burk87c9f642017-05-17 07:22:39 -0700385 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
386 setState(AAUDIO_STREAM_STATE_PAUSED);
387 }
Phil Burk204a1632017-01-03 17:23:43 -0800388 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700389 case AAUDIO_SERVICE_EVENT_STOPPED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700390 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_STOPPED");
Phil Burk87c9f642017-05-17 07:22:39 -0700391 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
392 setState(AAUDIO_STREAM_STATE_STOPPED);
393 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700394 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800395 case AAUDIO_SERVICE_EVENT_FLUSHED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700396 ALOGD("AudioStreamInternal::onEventFromServer() got AAUDIO_SERVICE_EVENT_FLUSHED");
Phil Burk87c9f642017-05-17 07:22:39 -0700397 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
398 setState(AAUDIO_STREAM_STATE_FLUSHED);
399 onFlushFromServer();
400 }
Phil Burk204a1632017-01-03 17:23:43 -0800401 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800402 case AAUDIO_SERVICE_EVENT_CLOSED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700403 ALOGD("AudioStreamInternal::onEventFromServer() got AAUDIO_SERVICE_EVENT_CLOSED");
Phil Burk5ed503c2017-02-01 09:38:15 -0800404 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burk204a1632017-01-03 17:23:43 -0800405 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800406 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
407 result = AAUDIO_ERROR_DISCONNECTED;
Phil Burkc0c70e32017-02-09 13:18:38 -0800408 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
Phil Burkec89b2e2017-06-20 15:05:06 -0700409 ALOGW("WARNING - AudioStreamInternal::onEventFromServer()"
410 " AAUDIO_SERVICE_EVENT_DISCONNECTED");
Phil Burk204a1632017-01-03 17:23:43 -0800411 break;
Phil Burkc0c70e32017-02-09 13:18:38 -0800412 case AAUDIO_SERVICE_EVENT_VOLUME:
Eric Laurenta2f296e2017-06-21 18:51:47 -0700413 mStreamVolume = (float)message->event.dataDouble;
414 doSetVolume();
Phil Burkec89b2e2017-06-20 15:05:06 -0700415 ALOGD("AudioStreamInternal::onEventFromServer() AAUDIO_SERVICE_EVENT_VOLUME %lf",
Phil Burke572f462017-04-20 13:03:19 -0700416 message->event.dataDouble);
Phil Burkc0c70e32017-02-09 13:18:38 -0800417 break;
Phil Burk204a1632017-01-03 17:23:43 -0800418 default:
Phil Burkec89b2e2017-06-20 15:05:06 -0700419 ALOGW("WARNING - AudioStreamInternal::onEventFromServer() Unrecognized event = %d",
Phil Burk204a1632017-01-03 17:23:43 -0800420 (int) message->event.event);
421 break;
422 }
423 return result;
424}
425
426// Process all the commands coming from the server.
Phil Burk5ed503c2017-02-01 09:38:15 -0800427aaudio_result_t AudioStreamInternal::processCommands() {
428 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800429
Phil Burk5ed503c2017-02-01 09:38:15 -0800430 while (result == AAUDIO_OK) {
Phil Burkcf5f6d22017-05-26 12:35:07 -0700431 //ALOGD("AudioStreamInternal::processCommands() - looping, %d", result);
Phil Burk5ed503c2017-02-01 09:38:15 -0800432 AAudioServiceMessage message;
Phil Burk204a1632017-01-03 17:23:43 -0800433 if (mAudioEndpoint.readUpCommand(&message) != 1) {
434 break; // no command this time, no problem
435 }
436 switch (message.what) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800437 case AAudioServiceMessage::code::TIMESTAMP:
Phil Burk204a1632017-01-03 17:23:43 -0800438 result = onTimestampFromServer(&message);
439 break;
440
Phil Burk5ed503c2017-02-01 09:38:15 -0800441 case AAudioServiceMessage::code::EVENT:
Phil Burk204a1632017-01-03 17:23:43 -0800442 result = onEventFromServer(&message);
443 break;
444
445 default:
Phil Burk71f35bb2017-04-13 16:05:07 -0700446 ALOGE("WARNING - AudioStreamInternal::processCommands() Unrecognized what = %d",
Phil Burk204a1632017-01-03 17:23:43 -0800447 (int) message.what);
Phil Burk17fff382017-05-16 14:06:45 -0700448 result = AAUDIO_ERROR_INTERNAL;
Phil Burk204a1632017-01-03 17:23:43 -0800449 break;
450 }
451 }
452 return result;
453}
454
Phil Burk87c9f642017-05-17 07:22:39 -0700455// Read or write the data, block if needed and timeoutMillis > 0
456aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
457 int64_t timeoutNanoseconds)
Phil Burk204a1632017-01-03 17:23:43 -0800458{
Phil Burk4485d412017-05-09 15:55:02 -0700459 const char * traceName = (mInService) ? "aaWrtS" : "aaWrtC";
460 ATRACE_BEGIN(traceName);
Phil Burk4485d412017-05-09 15:55:02 -0700461 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
462 if (ATRACE_ENABLED()) {
463 const char * traceName = (mInService) ? "aaFullS" : "aaFullC";
464 ATRACE_INT(traceName, fullFrames);
465 }
466
Phil Burkec89b2e2017-06-20 15:05:06 -0700467 aaudio_result_t result = AAUDIO_OK;
468 int32_t loopCount = 0;
469 uint8_t* audioData = (uint8_t*)buffer;
470 int64_t currentTimeNanos = AudioClock::getNanoseconds();
471 const int64_t entryTimeNanos = currentTimeNanos;
472 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
473 int32_t framesLeft = numFrames;
474
Phil Burk87c9f642017-05-17 07:22:39 -0700475 // Loop until all the data has been processed or until a timeout occurs.
Phil Burk204a1632017-01-03 17:23:43 -0800476 while (framesLeft > 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700477 // The call to processDataNow() will not block. It will just process as much as it can.
Phil Burk3316d5e2017-02-15 11:23:01 -0800478 int64_t wakeTimeNanos = 0;
Phil Burk87c9f642017-05-17 07:22:39 -0700479 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
480 currentTimeNanos, &wakeTimeNanos);
481 if (framesProcessed < 0) {
Phil Burk87c9f642017-05-17 07:22:39 -0700482 result = framesProcessed;
Phil Burk204a1632017-01-03 17:23:43 -0800483 break;
484 }
Phil Burk87c9f642017-05-17 07:22:39 -0700485 framesLeft -= (int32_t) framesProcessed;
486 audioData += framesProcessed * getBytesPerFrame();
Phil Burk204a1632017-01-03 17:23:43 -0800487
488 // Should we block?
489 if (timeoutNanoseconds == 0) {
490 break; // don't block
491 } else if (framesLeft > 0) {
Phil Burk204a1632017-01-03 17:23:43 -0800492 // clip the wake time to something reasonable
493 if (wakeTimeNanos < currentTimeNanos) {
494 wakeTimeNanos = currentTimeNanos;
495 }
496 if (wakeTimeNanos > deadlineNanos) {
497 // If we time out, just return the framesWritten so far.
Phil Burkcf5f6d22017-05-26 12:35:07 -0700498 // TODO remove after we fix the deadline bug
Phil Burkec89b2e2017-06-20 15:05:06 -0700499 ALOGW("AudioStreamInternal::processData(): entered at %lld nanos, currently %lld",
500 (long long) entryTimeNanos, (long long) currentTimeNanos);
501 ALOGW("AudioStreamInternal::processData(): timed out after %lld nanos",
Phil Burkc0c70e32017-02-09 13:18:38 -0800502 (long long) timeoutNanoseconds);
Phil Burkec89b2e2017-06-20 15:05:06 -0700503 ALOGW("AudioStreamInternal::processData(): wakeTime = %lld, deadline = %lld nanos",
Phil Burk87c9f642017-05-17 07:22:39 -0700504 (long long) wakeTimeNanos, (long long) deadlineNanos);
Phil Burkec89b2e2017-06-20 15:05:06 -0700505 ALOGW("AudioStreamInternal::processData(): past deadline by %d micros",
Phil Burk87c9f642017-05-17 07:22:39 -0700506 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
Phil Burkec89b2e2017-06-20 15:05:06 -0700507 mClockModel.dump();
508 mAudioEndpoint.dump();
Phil Burk204a1632017-01-03 17:23:43 -0800509 break;
510 }
511
Phil Burk71f35bb2017-04-13 16:05:07 -0700512 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
513 AudioClock::sleepForNanos(sleepForNanos);
Phil Burk204a1632017-01-03 17:23:43 -0800514 currentTimeNanos = AudioClock::getNanoseconds();
515 }
516 }
517
Phil Burk87c9f642017-05-17 07:22:39 -0700518 // return error or framesProcessed
Phil Burkc0c70e32017-02-09 13:18:38 -0800519 (void) loopCount;
Phil Burk4485d412017-05-09 15:55:02 -0700520 ATRACE_END();
Phil Burk204a1632017-01-03 17:23:43 -0800521 return (result < 0) ? result : numFrames - framesLeft;
522}
523
Phil Burk3316d5e2017-02-15 11:23:01 -0800524void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
Phil Burk87c9f642017-05-17 07:22:39 -0700525 mClockModel.processTimestamp(position, time);
Phil Burk204a1632017-01-03 17:23:43 -0800526}
527
Phil Burk3316d5e2017-02-15 11:23:01 -0800528aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
529 int32_t actualFrames = 0;
Phil Burk71f35bb2017-04-13 16:05:07 -0700530 // Round to the next highest burst size.
531 if (getFramesPerBurst() > 0) {
532 int32_t numBursts = (requestedFrames + getFramesPerBurst() - 1) / getFramesPerBurst();
533 requestedFrames = numBursts * getFramesPerBurst();
534 }
535
Phil Burk3316d5e2017-02-15 11:23:01 -0800536 aaudio_result_t result = mAudioEndpoint.setBufferSizeInFrames(requestedFrames, &actualFrames);
Phil Burkcf5f6d22017-05-26 12:35:07 -0700537 ALOGD("AudioStreamInternal::setBufferSize() req = %d => %d", requestedFrames, actualFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800538 if (result < 0) {
539 return result;
540 } else {
541 return (aaudio_result_t) actualFrames;
542 }
Phil Burk204a1632017-01-03 17:23:43 -0800543}
544
Phil Burk87c9f642017-05-17 07:22:39 -0700545int32_t AudioStreamInternal::getBufferSize() const {
Phil Burk204a1632017-01-03 17:23:43 -0800546 return mAudioEndpoint.getBufferSizeInFrames();
547}
548
Phil Burk87c9f642017-05-17 07:22:39 -0700549int32_t AudioStreamInternal::getBufferCapacity() const {
Phil Burk204a1632017-01-03 17:23:43 -0800550 return mAudioEndpoint.getBufferCapacityInFrames();
551}
552
Phil Burk87c9f642017-05-17 07:22:39 -0700553int32_t AudioStreamInternal::getFramesPerBurst() const {
554 return mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
Phil Burk204a1632017-01-03 17:23:43 -0800555}
556
Phil Burk87c9f642017-05-17 07:22:39 -0700557aaudio_result_t AudioStreamInternal::joinThread(void** returnArg) {
558 return AudioStream::joinThread(returnArg, calculateReasonableTimeout(getFramesPerBurst()));
Phil Burk4c5129b2017-04-28 15:17:32 -0700559}
Eric Laurenta2f296e2017-06-21 18:51:47 -0700560
561void AudioStreamInternal::doSetVolume() {
562 // No pan and only left volume is taken into account from IPLayer interface
563 mVolumeRamp.setTarget(mStreamVolume * mVolumeMultiplierL /* * mPanMultiplierL */);
564}
565
566
567//------------------------------------------------------------------------------
568// Implementation of PlayerBase
569status_t AudioStreamInternal::playerStart() {
570 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.startStream(mServiceStreamHandle));
571}
572
573status_t AudioStreamInternal::playerPause() {
574 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.pauseStream(mServiceStreamHandle));
575}
576
577status_t AudioStreamInternal::playerStop() {
578 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.stopStream(mServiceStreamHandle));
579}
580
581status_t AudioStreamInternal::playerSetVolume() {
582 doSetVolume();
583 return NO_ERROR;
584}
585
586void AudioStreamInternal::destroy() {
587 baseDestroy();
588}