blob: 7b01e443bb0890e5074f48709572183f64ecaf12 [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.
Eric Laurentcb4dae22017-07-01 19:39:32 -070019#define LOG_TAG (mInService ? "AudioStreamInternal_Service" : "AudioStreamInternal_Client")
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());
Eric Laurentcb4dae22017-07-01 19:39:32 -070096 request.setInService(mInService);
Phil Burkc0c70e32017-02-09 13:18:38 -080097
Phil Burk204a1632017-01-03 17:23:43 -080098 request.getConfiguration().setDeviceId(getDeviceId());
99 request.getConfiguration().setSampleRate(getSampleRate());
100 request.getConfiguration().setSamplesPerFrame(getSamplesPerFrame());
Phil Burk71f35bb2017-04-13 16:05:07 -0700101 request.getConfiguration().setSharingMode(getSharingMode());
102
Phil Burk3df348f2017-02-08 11:41:55 -0800103 request.getConfiguration().setBufferCapacity(builder.getBufferCapacity());
Phil Burk204a1632017-01-03 17:23:43 -0800104
Phil Burkc0c70e32017-02-09 13:18:38 -0800105 mServiceStreamHandle = mServiceInterface.openStream(request, configuration);
Phil Burk204a1632017-01-03 17:23:43 -0800106 if (mServiceStreamHandle < 0) {
107 result = mServiceStreamHandle;
Phil Burkcf5f6d22017-05-26 12:35:07 -0700108 ALOGE("AudioStreamInternal.open(): openStream() returned %d", result);
Phil Burk204a1632017-01-03 17:23:43 -0800109 } else {
110 result = configuration.validate();
Phil Burk5ed503c2017-02-01 09:38:15 -0800111 if (result != AAUDIO_OK) {
Phil Burk204a1632017-01-03 17:23:43 -0800112 close();
113 return result;
114 }
115 // Save results of the open.
116 setSampleRate(configuration.getSampleRate());
117 setSamplesPerFrame(configuration.getSamplesPerFrame());
Phil Burkc0c70e32017-02-09 13:18:38 -0800118 setDeviceId(configuration.getDeviceId());
Eric Laurentd51329e2017-06-30 16:06:16 -0700119 setSharingMode(configuration.getSharingMode());
Phil Burk204a1632017-01-03 17:23:43 -0800120
Phil Burkc0c70e32017-02-09 13:18:38 -0800121 // Save device format so we can do format conversion and volume scaling together.
122 mDeviceFormat = configuration.getAudioFormat();
123
124 result = mServiceInterface.getStreamDescription(mServiceStreamHandle, mEndPointParcelable);
Phil Burk5ed503c2017-02-01 09:38:15 -0800125 if (result != AAUDIO_OK) {
Phil Burkc0c70e32017-02-09 13:18:38 -0800126 mServiceInterface.closeStream(mServiceStreamHandle);
Phil Burk204a1632017-01-03 17:23:43 -0800127 return result;
128 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800129
Phil Burk204a1632017-01-03 17:23:43 -0800130 // resolve parcelable into a descriptor
Phil Burkc0c70e32017-02-09 13:18:38 -0800131 result = mEndPointParcelable.resolve(&mEndpointDescriptor);
132 if (result != AAUDIO_OK) {
Phil Burkc0c70e32017-02-09 13:18:38 -0800133 mServiceInterface.closeStream(mServiceStreamHandle);
134 return result;
135 }
Phil Burk204a1632017-01-03 17:23:43 -0800136
137 // Configure endpoint based on descriptor.
138 mAudioEndpoint.configure(&mEndpointDescriptor);
139
Phil Burk87c9f642017-05-17 07:22:39 -0700140 mFramesPerBurst = mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
141 int32_t capacity = mEndpointDescriptor.dataQueueDescriptor.capacityInFrames;
Phil Burk71f35bb2017-04-13 16:05:07 -0700142
Phil Burk71f35bb2017-04-13 16:05:07 -0700143 // Validate result from server.
144 if (mFramesPerBurst < 16 || mFramesPerBurst > 16 * 1024) {
145 ALOGE("AudioStream::open(): framesPerBurst out of range = %d", mFramesPerBurst);
146 return AAUDIO_ERROR_OUT_OF_RANGE;
147 }
148 if (capacity < mFramesPerBurst || capacity > 32 * 1024) {
149 ALOGE("AudioStream::open(): bufferCapacity out of range = %d", capacity);
150 return AAUDIO_ERROR_OUT_OF_RANGE;
151 }
Phil Burk204a1632017-01-03 17:23:43 -0800152
153 mClockModel.setSampleRate(getSampleRate());
154 mClockModel.setFramesPerBurst(mFramesPerBurst);
155
Phil Burke4d7bb42017-03-28 11:32:39 -0700156 if (getDataCallbackProc()) {
157 mCallbackFrames = builder.getFramesPerDataCallback();
158 if (mCallbackFrames > getBufferCapacity() / 2) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700159 ALOGE("AudioStreamInternal::open(): framesPerCallback too big = %d, capacity = %d",
Phil Burk71f35bb2017-04-13 16:05:07 -0700160 mCallbackFrames, getBufferCapacity());
Phil Burkc0c70e32017-02-09 13:18:38 -0800161 mServiceInterface.closeStream(mServiceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700162 return AAUDIO_ERROR_OUT_OF_RANGE;
163
164 } else if (mCallbackFrames < 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700165 ALOGE("AudioStreamInternal::open(): framesPerCallback negative");
Phil Burkc0c70e32017-02-09 13:18:38 -0800166 mServiceInterface.closeStream(mServiceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700167 return AAUDIO_ERROR_OUT_OF_RANGE;
168
169 }
170 if (mCallbackFrames == AAUDIO_UNSPECIFIED) {
171 mCallbackFrames = mFramesPerBurst;
172 }
173
174 int32_t bytesPerFrame = getSamplesPerFrame()
175 * AAudioConvert_formatToSizeInBytes(getFormat());
176 int32_t callbackBufferSize = mCallbackFrames * bytesPerFrame;
177 mCallbackBuffer = new uint8_t[callbackBufferSize];
178 }
179
Phil Burk5ed503c2017-02-01 09:38:15 -0800180 setState(AAUDIO_STREAM_STATE_OPEN);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700181 // only connect to AudioManager if this is a playback stream running in client process
182 if (!mInService && getDirection() == AAUDIO_DIRECTION_OUTPUT) {
183 init(android::PLAYER_TYPE_AAUDIO, AUDIO_USAGE_MEDIA);
184 }
Phil Burk204a1632017-01-03 17:23:43 -0800185 }
186 return result;
187}
188
Phil Burk5ed503c2017-02-01 09:38:15 -0800189aaudio_result_t AudioStreamInternal::close() {
Phil Burkec89b2e2017-06-20 15:05:06 -0700190 ALOGD("AudioStreamInternal::close(): mServiceStreamHandle = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700191 mServiceStreamHandle);
Phil Burk5ed503c2017-02-01 09:38:15 -0800192 if (mServiceStreamHandle != AAUDIO_HANDLE_INVALID) {
Phil Burk4485d412017-05-09 15:55:02 -0700193 // Don't close a stream while it is running.
194 aaudio_stream_state_t currentState = getState();
Phil Burk87c9f642017-05-17 07:22:39 -0700195 if (isActive()) {
Phil Burk4485d412017-05-09 15:55:02 -0700196 requestStop();
197 aaudio_stream_state_t nextState;
198 int64_t timeoutNanoseconds = MIN_TIMEOUT_NANOS;
199 aaudio_result_t result = waitForStateChange(currentState, &nextState,
200 timeoutNanoseconds);
201 if (result != AAUDIO_OK) {
202 ALOGE("AudioStreamInternal::close() waitForStateChange() returned %d %s",
203 result, AAudio_convertResultToText(result));
204 }
205 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700206 setState(AAUDIO_STREAM_STATE_CLOSING);
Phil Burk5ed503c2017-02-01 09:38:15 -0800207 aaudio_handle_t serviceStreamHandle = mServiceStreamHandle;
208 mServiceStreamHandle = AAUDIO_HANDLE_INVALID;
Phil Burkc0c70e32017-02-09 13:18:38 -0800209
210 mServiceInterface.closeStream(serviceStreamHandle);
Phil Burke4d7bb42017-03-28 11:32:39 -0700211 delete[] mCallbackBuffer;
Phil Burk4485d412017-05-09 15:55:02 -0700212 mCallbackBuffer = nullptr;
Phil Burkec89b2e2017-06-20 15:05:06 -0700213 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burkc0c70e32017-02-09 13:18:38 -0800214 return mEndPointParcelable.close();
Phil Burk204a1632017-01-03 17:23:43 -0800215 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800216 return AAUDIO_ERROR_INVALID_HANDLE;
Phil Burk204a1632017-01-03 17:23:43 -0800217 }
218}
219
Phil Burkc0c70e32017-02-09 13:18:38 -0800220
Phil Burke4d7bb42017-03-28 11:32:39 -0700221static void *aaudio_callback_thread_proc(void *context)
222{
223 AudioStreamInternal *stream = (AudioStreamInternal *)context;
Phil Burk677d7912017-04-07 12:17:12 -0700224 //LOGD("AudioStreamInternal(): oboe_callback_thread, stream = %p", stream);
Phil Burke4d7bb42017-03-28 11:32:39 -0700225 if (stream != NULL) {
226 return stream->callbackLoop();
227 } else {
228 return NULL;
229 }
230}
231
Phil Burk5ed503c2017-02-01 09:38:15 -0800232aaudio_result_t AudioStreamInternal::requestStart()
Phil Burk204a1632017-01-03 17:23:43 -0800233{
Phil Burk3316d5e2017-02-15 11:23:01 -0800234 int64_t startTime;
Phil Burkec89b2e2017-06-20 15:05:06 -0700235 ALOGD("AudioStreamInternal()::requestStart()");
Phil Burk5ed503c2017-02-01 09:38:15 -0800236 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
237 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800238 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700239 if (isActive()) {
240 return AAUDIO_ERROR_INVALID_STATE;
241 }
242 aaudio_stream_state_t originalState = getState();
243
244 setState(AAUDIO_STREAM_STATE_STARTING);
245 aaudio_result_t result = AAudioConvert_androidToAAudioResult(startWithStatus());
Phil Burkc0c70e32017-02-09 13:18:38 -0800246
Phil Burk3316d5e2017-02-15 11:23:01 -0800247 startTime = AudioClock::getNanoseconds();
Phil Burk204a1632017-01-03 17:23:43 -0800248 mClockModel.start(startTime);
Phil Burke4d7bb42017-03-28 11:32:39 -0700249
250 if (result == AAUDIO_OK && getDataCallbackProc() != nullptr) {
251 // Launch the callback loop thread.
252 int64_t periodNanos = mCallbackFrames
253 * AAUDIO_NANOS_PER_SECOND
254 / getSampleRate();
255 mCallbackEnabled.store(true);
256 result = createThread(periodNanos, aaudio_callback_thread_proc, this);
257 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700258 if (result != AAUDIO_OK) {
259 setState(originalState);
260 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700261 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800262}
263
Phil Burke4d7bb42017-03-28 11:32:39 -0700264int64_t AudioStreamInternal::calculateReasonableTimeout(int32_t framesPerOperation) {
265
266 // Wait for at least a second or some number of callbacks to join the thread.
Phil Burk71f35bb2017-04-13 16:05:07 -0700267 int64_t timeoutNanoseconds = (MIN_TIMEOUT_OPERATIONS
268 * framesPerOperation
269 * AAUDIO_NANOS_PER_SECOND)
270 / getSampleRate();
Phil Burke4d7bb42017-03-28 11:32:39 -0700271 if (timeoutNanoseconds < MIN_TIMEOUT_NANOS) { // arbitrary number of seconds
272 timeoutNanoseconds = MIN_TIMEOUT_NANOS;
273 }
274 return timeoutNanoseconds;
275}
276
Phil Burk87c9f642017-05-17 07:22:39 -0700277int64_t AudioStreamInternal::calculateReasonableTimeout() {
278 return calculateReasonableTimeout(getFramesPerBurst());
279}
280
Phil Burke4d7bb42017-03-28 11:32:39 -0700281aaudio_result_t AudioStreamInternal::stopCallback()
282{
283 if (isDataCallbackActive()) {
284 mCallbackEnabled.store(false);
Phil Burk87c9f642017-05-17 07:22:39 -0700285 return joinThread(NULL);
Phil Burke4d7bb42017-03-28 11:32:39 -0700286 } else {
287 return AAUDIO_OK;
288 }
289}
290
Phil Burk71f35bb2017-04-13 16:05:07 -0700291aaudio_result_t AudioStreamInternal::requestStopInternal()
292{
293 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700294 ALOGE("AudioStreamInternal::requestStopInternal() mServiceStreamHandle invalid = 0x%08X",
Phil Burk71f35bb2017-04-13 16:05:07 -0700295 mServiceStreamHandle);
296 return AAUDIO_ERROR_INVALID_STATE;
297 }
298
299 mClockModel.stop(AudioClock::getNanoseconds());
300 setState(AAUDIO_STREAM_STATE_STOPPING);
Eric Laurenta2f296e2017-06-21 18:51:47 -0700301 return AAudioConvert_androidToAAudioResult(stopWithStatus());
Phil Burk71f35bb2017-04-13 16:05:07 -0700302}
303
Phil Burk5ed503c2017-02-01 09:38:15 -0800304aaudio_result_t AudioStreamInternal::requestStop()
Phil Burk204a1632017-01-03 17:23:43 -0800305{
Phil Burk71f35bb2017-04-13 16:05:07 -0700306 aaudio_result_t result = stopCallback();
307 if (result != AAUDIO_OK) {
308 return result;
Phil Burk204a1632017-01-03 17:23:43 -0800309 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700310 result = requestStopInternal();
Phil Burk204a1632017-01-03 17:23:43 -0800311 return result;
312}
313
Phil Burk5ed503c2017-02-01 09:38:15 -0800314aaudio_result_t AudioStreamInternal::registerThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800315 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
316 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800317 }
Phil Burkc0c70e32017-02-09 13:18:38 -0800318 return mServiceInterface.registerAudioThread(mServiceStreamHandle,
Phil Burkc0c70e32017-02-09 13:18:38 -0800319 gettid(),
320 getPeriodNanoseconds());
Phil Burk204a1632017-01-03 17:23:43 -0800321}
322
Phil Burk5ed503c2017-02-01 09:38:15 -0800323aaudio_result_t AudioStreamInternal::unregisterThread() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800324 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
325 return AAUDIO_ERROR_INVALID_STATE;
Phil Burk204a1632017-01-03 17:23:43 -0800326 }
Phil Burk2ac035f2017-06-23 14:51:14 -0700327 return mServiceInterface.unregisterAudioThread(mServiceStreamHandle, gettid());
Phil Burk204a1632017-01-03 17:23:43 -0800328}
329
Eric Laurentcb4dae22017-07-01 19:39:32 -0700330aaudio_result_t AudioStreamInternal::startClient(const android::AudioClient& client,
331 audio_port_handle_t *clientHandle) {
332 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
333 return AAUDIO_ERROR_INVALID_STATE;
334 }
335 return mServiceInterface.startClient(mServiceStreamHandle, client, clientHandle);
336}
337
338aaudio_result_t AudioStreamInternal::stopClient(audio_port_handle_t clientHandle) {
339 if (mServiceStreamHandle == AAUDIO_HANDLE_INVALID) {
340 return AAUDIO_ERROR_INVALID_STATE;
341 }
342 return mServiceInterface.stopClient(mServiceStreamHandle, clientHandle);
343}
344
Phil Burk5ed503c2017-02-01 09:38:15 -0800345aaudio_result_t AudioStreamInternal::getTimestamp(clockid_t clockId,
Phil Burk3316d5e2017-02-15 11:23:01 -0800346 int64_t *framePosition,
347 int64_t *timeNanoseconds) {
Phil Burk5204d312017-05-04 17:16:13 -0700348 // TODO Generate in server and pass to client. Return latest.
Phil Burk3316d5e2017-02-15 11:23:01 -0800349 int64_t time = AudioClock::getNanoseconds();
Phil Burkec89b2e2017-06-20 15:05:06 -0700350 *framePosition = mClockModel.convertTimeToPosition(time) + mFramesOffsetFromService;
Phil Burk87c9f642017-05-17 07:22:39 -0700351 // TODO Get a more accurate timestamp from the service. This code just adds a fudge factor.
352 *timeNanoseconds = time + (6 * AAUDIO_NANOS_PER_MILLISECOND);
Phil Burk5ed503c2017-02-01 09:38:15 -0800353 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800354}
355
Phil Burke4d7bb42017-03-28 11:32:39 -0700356aaudio_result_t AudioStreamInternal::updateStateWhileWaiting() {
357 if (isDataCallbackActive()) {
358 return AAUDIO_OK; // state is getting updated by the callback thread read/write call
359 }
Phil Burk204a1632017-01-03 17:23:43 -0800360 return processCommands();
361}
362
Phil Burkec89b2e2017-06-20 15:05:06 -0700363void AudioStreamInternal::logTimestamp(AAudioServiceMessage &command) {
Phil Burk204a1632017-01-03 17:23:43 -0800364 static int64_t oldPosition = 0;
Phil Burk3316d5e2017-02-15 11:23:01 -0800365 static int64_t oldTime = 0;
Phil Burk204a1632017-01-03 17:23:43 -0800366 int64_t framePosition = command.timestamp.position;
Phil Burk3316d5e2017-02-15 11:23:01 -0800367 int64_t nanoTime = command.timestamp.timestamp;
Phil Burkec89b2e2017-06-20 15:05:06 -0700368 ALOGD("AudioStreamInternal: timestamp says framePosition = %08lld at nanoTime %lld",
Phil Burk204a1632017-01-03 17:23:43 -0800369 (long long) framePosition,
370 (long long) nanoTime);
371 int64_t nanosDelta = nanoTime - oldTime;
372 if (nanosDelta > 0 && oldTime > 0) {
373 int64_t framesDelta = framePosition - oldPosition;
Phil Burk5ed503c2017-02-01 09:38:15 -0800374 int64_t rate = (framesDelta * AAUDIO_NANOS_PER_SECOND) / nanosDelta;
Phil Burkec89b2e2017-06-20 15:05:06 -0700375 ALOGD("AudioStreamInternal: framesDelta = %08lld, nanosDelta = %08lld, rate = %lld",
376 (long long) framesDelta, (long long) nanosDelta, (long long) rate);
Phil Burk204a1632017-01-03 17:23:43 -0800377 }
378 oldPosition = framePosition;
379 oldTime = nanoTime;
380}
Phil Burk204a1632017-01-03 17:23:43 -0800381
Phil Burk5ed503c2017-02-01 09:38:15 -0800382aaudio_result_t AudioStreamInternal::onTimestampFromServer(AAudioServiceMessage *message) {
Phil Burk204a1632017-01-03 17:23:43 -0800383#if LOG_TIMESTAMPS
Phil Burkec89b2e2017-06-20 15:05:06 -0700384 logTimestamp(*message);
Phil Burk204a1632017-01-03 17:23:43 -0800385#endif
Phil Burk87c9f642017-05-17 07:22:39 -0700386 processTimestamp(message->timestamp.position, message->timestamp.timestamp);
Phil Burk5ed503c2017-02-01 09:38:15 -0800387 return AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800388}
389
Phil Burk5ed503c2017-02-01 09:38:15 -0800390aaudio_result_t AudioStreamInternal::onEventFromServer(AAudioServiceMessage *message) {
391 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800392 switch (message->event.event) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800393 case AAUDIO_SERVICE_EVENT_STARTED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700394 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_STARTED");
Phil Burk87c9f642017-05-17 07:22:39 -0700395 if (getState() == AAUDIO_STREAM_STATE_STARTING) {
396 setState(AAUDIO_STREAM_STATE_STARTED);
397 }
Phil Burk204a1632017-01-03 17:23:43 -0800398 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800399 case AAUDIO_SERVICE_EVENT_PAUSED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700400 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_PAUSED");
Phil Burk87c9f642017-05-17 07:22:39 -0700401 if (getState() == AAUDIO_STREAM_STATE_PAUSING) {
402 setState(AAUDIO_STREAM_STATE_PAUSED);
403 }
Phil Burk204a1632017-01-03 17:23:43 -0800404 break;
Phil Burk71f35bb2017-04-13 16:05:07 -0700405 case AAUDIO_SERVICE_EVENT_STOPPED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700406 ALOGD("AudioStreamInternal::onEventFromServergot() AAUDIO_SERVICE_EVENT_STOPPED");
Phil Burk87c9f642017-05-17 07:22:39 -0700407 if (getState() == AAUDIO_STREAM_STATE_STOPPING) {
408 setState(AAUDIO_STREAM_STATE_STOPPED);
409 }
Phil Burk71f35bb2017-04-13 16:05:07 -0700410 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800411 case AAUDIO_SERVICE_EVENT_FLUSHED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700412 ALOGD("AudioStreamInternal::onEventFromServer() got AAUDIO_SERVICE_EVENT_FLUSHED");
Phil Burk87c9f642017-05-17 07:22:39 -0700413 if (getState() == AAUDIO_STREAM_STATE_FLUSHING) {
414 setState(AAUDIO_STREAM_STATE_FLUSHED);
415 onFlushFromServer();
416 }
Phil Burk204a1632017-01-03 17:23:43 -0800417 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800418 case AAUDIO_SERVICE_EVENT_CLOSED:
Phil Burkec89b2e2017-06-20 15:05:06 -0700419 ALOGD("AudioStreamInternal::onEventFromServer() got AAUDIO_SERVICE_EVENT_CLOSED");
Phil Burk5ed503c2017-02-01 09:38:15 -0800420 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burk204a1632017-01-03 17:23:43 -0800421 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800422 case AAUDIO_SERVICE_EVENT_DISCONNECTED:
423 result = AAUDIO_ERROR_DISCONNECTED;
Phil Burkc0c70e32017-02-09 13:18:38 -0800424 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
Phil Burkec89b2e2017-06-20 15:05:06 -0700425 ALOGW("WARNING - AudioStreamInternal::onEventFromServer()"
426 " AAUDIO_SERVICE_EVENT_DISCONNECTED");
Phil Burk204a1632017-01-03 17:23:43 -0800427 break;
Phil Burkc0c70e32017-02-09 13:18:38 -0800428 case AAUDIO_SERVICE_EVENT_VOLUME:
Eric Laurenta2f296e2017-06-21 18:51:47 -0700429 mStreamVolume = (float)message->event.dataDouble;
430 doSetVolume();
Phil Burkec89b2e2017-06-20 15:05:06 -0700431 ALOGD("AudioStreamInternal::onEventFromServer() AAUDIO_SERVICE_EVENT_VOLUME %lf",
Phil Burke572f462017-04-20 13:03:19 -0700432 message->event.dataDouble);
Phil Burkc0c70e32017-02-09 13:18:38 -0800433 break;
Phil Burk204a1632017-01-03 17:23:43 -0800434 default:
Phil Burkec89b2e2017-06-20 15:05:06 -0700435 ALOGW("WARNING - AudioStreamInternal::onEventFromServer() Unrecognized event = %d",
Phil Burk204a1632017-01-03 17:23:43 -0800436 (int) message->event.event);
437 break;
438 }
439 return result;
440}
441
442// Process all the commands coming from the server.
Phil Burk5ed503c2017-02-01 09:38:15 -0800443aaudio_result_t AudioStreamInternal::processCommands() {
444 aaudio_result_t result = AAUDIO_OK;
Phil Burk204a1632017-01-03 17:23:43 -0800445
Phil Burk5ed503c2017-02-01 09:38:15 -0800446 while (result == AAUDIO_OK) {
Phil Burkcf5f6d22017-05-26 12:35:07 -0700447 //ALOGD("AudioStreamInternal::processCommands() - looping, %d", result);
Phil Burk5ed503c2017-02-01 09:38:15 -0800448 AAudioServiceMessage message;
Phil Burk204a1632017-01-03 17:23:43 -0800449 if (mAudioEndpoint.readUpCommand(&message) != 1) {
450 break; // no command this time, no problem
451 }
452 switch (message.what) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800453 case AAudioServiceMessage::code::TIMESTAMP:
Phil Burk204a1632017-01-03 17:23:43 -0800454 result = onTimestampFromServer(&message);
455 break;
456
Phil Burk5ed503c2017-02-01 09:38:15 -0800457 case AAudioServiceMessage::code::EVENT:
Phil Burk204a1632017-01-03 17:23:43 -0800458 result = onEventFromServer(&message);
459 break;
460
461 default:
Phil Burk71f35bb2017-04-13 16:05:07 -0700462 ALOGE("WARNING - AudioStreamInternal::processCommands() Unrecognized what = %d",
Phil Burk204a1632017-01-03 17:23:43 -0800463 (int) message.what);
Phil Burk17fff382017-05-16 14:06:45 -0700464 result = AAUDIO_ERROR_INTERNAL;
Phil Burk204a1632017-01-03 17:23:43 -0800465 break;
466 }
467 }
468 return result;
469}
470
Phil Burk87c9f642017-05-17 07:22:39 -0700471// Read or write the data, block if needed and timeoutMillis > 0
472aaudio_result_t AudioStreamInternal::processData(void *buffer, int32_t numFrames,
473 int64_t timeoutNanoseconds)
Phil Burk204a1632017-01-03 17:23:43 -0800474{
Phil Burk4485d412017-05-09 15:55:02 -0700475 const char * traceName = (mInService) ? "aaWrtS" : "aaWrtC";
476 ATRACE_BEGIN(traceName);
Phil Burk4485d412017-05-09 15:55:02 -0700477 int32_t fullFrames = mAudioEndpoint.getFullFramesAvailable();
478 if (ATRACE_ENABLED()) {
479 const char * traceName = (mInService) ? "aaFullS" : "aaFullC";
480 ATRACE_INT(traceName, fullFrames);
481 }
482
Phil Burkec89b2e2017-06-20 15:05:06 -0700483 aaudio_result_t result = AAUDIO_OK;
484 int32_t loopCount = 0;
485 uint8_t* audioData = (uint8_t*)buffer;
486 int64_t currentTimeNanos = AudioClock::getNanoseconds();
487 const int64_t entryTimeNanos = currentTimeNanos;
488 const int64_t deadlineNanos = currentTimeNanos + timeoutNanoseconds;
489 int32_t framesLeft = numFrames;
490
Phil Burk87c9f642017-05-17 07:22:39 -0700491 // Loop until all the data has been processed or until a timeout occurs.
Phil Burk204a1632017-01-03 17:23:43 -0800492 while (framesLeft > 0) {
Phil Burkec89b2e2017-06-20 15:05:06 -0700493 // The call to processDataNow() will not block. It will just process as much as it can.
Phil Burk3316d5e2017-02-15 11:23:01 -0800494 int64_t wakeTimeNanos = 0;
Phil Burk87c9f642017-05-17 07:22:39 -0700495 aaudio_result_t framesProcessed = processDataNow(audioData, framesLeft,
496 currentTimeNanos, &wakeTimeNanos);
497 if (framesProcessed < 0) {
Phil Burk87c9f642017-05-17 07:22:39 -0700498 result = framesProcessed;
Phil Burk204a1632017-01-03 17:23:43 -0800499 break;
500 }
Phil Burk87c9f642017-05-17 07:22:39 -0700501 framesLeft -= (int32_t) framesProcessed;
502 audioData += framesProcessed * getBytesPerFrame();
Phil Burk204a1632017-01-03 17:23:43 -0800503
504 // Should we block?
505 if (timeoutNanoseconds == 0) {
506 break; // don't block
507 } else if (framesLeft > 0) {
Phil Burk204a1632017-01-03 17:23:43 -0800508 // clip the wake time to something reasonable
509 if (wakeTimeNanos < currentTimeNanos) {
510 wakeTimeNanos = currentTimeNanos;
511 }
512 if (wakeTimeNanos > deadlineNanos) {
513 // If we time out, just return the framesWritten so far.
Phil Burkcf5f6d22017-05-26 12:35:07 -0700514 // TODO remove after we fix the deadline bug
Phil Burkec89b2e2017-06-20 15:05:06 -0700515 ALOGW("AudioStreamInternal::processData(): entered at %lld nanos, currently %lld",
516 (long long) entryTimeNanos, (long long) currentTimeNanos);
517 ALOGW("AudioStreamInternal::processData(): timed out after %lld nanos",
Phil Burkc0c70e32017-02-09 13:18:38 -0800518 (long long) timeoutNanoseconds);
Phil Burkec89b2e2017-06-20 15:05:06 -0700519 ALOGW("AudioStreamInternal::processData(): wakeTime = %lld, deadline = %lld nanos",
Phil Burk87c9f642017-05-17 07:22:39 -0700520 (long long) wakeTimeNanos, (long long) deadlineNanos);
Phil Burkec89b2e2017-06-20 15:05:06 -0700521 ALOGW("AudioStreamInternal::processData(): past deadline by %d micros",
Phil Burk87c9f642017-05-17 07:22:39 -0700522 (int)((wakeTimeNanos - deadlineNanos) / AAUDIO_NANOS_PER_MICROSECOND));
Phil Burkec89b2e2017-06-20 15:05:06 -0700523 mClockModel.dump();
524 mAudioEndpoint.dump();
Phil Burk204a1632017-01-03 17:23:43 -0800525 break;
526 }
527
Phil Burk71f35bb2017-04-13 16:05:07 -0700528 int64_t sleepForNanos = wakeTimeNanos - currentTimeNanos;
529 AudioClock::sleepForNanos(sleepForNanos);
Phil Burk204a1632017-01-03 17:23:43 -0800530 currentTimeNanos = AudioClock::getNanoseconds();
531 }
532 }
533
Phil Burk87c9f642017-05-17 07:22:39 -0700534 // return error or framesProcessed
Phil Burkc0c70e32017-02-09 13:18:38 -0800535 (void) loopCount;
Phil Burk4485d412017-05-09 15:55:02 -0700536 ATRACE_END();
Phil Burk204a1632017-01-03 17:23:43 -0800537 return (result < 0) ? result : numFrames - framesLeft;
538}
539
Phil Burk3316d5e2017-02-15 11:23:01 -0800540void AudioStreamInternal::processTimestamp(uint64_t position, int64_t time) {
Phil Burk87c9f642017-05-17 07:22:39 -0700541 mClockModel.processTimestamp(position, time);
Phil Burk204a1632017-01-03 17:23:43 -0800542}
543
Phil Burk3316d5e2017-02-15 11:23:01 -0800544aaudio_result_t AudioStreamInternal::setBufferSize(int32_t requestedFrames) {
545 int32_t actualFrames = 0;
Phil Burk71f35bb2017-04-13 16:05:07 -0700546 // Round to the next highest burst size.
547 if (getFramesPerBurst() > 0) {
548 int32_t numBursts = (requestedFrames + getFramesPerBurst() - 1) / getFramesPerBurst();
549 requestedFrames = numBursts * getFramesPerBurst();
550 }
551
Phil Burk3316d5e2017-02-15 11:23:01 -0800552 aaudio_result_t result = mAudioEndpoint.setBufferSizeInFrames(requestedFrames, &actualFrames);
Phil Burkcf5f6d22017-05-26 12:35:07 -0700553 ALOGD("AudioStreamInternal::setBufferSize() req = %d => %d", requestedFrames, actualFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800554 if (result < 0) {
555 return result;
556 } else {
557 return (aaudio_result_t) actualFrames;
558 }
Phil Burk204a1632017-01-03 17:23:43 -0800559}
560
Phil Burk87c9f642017-05-17 07:22:39 -0700561int32_t AudioStreamInternal::getBufferSize() const {
Phil Burk204a1632017-01-03 17:23:43 -0800562 return mAudioEndpoint.getBufferSizeInFrames();
563}
564
Phil Burk87c9f642017-05-17 07:22:39 -0700565int32_t AudioStreamInternal::getBufferCapacity() const {
Phil Burk204a1632017-01-03 17:23:43 -0800566 return mAudioEndpoint.getBufferCapacityInFrames();
567}
568
Phil Burk87c9f642017-05-17 07:22:39 -0700569int32_t AudioStreamInternal::getFramesPerBurst() const {
570 return mEndpointDescriptor.dataQueueDescriptor.framesPerBurst;
Phil Burk204a1632017-01-03 17:23:43 -0800571}
572
Phil Burk87c9f642017-05-17 07:22:39 -0700573aaudio_result_t AudioStreamInternal::joinThread(void** returnArg) {
574 return AudioStream::joinThread(returnArg, calculateReasonableTimeout(getFramesPerBurst()));
Phil Burk4c5129b2017-04-28 15:17:32 -0700575}
Eric Laurenta2f296e2017-06-21 18:51:47 -0700576
577void AudioStreamInternal::doSetVolume() {
578 // No pan and only left volume is taken into account from IPLayer interface
579 mVolumeRamp.setTarget(mStreamVolume * mVolumeMultiplierL /* * mPanMultiplierL */);
580}
581
582
583//------------------------------------------------------------------------------
584// Implementation of PlayerBase
585status_t AudioStreamInternal::playerStart() {
586 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.startStream(mServiceStreamHandle));
587}
588
589status_t AudioStreamInternal::playerPause() {
590 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.pauseStream(mServiceStreamHandle));
591}
592
593status_t AudioStreamInternal::playerStop() {
594 return AAudioConvert_aaudioToAndroidStatus(mServiceInterface.stopStream(mServiceStreamHandle));
595}
596
597status_t AudioStreamInternal::playerSetVolume() {
598 doSetVolume();
599 return NO_ERROR;
600}
601
602void AudioStreamInternal::destroy() {
603 baseDestroy();
604}