blob: ca6b34c36f476a1ae97177f90f2d7cbaa3e44a05 [file] [log] [blame]
Glenn Kasten99e53b82012-01-19 08:59:58 -08001/*
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080018//#define LOG_NDEBUG 0
19#define LOG_TAG "AudioTrack"
20
Mark Salyzyn34fb2962014-06-18 16:30:56 -070021#include <inttypes.h>
Glenn Kastenc56f3422014-03-21 17:53:17 -070022#include <math.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080023#include <sys/resource.h>
Mark Salyzyn34fb2962014-06-18 16:30:56 -070024
Glenn Kasten9f80dd22012-12-18 15:57:32 -080025#include <audio_utils/primitives.h>
26#include <binder/IPCThreadState.h>
27#include <media/AudioTrack.h>
28#include <utils/Log.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080029#include <private/media/AudioTrackShared.h>
Glenn Kasten1ab85ec2013-05-31 09:18:43 -070030#include <media/IAudioFlinger.h>
Eric Laurente83b55d2014-11-14 10:06:21 -080031#include <media/AudioPolicyHelper.h>
Andy Hungcd044842014-08-07 11:04:34 -070032#include <media/AudioResamplerPublic.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080033
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +010034#define WAIT_PERIOD_MS 10
35#define WAIT_STREAM_END_TIMEOUT_SEC 120
Andy Hung53c3b5f2014-12-15 16:42:05 -080036static const int kMaxLoopCountNotifications = 32;
Glenn Kasten511754b2012-01-11 09:52:19 -080037
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080038namespace android {
Chia-chi Yeh33005a92010-06-16 06:33:13 +080039// ---------------------------------------------------------------------------
40
Andy Hunga7f03352015-05-31 21:54:49 -070041// TODO: Move to a separate .h
42
Andy Hung4ede21d2014-12-12 15:37:34 -080043template <typename T>
Andy Hunga7f03352015-05-31 21:54:49 -070044static inline const T &min(const T &x, const T &y) {
Andy Hung4ede21d2014-12-12 15:37:34 -080045 return x < y ? x : y;
46}
47
Andy Hunga7f03352015-05-31 21:54:49 -070048template <typename T>
49static inline const T &max(const T &x, const T &y) {
50 return x > y ? x : y;
51}
52
Andy Hung5d313802016-10-10 15:09:39 -070053static const int32_t NANOS_PER_SECOND = 1000000000;
54
Andy Hunga7f03352015-05-31 21:54:49 -070055static inline nsecs_t framesToNanoseconds(ssize_t frames, uint32_t sampleRate, float speed)
56{
57 return ((double)frames * 1000000000) / ((double)sampleRate * speed);
58}
59
Andy Hung7f1bc8a2014-09-12 14:43:11 -070060static int64_t convertTimespecToUs(const struct timespec &tv)
61{
62 return tv.tv_sec * 1000000ll + tv.tv_nsec / 1000;
63}
64
Andy Hung5d313802016-10-10 15:09:39 -070065static inline nsecs_t convertTimespecToNs(const struct timespec &tv)
66{
67 return tv.tv_sec * (long long)NANOS_PER_SECOND + tv.tv_nsec;
68}
69
Andy Hung7f1bc8a2014-09-12 14:43:11 -070070// current monotonic time in microseconds.
71static int64_t getNowUs()
72{
73 struct timespec tv;
74 (void) clock_gettime(CLOCK_MONOTONIC, &tv);
75 return convertTimespecToUs(tv);
76}
77
Andy Hung26145642015-04-15 21:56:53 -070078// FIXME: we don't use the pitch setting in the time stretcher (not working);
79// instead we emulate it using our sample rate converter.
80static const bool kFixPitch = true; // enable pitch fix
81static inline uint32_t adjustSampleRate(uint32_t sampleRate, float pitch)
82{
83 return kFixPitch ? (sampleRate * pitch + 0.5) : sampleRate;
84}
85
86static inline float adjustSpeed(float speed, float pitch)
87{
Ricardo Garcia6c7f0622015-04-30 18:39:16 -070088 return kFixPitch ? speed / max(pitch, AUDIO_TIMESTRETCH_PITCH_MIN_DELTA) : speed;
Andy Hung26145642015-04-15 21:56:53 -070089}
90
91static inline float adjustPitch(float pitch)
92{
93 return kFixPitch ? AUDIO_TIMESTRETCH_PITCH_NORMAL : pitch;
94}
95
Andy Hung8edb8dc2015-03-26 19:13:55 -070096// Must match similar computation in createTrack_l in Threads.cpp.
97// TODO: Move to a common library
98static size_t calculateMinFrameCount(
99 uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate,
Glenn Kastenea38ee72016-04-18 11:08:01 -0700100 uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/)
Andy Hung8edb8dc2015-03-26 19:13:55 -0700101{
102 // Ensure that buffer depth covers at least audio hardware latency
103 uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate);
104 if (minBufCount < 2) {
105 minBufCount = 2;
106 }
Glenn Kastenea38ee72016-04-18 11:08:01 -0700107#if 0
108 // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
109 // but keeping the code here to make it easier to add later.
110 if (minBufCount < notificationsPerBufferReq) {
111 minBufCount = notificationsPerBufferReq;
112 }
113#endif
Andy Hung8edb8dc2015-03-26 19:13:55 -0700114 ALOGV("calculateMinFrameCount afLatency %u afFrameCount %u afSampleRate %u "
Glenn Kastenea38ee72016-04-18 11:08:01 -0700115 "sampleRate %u speed %f minBufCount: %u" /*" notificationsPerBufferReq %u"*/,
116 afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
117 /*, notificationsPerBufferReq*/);
Andy Hung8edb8dc2015-03-26 19:13:55 -0700118 return minBufCount * sourceFramesNeededWithTimestretch(
119 sampleRate, afFrameCount, afSampleRate, speed);
120}
121
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800122// static
123status_t AudioTrack::getMinFrameCount(
Glenn Kastene33054e2012-11-14 12:54:39 -0800124 size_t* frameCount,
Glenn Kastenfff6d712012-01-12 16:38:12 -0800125 audio_stream_type_t streamType,
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800126 uint32_t sampleRate)
127{
Glenn Kastend65d73c2012-06-22 17:21:07 -0700128 if (frameCount == NULL) {
129 return BAD_VALUE;
130 }
Glenn Kasten04cd0182012-06-25 11:49:27 -0700131
Andy Hung0e48d252015-01-26 11:43:15 -0800132 // FIXME handle in server, like createTrack_l(), possible missing info:
Glenn Kastene0fa4672012-04-24 14:35:14 -0700133 // audio_io_handle_t output
134 // audio_format_t format
135 // audio_channel_mask_t channelMask
Andy Hung0e48d252015-01-26 11:43:15 -0800136 // audio_output_flags_t flags (FAST)
Glenn Kasten3b16c762012-11-14 08:44:39 -0800137 uint32_t afSampleRate;
Glenn Kasten66a04672014-01-08 08:53:44 -0800138 status_t status;
139 status = AudioSystem::getOutputSamplingRate(&afSampleRate, streamType);
140 if (status != NO_ERROR) {
Glenn Kasten70c0bfb2014-01-14 15:47:01 -0800141 ALOGE("Unable to query output sample rate for stream type %d; status %d",
142 streamType, status);
Glenn Kasten66a04672014-01-08 08:53:44 -0800143 return status;
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800144 }
Glenn Kastene33054e2012-11-14 12:54:39 -0800145 size_t afFrameCount;
Glenn Kasten66a04672014-01-08 08:53:44 -0800146 status = AudioSystem::getOutputFrameCount(&afFrameCount, streamType);
147 if (status != NO_ERROR) {
Glenn Kasten70c0bfb2014-01-14 15:47:01 -0800148 ALOGE("Unable to query output frame count for stream type %d; status %d",
149 streamType, status);
Glenn Kasten66a04672014-01-08 08:53:44 -0800150 return status;
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800151 }
152 uint32_t afLatency;
Glenn Kasten66a04672014-01-08 08:53:44 -0800153 status = AudioSystem::getOutputLatency(&afLatency, streamType);
154 if (status != NO_ERROR) {
Glenn Kasten70c0bfb2014-01-14 15:47:01 -0800155 ALOGE("Unable to query output latency for stream type %d; status %d",
156 streamType, status);
Glenn Kasten66a04672014-01-08 08:53:44 -0800157 return status;
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800158 }
159
Andy Hung8edb8dc2015-03-26 19:13:55 -0700160 // When called from createTrack, speed is 1.0f (normal speed).
161 // This is rechecked again on setting playback rate (TODO: on setting sample rate, too).
Glenn Kastenea38ee72016-04-18 11:08:01 -0700162 *frameCount = calculateMinFrameCount(afLatency, afFrameCount, afSampleRate, sampleRate, 1.0f
163 /*, 0 notificationsPerBufferReq*/);
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800164
Andy Hung0e48d252015-01-26 11:43:15 -0800165 // The formula above should always produce a non-zero value under normal circumstances:
166 // AudioTrack.SAMPLE_RATE_HZ_MIN <= sampleRate <= AudioTrack.SAMPLE_RATE_HZ_MAX.
167 // Return error in the unlikely event that it does not, as that's part of the API contract.
Glenn Kasten66a04672014-01-08 08:53:44 -0800168 if (*frameCount == 0) {
Andy Hung0e48d252015-01-26 11:43:15 -0800169 ALOGE("AudioTrack::getMinFrameCount failed for streamType %d, sampleRate %u",
Glenn Kasten66a04672014-01-08 08:53:44 -0800170 streamType, sampleRate);
171 return BAD_VALUE;
172 }
Andy Hung8edb8dc2015-03-26 19:13:55 -0700173 ALOGV("getMinFrameCount=%zu: afFrameCount=%zu, afSampleRate=%u, afLatency=%u",
174 *frameCount, afFrameCount, afSampleRate, afLatency);
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800175 return NO_ERROR;
176}
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800177
178// ---------------------------------------------------------------------------
179
180AudioTrack::AudioTrack()
Glenn Kasten87913512011-06-22 16:15:25 -0700181 : mStatus(NO_INIT),
Haynes Mathew George9b3359f2016-03-23 19:09:10 -0700182 mState(STATE_STOPPED),
John Grossman4ff14ba2012-02-08 16:37:41 -0800183 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800184 mPreviousSchedulingGroup(SP_DEFAULT),
Paul McLeanaa981192015-03-21 09:55:15 -0700185 mPausedPosition(0),
Eric Laurent20b9ef02016-12-05 11:03:16 -0800186 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
187 mPortId(AUDIO_PORT_HANDLE_NONE)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800188{
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700189 mAttributes.content_type = AUDIO_CONTENT_TYPE_UNKNOWN;
190 mAttributes.usage = AUDIO_USAGE_UNKNOWN;
191 mAttributes.flags = 0x0;
192 strcpy(mAttributes.tags, "");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800193}
194
195AudioTrack::AudioTrack(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800196 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800197 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800198 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700199 audio_channel_mask_t channelMask,
Glenn Kastenbce50bf2014-02-27 15:29:51 -0800200 size_t frameCount,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700201 audio_output_flags_t flags,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800202 callback_t cbf,
203 void* user,
Glenn Kastenea38ee72016-04-18 11:08:01 -0700204 int32_t notificationFrames,
Glenn Kastend848eb42016-03-08 13:42:11 -0800205 audio_session_t sessionId,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000206 transfer_type transferType,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800207 const audio_offload_info_t *offloadInfo,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800208 uid_t uid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700209 pid_t pid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700210 const audio_attributes_t* pAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -0700211 bool doNotReconnect,
212 float maxRequiredSpeed)
Glenn Kasten87913512011-06-22 16:15:25 -0700213 : mStatus(NO_INIT),
Haynes Mathew George9b3359f2016-03-23 19:09:10 -0700214 mState(STATE_STOPPED),
John Grossman4ff14ba2012-02-08 16:37:41 -0800215 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800216 mPreviousSchedulingGroup(SP_DEFAULT),
Paul McLeanaa981192015-03-21 09:55:15 -0700217 mPausedPosition(0),
Eric Laurent20b9ef02016-12-05 11:03:16 -0800218 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
219 mPortId(AUDIO_PORT_HANDLE_NONE)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800220{
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700221 mStatus = set(streamType, sampleRate, format, channelMask,
Eric Laurenta514bdb2010-06-21 09:27:30 -0700222 frameCount, flags, cbf, user, notificationFrames,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800223 0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId, transferType,
Andy Hungff874dc2016-04-11 16:49:09 -0700224 offloadInfo, uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800225}
226
Andreas Huberc8139852012-01-18 10:51:55 -0800227AudioTrack::AudioTrack(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800228 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800229 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800230 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700231 audio_channel_mask_t channelMask,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800232 const sp<IMemory>& sharedBuffer,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700233 audio_output_flags_t flags,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800234 callback_t cbf,
235 void* user,
Glenn Kastenea38ee72016-04-18 11:08:01 -0700236 int32_t notificationFrames,
Glenn Kastend848eb42016-03-08 13:42:11 -0800237 audio_session_t sessionId,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000238 transfer_type transferType,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800239 const audio_offload_info_t *offloadInfo,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800240 uid_t uid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700241 pid_t pid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700242 const audio_attributes_t* pAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -0700243 bool doNotReconnect,
244 float maxRequiredSpeed)
Glenn Kasten87913512011-06-22 16:15:25 -0700245 : mStatus(NO_INIT),
Haynes Mathew George9b3359f2016-03-23 19:09:10 -0700246 mState(STATE_STOPPED),
John Grossman4ff14ba2012-02-08 16:37:41 -0800247 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800248 mPreviousSchedulingGroup(SP_DEFAULT),
Paul McLeanaa981192015-03-21 09:55:15 -0700249 mPausedPosition(0),
Eric Laurent20b9ef02016-12-05 11:03:16 -0800250 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
251 mPortId(AUDIO_PORT_HANDLE_NONE)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800252{
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700253 mStatus = set(streamType, sampleRate, format, channelMask,
Glenn Kasten17a736c2012-02-14 08:52:15 -0800254 0 /*frameCount*/, flags, cbf, user, notificationFrames,
Marco Nelissend457c972014-02-11 08:47:07 -0800255 sharedBuffer, false /*threadCanCallJava*/, sessionId, transferType, offloadInfo,
Andy Hungff874dc2016-04-11 16:49:09 -0700256 uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800257}
258
259AudioTrack::~AudioTrack()
260{
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800261 if (mStatus == NO_ERROR) {
262 // Make sure that callback function exits in the case where
263 // it is looping on buffer full condition in obtainBuffer().
264 // Otherwise the callback thread will never exit.
265 stop();
266 if (mAudioTrackThread != 0) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100267 mProxy->interrupt();
Glenn Kasten3acbd052012-02-28 10:39:56 -0800268 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800269 mAudioTrackThread->requestExitAndWait();
270 mAudioTrackThread.clear();
271 }
Eric Laurent296fb132015-05-01 11:38:42 -0700272 // No lock here: worst case we remove a NULL callback which will be a nop
273 if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) {
274 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
275 }
Marco Nelissenf8880202014-11-14 07:58:25 -0800276 IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this);
Glenn Kasten53cec222013-08-29 09:01:02 -0700277 mAudioTrack.clear();
Eric Laurent3bcffa12014-06-12 18:38:45 -0700278 mCblkMemory.clear();
279 mSharedBuffer.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800280 IPCThreadState::self()->flushCommands();
Glenn Kasten4c36d6f2015-03-20 09:05:01 -0700281 ALOGV("~AudioTrack, releasing session id %d from %d on behalf of %d",
282 mSessionId, IPCThreadState::self()->getCallingPid(), mClientPid);
Marco Nelissend457c972014-02-11 08:47:07 -0800283 AudioSystem::releaseAudioSessionId(mSessionId, mClientPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800284 }
285}
286
287status_t AudioTrack::set(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800288 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800289 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800290 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700291 audio_channel_mask_t channelMask,
Glenn Kastenbce50bf2014-02-27 15:29:51 -0800292 size_t frameCount,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700293 audio_output_flags_t flags,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800294 callback_t cbf,
295 void* user,
Glenn Kastenea38ee72016-04-18 11:08:01 -0700296 int32_t notificationFrames,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800297 const sp<IMemory>& sharedBuffer,
Eric Laurentbe916aa2010-06-01 23:49:17 -0700298 bool threadCanCallJava,
Glenn Kastend848eb42016-03-08 13:42:11 -0800299 audio_session_t sessionId,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000300 transfer_type transferType,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800301 const audio_offload_info_t *offloadInfo,
Andy Hung1f12a8a2016-11-07 16:10:30 -0800302 uid_t uid,
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700303 pid_t pid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700304 const audio_attributes_t* pAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -0700305 bool doNotReconnect,
306 float maxRequiredSpeed)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800307{
Glenn Kastenbce50bf2014-02-27 15:29:51 -0800308 ALOGV("set(): streamType %d, sampleRate %u, format %#x, channelMask %#x, frameCount %zu, "
Glenn Kastenea38ee72016-04-18 11:08:01 -0700309 "flags #%x, notificationFrames %d, sessionId %d, transferType %d, uid %d, pid %d",
Glenn Kastenbce50bf2014-02-27 15:29:51 -0800310 streamType, sampleRate, format, channelMask, frameCount, flags, notificationFrames,
Glenn Kasten4c36d6f2015-03-20 09:05:01 -0700311 sessionId, transferType, uid, pid);
Glenn Kasten86f04662014-02-24 15:13:05 -0800312
Phil Burk33ff89b2015-11-30 11:16:01 -0800313 mThreadCanCallJava = threadCanCallJava;
314
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800315 switch (transferType) {
316 case TRANSFER_DEFAULT:
317 if (sharedBuffer != 0) {
318 transferType = TRANSFER_SHARED;
319 } else if (cbf == NULL || threadCanCallJava) {
320 transferType = TRANSFER_SYNC;
321 } else {
322 transferType = TRANSFER_CALLBACK;
323 }
324 break;
325 case TRANSFER_CALLBACK:
326 if (cbf == NULL || sharedBuffer != 0) {
327 ALOGE("Transfer type TRANSFER_CALLBACK but cbf == NULL || sharedBuffer != 0");
328 return BAD_VALUE;
329 }
330 break;
331 case TRANSFER_OBTAIN:
332 case TRANSFER_SYNC:
333 if (sharedBuffer != 0) {
334 ALOGE("Transfer type TRANSFER_OBTAIN but sharedBuffer != 0");
335 return BAD_VALUE;
336 }
337 break;
338 case TRANSFER_SHARED:
339 if (sharedBuffer == 0) {
340 ALOGE("Transfer type TRANSFER_SHARED but sharedBuffer == 0");
341 return BAD_VALUE;
342 }
343 break;
344 default:
345 ALOGE("Invalid transfer type %d", transferType);
346 return BAD_VALUE;
347 }
Glenn Kastendd5f4c82014-01-13 10:26:32 -0800348 mSharedBuffer = sharedBuffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800349 mTransfer = transferType;
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700350 mDoNotReconnect = doNotReconnect;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800351
Eric Laurent97c9f4f2015-08-11 18:04:14 -0700352 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %zu", sharedBuffer->pointer(),
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700353 sharedBuffer->size());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800354
Mark Salyzyn34fb2962014-06-18 16:30:56 -0700355 ALOGV("set() streamType %d frameCount %zu flags %04x", streamType, frameCount, flags);
Eric Laurent1a9ed112012-03-20 18:36:01 -0700356
Glenn Kasten53cec222013-08-29 09:01:02 -0700357 // invariant that mAudioTrack != 0 is true only after set() returns successfully
Eric Laurent1dd70b92009-04-21 07:56:33 -0700358 if (mAudioTrack != 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000359 ALOGE("Track already in use");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800360 return INVALID_OPERATION;
361 }
362
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800363 // handle default values first.
Eric Laurente83b55d2014-11-14 10:06:21 -0800364 if (streamType == AUDIO_STREAM_DEFAULT) {
Dima Zavinfce7a472011-04-19 22:30:36 -0700365 streamType = AUDIO_STREAM_MUSIC;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800366 }
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700367 if (pAttributes == NULL) {
Eric Laurent223fd5c2014-11-11 13:43:36 -0800368 if (uint32_t(streamType) >= AUDIO_STREAM_PUBLIC_CNT) {
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700369 ALOGE("Invalid stream type %d", streamType);
370 return BAD_VALUE;
371 }
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700372 mStreamType = streamType;
Eric Laurente83b55d2014-11-14 10:06:21 -0800373
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700374 } else {
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700375 // stream type shouldn't be looked at, this track has audio attributes
376 memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700377 ALOGV("Building AudioTrack with attributes: usage=%d content=%d flags=0x%x tags=[%s]",
378 mAttributes.usage, mAttributes.content_type, mAttributes.flags, mAttributes.tags);
Eric Laurente83b55d2014-11-14 10:06:21 -0800379 mStreamType = AUDIO_STREAM_DEFAULT;
Eric Laurentc6bd5db2015-03-09 16:29:33 -0700380 if ((mAttributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
381 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
382 }
Phil Burk33ff89b2015-11-30 11:16:01 -0800383 if ((mAttributes.flags & AUDIO_FLAG_LOW_LATENCY) != 0) {
384 flags = (audio_output_flags_t) (flags | AUDIO_OUTPUT_FLAG_FAST);
385 }
Andy Hungfff204c2017-01-12 19:09:55 -0800386 // check deep buffer after flags have been modified above
387 if (flags == AUDIO_OUTPUT_FLAG_NONE && (mAttributes.flags & AUDIO_FLAG_DEEP_BUFFER) != 0) {
388 flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
389 }
Glenn Kastendd5f4c82014-01-13 10:26:32 -0800390 }
Glenn Kastenea7939a2012-03-14 12:56:26 -0700391
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800392 // these below should probably come from the audioFlinger too...
Glenn Kastene1c39622012-01-04 09:36:37 -0800393 if (format == AUDIO_FORMAT_DEFAULT) {
Dima Zavinfce7a472011-04-19 22:30:36 -0700394 format = AUDIO_FORMAT_PCM_16_BIT;
Phil Burkfdb3c072016-02-09 10:47:02 -0800395 } else if (format == AUDIO_FORMAT_IEC61937) { // HDMI pass-through?
396 mAttributes.flags |= AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800397 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800398
399 // validate parameters
Dima Zavinfce7a472011-04-19 22:30:36 -0700400 if (!audio_is_valid_format(format)) {
Glenn Kastencac3daa2014-02-07 09:47:14 -0800401 ALOGE("Invalid format %#x", format);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800402 return BAD_VALUE;
403 }
Glenn Kastendd5f4c82014-01-13 10:26:32 -0800404 mFormat = format;
Eric Laurentc2f1f072009-07-17 12:17:14 -0700405
Glenn Kasten8ba90322013-10-30 11:29:27 -0700406 if (!audio_is_output_channel(channelMask)) {
407 ALOGE("Invalid channel mask %#x", channelMask);
408 return BAD_VALUE;
409 }
Glenn Kastene3247bf2014-02-24 15:19:07 -0800410 mChannelMask = channelMask;
Andy Hunge5412692014-05-16 11:25:07 -0700411 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
Glenn Kastene3247bf2014-02-24 15:19:07 -0800412 mChannelCount = channelCount;
Glenn Kasten8ba90322013-10-30 11:29:27 -0700413
Eric Laurentc2f1f072009-07-17 12:17:14 -0700414 // force direct flag if format is not linear PCM
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100415 // or offload was requested
416 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
417 || !audio_is_linear_pcm(format)) {
418 ALOGV( (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
419 ? "Offload request, forcing to Direct Output"
420 : "Not linear PCM, forcing to Direct Output");
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700421 flags = (audio_output_flags_t)
Glenn Kasten3acbd052012-02-28 10:39:56 -0800422 // FIXME why can't we allow direct AND fast?
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700423 ((flags | AUDIO_OUTPUT_FLAG_DIRECT) & ~AUDIO_OUTPUT_FLAG_FAST);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700424 }
425
Eric Laurentd1f69b02014-12-15 14:33:13 -0800426 // force direct flag if HW A/V sync requested
427 if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
428 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
429 }
430
Glenn Kastenb7730382014-04-30 15:50:31 -0700431 if (flags & AUDIO_OUTPUT_FLAG_DIRECT) {
Phil Burkfdb3c072016-02-09 10:47:02 -0800432 if (audio_has_proportional_frames(format)) {
Glenn Kastenb7730382014-04-30 15:50:31 -0700433 mFrameSize = channelCount * audio_bytes_per_sample(format);
434 } else {
435 mFrameSize = sizeof(uint8_t);
436 }
Glenn Kastene3aa6592012-12-04 12:22:46 -0800437 } else {
Phil Burkfdb3c072016-02-09 10:47:02 -0800438 ALOG_ASSERT(audio_has_proportional_frames(format));
Glenn Kastenb7730382014-04-30 15:50:31 -0700439 mFrameSize = channelCount * audio_bytes_per_sample(format);
Glenn Kastenb7730382014-04-30 15:50:31 -0700440 // createTrack will return an error if PCM format is not supported by server,
441 // so no need to check for specific PCM formats here
Glenn Kastene3aa6592012-12-04 12:22:46 -0800442 }
443
Eric Laurent0d6db582014-11-12 18:39:44 -0800444 // sampling rate must be specified for direct outputs
445 if (sampleRate == 0 && (flags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
446 return BAD_VALUE;
447 }
448 mSampleRate = sampleRate;
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700449 mOriginalSampleRate = sampleRate;
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700450 mPlaybackRate = AUDIO_PLAYBACK_RATE_DEFAULT;
Andy Hungff874dc2016-04-11 16:49:09 -0700451 // 1.0 <= mMaxRequiredSpeed <= AUDIO_TIMESTRETCH_SPEED_MAX
452 mMaxRequiredSpeed = min(max(maxRequiredSpeed, 1.0f), AUDIO_TIMESTRETCH_SPEED_MAX);
Eric Laurent0d6db582014-11-12 18:39:44 -0800453
Glenn Kastenb5ccb2d2014-01-13 14:42:43 -0800454 // Make copy of input parameter offloadInfo so that in the future:
455 // (a) createTrack_l doesn't need it as an input parameter
456 // (b) we can support re-creation of offloaded tracks
457 if (offloadInfo != NULL) {
458 mOffloadInfoCopy = *offloadInfo;
459 mOffloadInfo = &mOffloadInfoCopy;
460 } else {
461 mOffloadInfo = NULL;
Eric Laurent20b9ef02016-12-05 11:03:16 -0800462 memset(&mOffloadInfoCopy, 0, sizeof(audio_offload_info_t));
Glenn Kastenb5ccb2d2014-01-13 14:42:43 -0800463 }
464
Glenn Kasten66e46352014-01-16 17:44:23 -0800465 mVolume[AUDIO_INTERLEAVE_LEFT] = 1.0f;
466 mVolume[AUDIO_INTERLEAVE_RIGHT] = 1.0f;
Glenn Kasten05632a52012-01-03 14:22:33 -0800467 mSendLevel = 0.0f;
Glenn Kasten396fabd2014-01-08 08:54:23 -0800468 // mFrameCount is initialized in createTrack_l
Glenn Kastenb6037442012-11-14 13:42:25 -0800469 mReqFrameCount = frameCount;
Glenn Kastenea38ee72016-04-18 11:08:01 -0700470 if (notificationFrames >= 0) {
471 mNotificationFramesReq = notificationFrames;
472 mNotificationsPerBufferReq = 0;
473 } else {
474 if (!(flags & AUDIO_OUTPUT_FLAG_FAST)) {
475 ALOGE("notificationFrames=%d not permitted for non-fast track",
476 notificationFrames);
477 return BAD_VALUE;
478 }
479 if (frameCount > 0) {
480 ALOGE("notificationFrames=%d not permitted with non-zero frameCount=%zu",
481 notificationFrames, frameCount);
482 return BAD_VALUE;
483 }
484 mNotificationFramesReq = 0;
485 const uint32_t minNotificationsPerBuffer = 1;
486 const uint32_t maxNotificationsPerBuffer = 8;
487 mNotificationsPerBufferReq = min(maxNotificationsPerBuffer,
488 max((uint32_t) -notificationFrames, minNotificationsPerBuffer));
489 ALOGW_IF(mNotificationsPerBufferReq != (uint32_t) -notificationFrames,
490 "notificationFrames=%d clamped to the range -%u to -%u",
491 notificationFrames, minNotificationsPerBuffer, maxNotificationsPerBuffer);
492 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800493 mNotificationFramesAct = 0;
Eric Laurentcaf7f482014-11-25 17:50:47 -0800494 if (sessionId == AUDIO_SESSION_ALLOCATE) {
Glenn Kastend848eb42016-03-08 13:42:11 -0800495 mSessionId = (audio_session_t) AudioSystem::newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
Eric Laurentcaf7f482014-11-25 17:50:47 -0800496 } else {
497 mSessionId = sessionId;
498 }
Marco Nelissend457c972014-02-11 08:47:07 -0800499 int callingpid = IPCThreadState::self()->getCallingPid();
500 int mypid = getpid();
Andy Hung1f12a8a2016-11-07 16:10:30 -0800501 if (uid == AUDIO_UID_INVALID || (callingpid != mypid)) {
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800502 mClientUid = IPCThreadState::self()->getCallingUid();
503 } else {
504 mClientUid = uid;
505 }
Marco Nelissend457c972014-02-11 08:47:07 -0800506 if (pid == -1 || (callingpid != mypid)) {
507 mClientPid = callingpid;
508 } else {
509 mClientPid = pid;
510 }
Eric Laurent2beeb502010-07-16 07:43:46 -0700511 mAuxEffectId = 0;
Haynes Mathew Georgeae34ed22016-01-28 11:58:39 -0800512 mOrigFlags = mFlags = flags;
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700513 mCbf = cbf;
Eric Laurentbe916aa2010-06-01 23:49:17 -0700514
Glenn Kastena997e7a2012-08-07 09:44:19 -0700515 if (cbf != NULL) {
Eric Laurent896adcd2012-09-13 11:18:23 -0700516 mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
Glenn Kastena997e7a2012-08-07 09:44:19 -0700517 mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/);
Glenn Kastenbfd31842015-03-20 09:01:44 -0700518 // thread begins in paused state, and will not reference us until start()
Glenn Kastena997e7a2012-08-07 09:44:19 -0700519 }
520
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800521 // create the IAudioTrack
Eric Laurent0d6db582014-11-12 18:39:44 -0800522 status_t status = createTrack_l();
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800523
Glenn Kastena997e7a2012-08-07 09:44:19 -0700524 if (status != NO_ERROR) {
525 if (mAudioTrackThread != 0) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100526 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h
527 mAudioTrackThread->requestExitAndWait();
Glenn Kastena997e7a2012-08-07 09:44:19 -0700528 mAudioTrackThread.clear();
529 }
530 return status;
Glenn Kasten5d464eb2012-06-22 17:19:53 -0700531 }
532
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800533 mStatus = NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800534 mUserData = user;
Andy Hung4ede21d2014-12-12 15:37:34 -0800535 mLoopCount = 0;
536 mLoopStart = 0;
537 mLoopEnd = 0;
Andy Hung53c3b5f2014-12-15 16:42:05 -0800538 mLoopCountNotified = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800539 mMarkerPosition = 0;
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700540 mMarkerReached = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800541 mNewPosition = 0;
542 mUpdatePeriod = 0;
Glenn Kasten200092b2014-08-15 15:13:30 -0700543 mPosition = 0;
544 mReleased = 0;
Andy Hung7f1bc8a2014-09-12 14:43:11 -0700545 mStartUs = 0;
Marco Nelissend457c972014-02-11 08:47:07 -0800546 AudioSystem::acquireAudioSessionId(mSessionId, mClientPid);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800547 mSequence = 1;
548 mObservedSequence = mSequence;
549 mInUnderrun = false;
Phil Burk1b420972015-04-22 10:52:21 -0700550 mPreviousTimestampValid = false;
Andy Hungc8e09c62015-06-03 23:43:36 -0700551 mTimestampStartupGlitchReported = false;
552 mRetrogradeMotionReported = false;
Andy Hungb01faa32016-04-27 12:51:32 -0700553 mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;
Andy Hung65ffdfc2016-10-10 15:52:11 -0700554 mStartTs.mPosition = 0;
Phil Burk2812d9e2016-01-04 10:34:30 -0800555 mUnderrunCountOffset = 0;
Andy Hungea2b9c02016-02-12 17:06:53 -0800556 mFramesWritten = 0;
557 mFramesWrittenServerOffset = 0;
Andy Hungf20a4e92016-08-15 19:10:34 -0700558 mFramesWrittenAtRestore = -1; // -1 is a unique initializer.
Andy Hung4ef88d72017-02-21 19:47:53 -0800559 mVolumeHandler = new VolumeHandler();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800560 return NO_ERROR;
561}
562
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800563// -------------------------------------------------------------------------
564
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100565status_t AudioTrack::start()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800566{
Eric Laurentf5aafb22010-11-18 08:40:16 -0800567 AutoMutex lock(mLock);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100568
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800569 if (mState == STATE_ACTIVE) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100570 return INVALID_OPERATION;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800571 }
572
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800573 mInUnderrun = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800574
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800575 State previousState = mState;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100576 if (previousState == STATE_PAUSED_STOPPING) {
577 mState = STATE_STOPPING;
578 } else {
579 mState = STATE_ACTIVE;
580 }
Glenn Kasten200092b2014-08-15 15:13:30 -0700581 (void) updateAndGetPosition_l();
Andy Hung65ffdfc2016-10-10 15:52:11 -0700582
583 // save start timestamp
584 if (isOffloadedOrDirect_l()) {
585 if (getTimestamp_l(mStartTs) != OK) {
586 mStartTs.mPosition = 0;
587 }
588 } else {
589 if (getTimestamp_l(&mStartEts) != OK) {
590 mStartEts.clear();
591 }
592 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800593 if (previousState == STATE_STOPPED || previousState == STATE_FLUSHED) {
594 // reset current position as seen by client to 0
Glenn Kasten200092b2014-08-15 15:13:30 -0700595 mPosition = 0;
Phil Burk1b420972015-04-22 10:52:21 -0700596 mPreviousTimestampValid = false;
Andy Hungc8e09c62015-06-03 23:43:36 -0700597 mTimestampStartupGlitchReported = false;
598 mRetrogradeMotionReported = false;
Andy Hungb01faa32016-04-27 12:51:32 -0700599 mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;
Phil Burk1b420972015-04-22 10:52:21 -0700600
Andy Hung65ffdfc2016-10-10 15:52:11 -0700601 if (!isOffloadedOrDirect_l()
602 && mStartEts.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] > 0) {
Andy Hunge1e98462016-04-12 10:18:51 -0700603 // Server side has consumed something, but is it finished consuming?
604 // It is possible since flush and stop are asynchronous that the server
605 // is still active at this point.
606 ALOGV("start: server read:%lld cumulative flushed:%lld client written:%lld",
607 (long long)(mFramesWrittenServerOffset
Andy Hung65ffdfc2016-10-10 15:52:11 -0700608 + mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER]),
609 (long long)mStartEts.mFlushed,
Andy Hunge1e98462016-04-12 10:18:51 -0700610 (long long)mFramesWritten);
Andy Hung65ffdfc2016-10-10 15:52:11 -0700611 mFramesWrittenServerOffset = -mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER];
Andy Hung61be8412015-10-06 10:51:09 -0700612 }
Andy Hunge1e98462016-04-12 10:18:51 -0700613 mFramesWritten = 0;
614 mProxy->clearTimestamp(); // need new server push for valid timestamp
615 mMarkerReached = false;
Andy Hung61be8412015-10-06 10:51:09 -0700616
Andy Hung7f1bc8a2014-09-12 14:43:11 -0700617 // For offloaded tracks, we don't know if the hardware counters are really zero here,
618 // since the flush is asynchronous and stop may not fully drain.
619 // We save the time when the track is started to later verify whether
620 // the counters are realistic (i.e. start from zero after this time).
621 mStartUs = getNowUs();
622
Eric Laurentec9a0322013-08-28 10:23:01 -0700623 // force refresh of remaining frames by processAudioBuffer() as last
624 // write before stop could be partial.
625 mRefreshRemaining = true;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800626 }
Glenn Kasten200092b2014-08-15 15:13:30 -0700627 mNewPosition = mPosition + mUpdatePeriod;
Andy Hung4be3b832016-10-13 17:51:43 -0700628 int32_t flags = android_atomic_and(~(CBLK_STREAM_END_DONE | CBLK_DISABLED), &mCblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800629
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800630 status_t status = NO_ERROR;
631 if (!(flags & CBLK_INVALID)) {
632 status = mAudioTrack->start();
633 if (status == DEAD_OBJECT) {
634 flags |= CBLK_INVALID;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800635 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800636 }
637 if (flags & CBLK_INVALID) {
638 status = restoreTrack_l("start");
639 }
640
Andy Hung79629f02016-03-24 13:57:40 -0700641 // resume or pause the callback thread as needed.
642 sp<AudioTrackThread> t = mAudioTrackThread;
643 if (status == NO_ERROR) {
644 if (t != 0) {
645 if (previousState == STATE_STOPPING) {
646 mProxy->interrupt();
647 } else {
648 t->resume();
649 }
650 } else {
651 mPreviousPriority = getpriority(PRIO_PROCESS, 0);
652 get_sched_policy(0, &mPreviousSchedulingGroup);
653 androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
654 }
Andy Hung39399b62017-04-21 15:07:45 -0700655
656 // Start our local VolumeHandler for restoration purposes.
657 mVolumeHandler->setStarted();
Andy Hung79629f02016-03-24 13:57:40 -0700658 } else {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800659 ALOGE("start() status %d", status);
660 mState = previousState;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800661 if (t != 0) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100662 if (previousState != STATE_STOPPING) {
663 t->pause();
664 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800665 } else {
Glenn Kasten87913512011-06-22 16:15:25 -0700666 setpriority(PRIO_PROCESS, 0, mPreviousPriority);
Glenn Kastena6364332012-04-19 09:35:04 -0700667 set_sched_policy(0, mPreviousSchedulingGroup);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800668 }
669 }
670
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100671 return status;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800672}
673
674void AudioTrack::stop()
675{
676 AutoMutex lock(mLock);
Glenn Kasten397edb32013-08-30 15:10:13 -0700677 if (mState != STATE_ACTIVE && mState != STATE_PAUSED) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800678 return;
679 }
680
Glenn Kasten23a75452014-01-13 10:37:17 -0800681 if (isOffloaded_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100682 mState = STATE_STOPPING;
683 } else {
684 mState = STATE_STOPPED;
Andy Hung2148bf02016-11-28 19:01:02 -0800685 ALOGD_IF(mSharedBuffer == nullptr,
686 "stop() called with %u frames delivered", mReleased.value());
Andy Hungc2813e52014-10-16 17:54:34 -0700687 mReleased = 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100688 }
689
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800690 mProxy->interrupt();
691 mAudioTrack->stop();
Andy Hung61be8412015-10-06 10:51:09 -0700692
693 // Note: legacy handling - stop does not clear playback marker
694 // and periodic update counter, but flush does for streaming tracks.
Andy Hung9b461582014-12-01 17:56:29 -0800695
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800696 if (mSharedBuffer != 0) {
Andy Hung9b461582014-12-01 17:56:29 -0800697 // clear buffer position and loop count.
Andy Hung9b461582014-12-01 17:56:29 -0800698 mStaticProxy->setBufferPositionAndLoop(0 /* position */,
699 0 /* loopStart */, 0 /* loopEnd */, 0 /* loopCount */);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800700 }
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100701
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800702 sp<AudioTrackThread> t = mAudioTrackThread;
703 if (t != 0) {
Glenn Kasten23a75452014-01-13 10:37:17 -0800704 if (!isOffloaded_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100705 t->pause();
706 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800707 } else {
708 setpriority(PRIO_PROCESS, 0, mPreviousPriority);
709 set_sched_policy(0, mPreviousSchedulingGroup);
710 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800711}
712
713bool AudioTrack::stopped() const
714{
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800715 AutoMutex lock(mLock);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800716 return mState != STATE_ACTIVE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800717}
718
719void AudioTrack::flush()
720{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800721 if (mSharedBuffer != 0) {
722 return;
Glenn Kasten4bae3642012-11-30 13:41:12 -0800723 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800724 AutoMutex lock(mLock);
725 if (mState == STATE_ACTIVE || mState == STATE_FLUSHED) {
726 return;
727 }
728 flush_l();
Eric Laurent1703cdf2011-03-07 14:52:59 -0800729}
730
Eric Laurent1703cdf2011-03-07 14:52:59 -0800731void AudioTrack::flush_l()
732{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800733 ALOG_ASSERT(mState != STATE_ACTIVE);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700734
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700735 // clear playback marker and periodic update counter
736 mMarkerPosition = 0;
737 mMarkerReached = false;
738 mUpdatePeriod = 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100739 mRefreshRemaining = true;
Eric Laurentc2f1f072009-07-17 12:17:14 -0700740
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800741 mState = STATE_FLUSHED;
Andy Hungc2813e52014-10-16 17:54:34 -0700742 mReleased = 0;
Glenn Kasten23a75452014-01-13 10:37:17 -0800743 if (isOffloaded_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100744 mProxy->interrupt();
745 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800746 mProxy->flush();
Glenn Kasten4bae3642012-11-30 13:41:12 -0800747 mAudioTrack->flush();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800748}
749
750void AudioTrack::pause()
751{
Eric Laurentf5aafb22010-11-18 08:40:16 -0800752 AutoMutex lock(mLock);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100753 if (mState == STATE_ACTIVE) {
754 mState = STATE_PAUSED;
755 } else if (mState == STATE_STOPPING) {
756 mState = STATE_PAUSED_STOPPING;
757 } else {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800758 return;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800759 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800760 mProxy->interrupt();
761 mAudioTrack->pause();
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800762
Marco Nelissen3a90f282014-03-10 11:21:43 -0700763 if (isOffloaded_l()) {
Glenn Kasten142f5192014-03-25 17:44:59 -0700764 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Andy Hung7f1bc8a2014-09-12 14:43:11 -0700765 // An offload output can be re-used between two audio tracks having
766 // the same configuration. A timestamp query for a paused track
767 // while the other is running would return an incorrect time.
768 // To fix this, cache the playback position on a pause() and return
769 // this time when requested until the track is resumed.
770
771 // OffloadThread sends HAL pause in its threadLoop. Time saved
772 // here can be slightly off.
773
774 // TODO: check return code for getRenderPosition.
775
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800776 uint32_t halFrames;
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800777 AudioSystem::getRenderPosition(mOutput, &halFrames, &mPausedPosition);
778 ALOGV("AudioTrack::pause for offload, cache current position %u", mPausedPosition);
779 }
780 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800781}
782
Eric Laurentbe916aa2010-06-01 23:49:17 -0700783status_t AudioTrack::setVolume(float left, float right)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800784{
Glenn Kastenc56f3422014-03-21 17:53:17 -0700785 // This duplicates a test by AudioTrack JNI, but that is not the only caller
786 if (isnanf(left) || left < GAIN_FLOAT_ZERO || left > GAIN_FLOAT_UNITY ||
787 isnanf(right) || right < GAIN_FLOAT_ZERO || right > GAIN_FLOAT_UNITY) {
Eric Laurentbe916aa2010-06-01 23:49:17 -0700788 return BAD_VALUE;
789 }
790
Eric Laurent1703cdf2011-03-07 14:52:59 -0800791 AutoMutex lock(mLock);
Glenn Kasten66e46352014-01-16 17:44:23 -0800792 mVolume[AUDIO_INTERLEAVE_LEFT] = left;
793 mVolume[AUDIO_INTERLEAVE_RIGHT] = right;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800794
Glenn Kastenc56f3422014-03-21 17:53:17 -0700795 mProxy->setVolumeLR(gain_minifloat_pack(gain_from_float(left), gain_from_float(right)));
Eric Laurentbe916aa2010-06-01 23:49:17 -0700796
Glenn Kasten23a75452014-01-13 10:37:17 -0800797 if (isOffloaded_l()) {
Eric Laurent59fe0102013-09-27 18:48:26 -0700798 mAudioTrack->signal();
799 }
Eric Laurentbe916aa2010-06-01 23:49:17 -0700800 return NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800801}
802
Glenn Kastenb1c09932012-02-27 16:21:04 -0800803status_t AudioTrack::setVolume(float volume)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800804{
Glenn Kastenb1c09932012-02-27 16:21:04 -0800805 return setVolume(volume, volume);
Eric Laurentbe916aa2010-06-01 23:49:17 -0700806}
807
Eric Laurent2beeb502010-07-16 07:43:46 -0700808status_t AudioTrack::setAuxEffectSendLevel(float level)
Eric Laurentbe916aa2010-06-01 23:49:17 -0700809{
Glenn Kastenc56f3422014-03-21 17:53:17 -0700810 // This duplicates a test by AudioTrack JNI, but that is not the only caller
811 if (isnanf(level) || level < GAIN_FLOAT_ZERO || level > GAIN_FLOAT_UNITY) {
Eric Laurentbe916aa2010-06-01 23:49:17 -0700812 return BAD_VALUE;
813 }
814
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800815 AutoMutex lock(mLock);
Eric Laurentbe916aa2010-06-01 23:49:17 -0700816 mSendLevel = level;
Glenn Kastene3aa6592012-12-04 12:22:46 -0800817 mProxy->setSendLevel(level);
Eric Laurentbe916aa2010-06-01 23:49:17 -0700818
819 return NO_ERROR;
820}
821
Glenn Kastena5224f32012-01-04 12:41:44 -0800822void AudioTrack::getAuxEffectSendLevel(float* level) const
Eric Laurentbe916aa2010-06-01 23:49:17 -0700823{
824 if (level != NULL) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800825 *level = mSendLevel;
Eric Laurentbe916aa2010-06-01 23:49:17 -0700826 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800827}
828
Glenn Kasten3b16c762012-11-14 08:44:39 -0800829status_t AudioTrack::setSampleRate(uint32_t rate)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800830{
Andy Hung5cbb5782015-03-27 18:39:59 -0700831 AutoMutex lock(mLock);
832 if (rate == mSampleRate) {
833 return NO_ERROR;
834 }
Glenn Kastend79072e2016-01-06 08:41:20 -0800835 if (isOffloadedOrDirect_l() || (mFlags & AUDIO_OUTPUT_FLAG_FAST)) {
John Grossman4ff14ba2012-02-08 16:37:41 -0800836 return INVALID_OPERATION;
837 }
Eric Laurent0d6db582014-11-12 18:39:44 -0800838 if (mOutput == AUDIO_IO_HANDLE_NONE) {
839 return NO_INIT;
840 }
Andy Hung5cbb5782015-03-27 18:39:59 -0700841 // NOTE: it is theoretically possible, but highly unlikely, that a device change
842 // could mean a previously allowed sampling rate is no longer allowed.
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800843 uint32_t afSamplingRate;
Eric Laurent0d6db582014-11-12 18:39:44 -0800844 if (AudioSystem::getSamplingRate(mOutput, &afSamplingRate) != NO_ERROR) {
Eric Laurent57326622009-07-07 07:10:45 -0700845 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800846 }
Andy Hung26145642015-04-15 21:56:53 -0700847 // pitch is emulated by adjusting speed and sampleRate
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700848 const uint32_t effectiveSampleRate = adjustSampleRate(rate, mPlaybackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -0700849 if (rate == 0 || effectiveSampleRate > afSamplingRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Glenn Kastend65d73c2012-06-22 17:21:07 -0700850 return BAD_VALUE;
851 }
Andy Hung8edb8dc2015-03-26 19:13:55 -0700852 // TODO: Should we also check if the buffer size is compatible?
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800853
Glenn Kastene3aa6592012-12-04 12:22:46 -0800854 mSampleRate = rate;
Andy Hung26145642015-04-15 21:56:53 -0700855 mProxy->setSampleRate(effectiveSampleRate);
Glenn Kastene3aa6592012-12-04 12:22:46 -0800856
Eric Laurent57326622009-07-07 07:10:45 -0700857 return NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800858}
859
Glenn Kastena5224f32012-01-04 12:41:44 -0800860uint32_t AudioTrack::getSampleRate() const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800861{
Eric Laurent1703cdf2011-03-07 14:52:59 -0800862 AutoMutex lock(mLock);
Eric Laurent6f59db12013-07-26 17:16:50 -0700863
864 // sample rate can be updated during playback by the offloaded decoder so we need to
865 // query the HAL and update if needed.
866// FIXME use Proxy return channel to update the rate from server and avoid polling here
Eric Laurentab5cdba2014-06-09 17:22:27 -0700867 if (isOffloadedOrDirect_l()) {
Glenn Kasten142f5192014-03-25 17:44:59 -0700868 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Eric Laurent6f59db12013-07-26 17:16:50 -0700869 uint32_t sampleRate = 0;
Jean-Michel Trivib7f24b12014-06-11 10:05:30 -0700870 status_t status = AudioSystem::getSamplingRate(mOutput, &sampleRate);
Eric Laurent6f59db12013-07-26 17:16:50 -0700871 if (status == NO_ERROR) {
872 mSampleRate = sampleRate;
873 }
874 }
875 }
Glenn Kastene3aa6592012-12-04 12:22:46 -0800876 return mSampleRate;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800877}
878
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700879uint32_t AudioTrack::getOriginalSampleRate() const
880{
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700881 return mOriginalSampleRate;
882}
883
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700884status_t AudioTrack::setPlaybackRate(const AudioPlaybackRate &playbackRate)
Andy Hung8edb8dc2015-03-26 19:13:55 -0700885{
Andy Hung8edb8dc2015-03-26 19:13:55 -0700886 AutoMutex lock(mLock);
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700887 if (isAudioPlaybackRateEqual(playbackRate, mPlaybackRate)) {
Andy Hung8edb8dc2015-03-26 19:13:55 -0700888 return NO_ERROR;
889 }
Glenn Kastend79072e2016-01-06 08:41:20 -0800890 if (isOffloadedOrDirect_l()) {
Andy Hung8edb8dc2015-03-26 19:13:55 -0700891 return INVALID_OPERATION;
892 }
893 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
894 return INVALID_OPERATION;
895 }
Andy Hungff874dc2016-04-11 16:49:09 -0700896
897 ALOGV("setPlaybackRate (input): mSampleRate:%u mSpeed:%f mPitch:%f",
898 mSampleRate, playbackRate.mSpeed, playbackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -0700899 // pitch is emulated by adjusting speed and sampleRate
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700900 const uint32_t effectiveRate = adjustSampleRate(mSampleRate, playbackRate.mPitch);
901 const float effectiveSpeed = adjustSpeed(playbackRate.mSpeed, playbackRate.mPitch);
902 const float effectivePitch = adjustPitch(playbackRate.mPitch);
Ricardo Garcia6c7f0622015-04-30 18:39:16 -0700903 AudioPlaybackRate playbackRateTemp = playbackRate;
904 playbackRateTemp.mSpeed = effectiveSpeed;
905 playbackRateTemp.mPitch = effectivePitch;
906
Andy Hungff874dc2016-04-11 16:49:09 -0700907 ALOGV("setPlaybackRate (effective): mSampleRate:%u mSpeed:%f mPitch:%f",
908 effectiveRate, effectiveSpeed, effectivePitch);
909
Ricardo Garcia6c7f0622015-04-30 18:39:16 -0700910 if (!isAudioPlaybackRateValid(playbackRateTemp)) {
Kevin Rocard4e728d42017-04-06 18:00:40 -0700911 ALOGW("setPlaybackRate(%f, %f) failed (effective rate out of bounds)",
Andy Hungff874dc2016-04-11 16:49:09 -0700912 playbackRate.mSpeed, playbackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -0700913 return BAD_VALUE;
914 }
Andy Hung8edb8dc2015-03-26 19:13:55 -0700915 // Check if the buffer size is compatible.
Andy Hung26145642015-04-15 21:56:53 -0700916 if (!isSampleRateSpeedAllowed_l(effectiveRate, effectiveSpeed)) {
Kevin Rocard4e728d42017-04-06 18:00:40 -0700917 ALOGW("setPlaybackRate(%f, %f) failed (buffer size)",
Andy Hungff874dc2016-04-11 16:49:09 -0700918 playbackRate.mSpeed, playbackRate.mPitch);
Andy Hung8edb8dc2015-03-26 19:13:55 -0700919 return BAD_VALUE;
920 }
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700921
Ricardo Garcia6c7f0622015-04-30 18:39:16 -0700922 // Check resampler ratios are within bounds
Glenn Kastend3bb6452016-12-05 18:14:37 -0800923 if ((uint64_t)effectiveRate > (uint64_t)mSampleRate *
924 (uint64_t)AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Kevin Rocard4e728d42017-04-06 18:00:40 -0700925 ALOGW("setPlaybackRate(%f, %f) failed. Resample rate exceeds max accepted value",
Ricardo Garcia6c7f0622015-04-30 18:39:16 -0700926 playbackRate.mSpeed, playbackRate.mPitch);
927 return BAD_VALUE;
928 }
929
Dan Austine34eae22015-10-27 16:14:52 -0700930 if ((uint64_t)effectiveRate * (uint64_t)AUDIO_RESAMPLER_UP_RATIO_MAX < (uint64_t)mSampleRate) {
Kevin Rocard4e728d42017-04-06 18:00:40 -0700931 ALOGW("setPlaybackRate(%f, %f) failed. Resample rate below min accepted value",
Ricardo Garcia6c7f0622015-04-30 18:39:16 -0700932 playbackRate.mSpeed, playbackRate.mPitch);
933 return BAD_VALUE;
934 }
935 mPlaybackRate = playbackRate;
936 //set effective rates
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700937 mProxy->setPlaybackRate(playbackRateTemp);
Andy Hung26145642015-04-15 21:56:53 -0700938 mProxy->setSampleRate(effectiveRate); // FIXME: not quite "atomic" with setPlaybackRate
Andy Hung8edb8dc2015-03-26 19:13:55 -0700939 return NO_ERROR;
940}
941
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700942const AudioPlaybackRate& AudioTrack::getPlaybackRate() const
Andy Hung8edb8dc2015-03-26 19:13:55 -0700943{
944 AutoMutex lock(mLock);
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700945 return mPlaybackRate;
Andy Hung8edb8dc2015-03-26 19:13:55 -0700946}
947
Phil Burkc0adecb2016-01-08 12:44:11 -0800948ssize_t AudioTrack::getBufferSizeInFrames()
949{
950 AutoMutex lock(mLock);
951 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
952 return NO_INIT;
953 }
Phil Burke8972b02016-03-04 11:29:57 -0800954 return (ssize_t) mProxy->getBufferSizeInFrames();
Phil Burkc0adecb2016-01-08 12:44:11 -0800955}
956
Andy Hungf2c87b32016-04-07 19:49:29 -0700957status_t AudioTrack::getBufferDurationInUs(int64_t *duration)
958{
959 if (duration == nullptr) {
960 return BAD_VALUE;
961 }
962 AutoMutex lock(mLock);
963 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
964 return NO_INIT;
965 }
966 ssize_t bufferSizeInFrames = (ssize_t) mProxy->getBufferSizeInFrames();
967 if (bufferSizeInFrames < 0) {
968 return (status_t)bufferSizeInFrames;
969 }
970 *duration = (int64_t)((double)bufferSizeInFrames * 1000000
971 / ((double)mSampleRate * mPlaybackRate.mSpeed));
972 return NO_ERROR;
973}
974
Phil Burkc0adecb2016-01-08 12:44:11 -0800975ssize_t AudioTrack::setBufferSizeInFrames(size_t bufferSizeInFrames)
976{
977 AutoMutex lock(mLock);
978 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
979 return NO_INIT;
980 }
981 // Reject if timed track or compressed audio.
Glenn Kastend79072e2016-01-06 08:41:20 -0800982 if (!audio_is_linear_pcm(mFormat)) {
Phil Burkc0adecb2016-01-08 12:44:11 -0800983 return INVALID_OPERATION;
984 }
Phil Burke8972b02016-03-04 11:29:57 -0800985 return (ssize_t) mProxy->setBufferSizeInFrames((uint32_t) bufferSizeInFrames);
Phil Burkc0adecb2016-01-08 12:44:11 -0800986}
987
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800988status_t AudioTrack::setLoop(uint32_t loopStart, uint32_t loopEnd, int loopCount)
989{
Glenn Kastend79072e2016-01-06 08:41:20 -0800990 if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
Glenn Kasten083d1c12012-11-30 15:00:36 -0800991 return INVALID_OPERATION;
992 }
993
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800994 if (loopCount == 0) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800995 ;
996 } else if (loopCount >= -1 && loopStart < loopEnd && loopEnd <= mFrameCount &&
997 loopEnd - loopStart >= MIN_LOOP) {
998 ;
999 } else {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001000 return BAD_VALUE;
1001 }
1002
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001003 AutoMutex lock(mLock);
1004 // See setPosition() regarding setting parameters such as loop points or position while active
1005 if (mState == STATE_ACTIVE) {
1006 return INVALID_OPERATION;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001007 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001008 setLoop_l(loopStart, loopEnd, loopCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001009 return NO_ERROR;
1010}
1011
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001012void AudioTrack::setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount)
1013{
Andy Hung4ede21d2014-12-12 15:37:34 -08001014 // We do not update the periodic notification point.
1015 // mNewPosition = updateAndGetPosition_l() + mUpdatePeriod;
1016 mLoopCount = loopCount;
1017 mLoopEnd = loopEnd;
1018 mLoopStart = loopStart;
Andy Hung53c3b5f2014-12-15 16:42:05 -08001019 mLoopCountNotified = loopCount;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001020 mStaticProxy->setLoop(loopStart, loopEnd, loopCount);
Andy Hung3c09c782014-12-29 18:39:32 -08001021
1022 // Waking the AudioTrackThread is not needed as this cannot be called when active.
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001023}
1024
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001025status_t AudioTrack::setMarkerPosition(uint32_t marker)
1026{
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001027 // The only purpose of setting marker position is to get a callback
Eric Laurentab5cdba2014-06-09 17:22:27 -07001028 if (mCbf == NULL || isOffloadedOrDirect()) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001029 return INVALID_OPERATION;
1030 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001031
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001032 AutoMutex lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001033 mMarkerPosition = marker;
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -07001034 mMarkerReached = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001035
Andy Hung3c09c782014-12-29 18:39:32 -08001036 sp<AudioTrackThread> t = mAudioTrackThread;
1037 if (t != 0) {
1038 t->wake();
1039 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001040 return NO_ERROR;
1041}
1042
Glenn Kastena5224f32012-01-04 12:41:44 -08001043status_t AudioTrack::getMarkerPosition(uint32_t *marker) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001044{
Eric Laurentab5cdba2014-06-09 17:22:27 -07001045 if (isOffloadedOrDirect()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001046 return INVALID_OPERATION;
1047 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07001048 if (marker == NULL) {
1049 return BAD_VALUE;
1050 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001051
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001052 AutoMutex lock(mLock);
Andy Hung90e8a972015-11-09 16:42:40 -08001053 mMarkerPosition.getValue(marker);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001054
1055 return NO_ERROR;
1056}
1057
1058status_t AudioTrack::setPositionUpdatePeriod(uint32_t updatePeriod)
1059{
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001060 // The only purpose of setting position update period is to get a callback
Eric Laurentab5cdba2014-06-09 17:22:27 -07001061 if (mCbf == NULL || isOffloadedOrDirect()) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001062 return INVALID_OPERATION;
1063 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001064
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001065 AutoMutex lock(mLock);
Glenn Kasten200092b2014-08-15 15:13:30 -07001066 mNewPosition = updateAndGetPosition_l() + updatePeriod;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001067 mUpdatePeriod = updatePeriod;
Glenn Kasten2b2165c2014-01-13 08:53:36 -08001068
Andy Hung3c09c782014-12-29 18:39:32 -08001069 sp<AudioTrackThread> t = mAudioTrackThread;
1070 if (t != 0) {
1071 t->wake();
1072 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001073 return NO_ERROR;
1074}
1075
Glenn Kastena5224f32012-01-04 12:41:44 -08001076status_t AudioTrack::getPositionUpdatePeriod(uint32_t *updatePeriod) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001077{
Eric Laurentab5cdba2014-06-09 17:22:27 -07001078 if (isOffloadedOrDirect()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001079 return INVALID_OPERATION;
1080 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07001081 if (updatePeriod == NULL) {
1082 return BAD_VALUE;
1083 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001084
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001085 AutoMutex lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001086 *updatePeriod = mUpdatePeriod;
1087
1088 return NO_ERROR;
1089}
1090
1091status_t AudioTrack::setPosition(uint32_t position)
1092{
Glenn Kastend79072e2016-01-06 08:41:20 -08001093 if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001094 return INVALID_OPERATION;
1095 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001096 if (position > mFrameCount) {
1097 return BAD_VALUE;
1098 }
John Grossman4ff14ba2012-02-08 16:37:41 -08001099
Eric Laurent1703cdf2011-03-07 14:52:59 -08001100 AutoMutex lock(mLock);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001101 // Currently we require that the player is inactive before setting parameters such as position
1102 // or loop points. Otherwise, there could be a race condition: the application could read the
1103 // current position, compute a new position or loop parameters, and then set that position or
1104 // loop parameters but it would do the "wrong" thing since the position has continued to advance
1105 // in the mean time. If we ever provide a sequencer in server, we could allow a way for the app
1106 // to specify how it wants to handle such scenarios.
1107 if (mState == STATE_ACTIVE) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001108 return INVALID_OPERATION;
1109 }
Andy Hung9b461582014-12-01 17:56:29 -08001110 // After setting the position, use full update period before notification.
Glenn Kasten200092b2014-08-15 15:13:30 -07001111 mNewPosition = updateAndGetPosition_l() + mUpdatePeriod;
Andy Hung9b461582014-12-01 17:56:29 -08001112 mStaticProxy->setBufferPosition(position);
Andy Hung3c09c782014-12-29 18:39:32 -08001113
1114 // Waking the AudioTrackThread is not needed as this cannot be called when active.
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001115 return NO_ERROR;
1116}
1117
Glenn Kasten200092b2014-08-15 15:13:30 -07001118status_t AudioTrack::getPosition(uint32_t *position)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001119{
Glenn Kastend65d73c2012-06-22 17:21:07 -07001120 if (position == NULL) {
1121 return BAD_VALUE;
1122 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001123
Eric Laurent1703cdf2011-03-07 14:52:59 -08001124 AutoMutex lock(mLock);
Andy Hung7a490e72016-03-23 15:58:10 -07001125 // FIXME: offloaded and direct tracks call into the HAL for render positions
1126 // for compressed/synced data; however, we use proxy position for pure linear pcm data
1127 // as we do not know the capability of the HAL for pcm position support and standby.
1128 // There may be some latency differences between the HAL position and the proxy position.
1129 if (isOffloadedOrDirect_l() && !isPurePcmData_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001130 uint32_t dspFrames = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001131
Eric Laurentab5cdba2014-06-09 17:22:27 -07001132 if (isOffloaded_l() && ((mState == STATE_PAUSED) || (mState == STATE_PAUSED_STOPPING))) {
Haynes Mathew George7064fd22014-01-08 13:59:53 -08001133 ALOGV("getPosition called in paused state, return cached position %u", mPausedPosition);
1134 *position = mPausedPosition;
1135 return NO_ERROR;
1136 }
1137
Glenn Kasten142f5192014-03-25 17:44:59 -07001138 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Andy Hung1f1db832015-06-08 13:26:10 -07001139 uint32_t halFrames; // actually unused
1140 (void) AudioSystem::getRenderPosition(mOutput, &halFrames, &dspFrames);
1141 // FIXME: on getRenderPosition() error, we return OK with frame position 0.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001142 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07001143 // FIXME: dspFrames may not be zero in (mState == STATE_STOPPED || mState == STATE_FLUSHED)
1144 // due to hardware latency. We leave this behavior for now.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001145 *position = dspFrames;
1146 } else {
Eric Laurent275e8e92014-11-30 15:14:47 -08001147 if (mCblk->mFlags & CBLK_INVALID) {
Andy Hung1f1db832015-06-08 13:26:10 -07001148 (void) restoreTrack_l("getPosition");
1149 // FIXME: for compatibility with the Java API we ignore the restoreTrack_l()
1150 // error here (e.g. DEAD_OBJECT) and return OK with the last recorded server position.
Eric Laurent275e8e92014-11-30 15:14:47 -08001151 }
1152
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001153 // IAudioTrack::stop() isn't synchronous; we don't know when presentation completes
Glenn Kasten200092b2014-08-15 15:13:30 -07001154 *position = (mState == STATE_STOPPED || mState == STATE_FLUSHED) ?
Andy Hung90e8a972015-11-09 16:42:40 -08001155 0 : updateAndGetPosition_l().value();
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001156 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001157 return NO_ERROR;
1158}
1159
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001160status_t AudioTrack::getBufferPosition(uint32_t *position)
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001161{
Glenn Kastend79072e2016-01-06 08:41:20 -08001162 if (mSharedBuffer == 0) {
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001163 return INVALID_OPERATION;
1164 }
1165 if (position == NULL) {
1166 return BAD_VALUE;
1167 }
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001168
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001169 AutoMutex lock(mLock);
1170 *position = mStaticProxy->getBufferPosition();
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001171 return NO_ERROR;
1172}
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001173
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001174status_t AudioTrack::reload()
1175{
Glenn Kastend79072e2016-01-06 08:41:20 -08001176 if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
Glenn Kasten083d1c12012-11-30 15:00:36 -08001177 return INVALID_OPERATION;
1178 }
1179
Eric Laurent1703cdf2011-03-07 14:52:59 -08001180 AutoMutex lock(mLock);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001181 // See setPosition() regarding setting parameters such as loop points or position while active
1182 if (mState == STATE_ACTIVE) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001183 return INVALID_OPERATION;
1184 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001185 mNewPosition = mUpdatePeriod;
Andy Hung9b461582014-12-01 17:56:29 -08001186 (void) updateAndGetPosition_l();
1187 mPosition = 0;
Phil Burk1b420972015-04-22 10:52:21 -07001188 mPreviousTimestampValid = false;
Andy Hung53c3b5f2014-12-15 16:42:05 -08001189#if 0
Andy Hung9b461582014-12-01 17:56:29 -08001190 // The documentation is not clear on the behavior of reload() and the restoration
Andy Hung53c3b5f2014-12-15 16:42:05 -08001191 // of loop count. Historically we have not restored loop count, start, end,
1192 // but it makes sense if one desires to repeat playing a particular sound.
1193 if (mLoopCount != 0) {
1194 mLoopCountNotified = mLoopCount;
1195 mStaticProxy->setLoop(mLoopStart, mLoopEnd, mLoopCount);
1196 }
1197#endif
Andy Hung9b461582014-12-01 17:56:29 -08001198 mStaticProxy->setBufferPosition(0);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001199 return NO_ERROR;
1200}
1201
Glenn Kasten38e905b2014-01-13 10:21:48 -08001202audio_io_handle_t AudioTrack::getOutput() const
Eric Laurentc2f1f072009-07-17 12:17:14 -07001203{
Eric Laurent1703cdf2011-03-07 14:52:59 -08001204 AutoMutex lock(mLock);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001205 return mOutput;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001206}
1207
Paul McLeanaa981192015-03-21 09:55:15 -07001208status_t AudioTrack::setOutputDevice(audio_port_handle_t deviceId) {
1209 AutoMutex lock(mLock);
1210 if (mSelectedDeviceId != deviceId) {
1211 mSelectedDeviceId = deviceId;
Eric Laurent493404d2015-04-21 15:07:36 -07001212 android_atomic_or(CBLK_INVALID, &mCblk->mFlags);
Paul McLeanaa981192015-03-21 09:55:15 -07001213 }
Eric Laurent493404d2015-04-21 15:07:36 -07001214 return NO_ERROR;
Paul McLeanaa981192015-03-21 09:55:15 -07001215}
1216
1217audio_port_handle_t AudioTrack::getOutputDevice() {
1218 AutoMutex lock(mLock);
1219 return mSelectedDeviceId;
1220}
1221
Eric Laurent296fb132015-05-01 11:38:42 -07001222audio_port_handle_t AudioTrack::getRoutedDeviceId() {
1223 AutoMutex lock(mLock);
1224 if (mOutput == AUDIO_IO_HANDLE_NONE) {
1225 return AUDIO_PORT_HANDLE_NONE;
1226 }
1227 return AudioSystem::getDeviceIdForIo(mOutput);
1228}
1229
Eric Laurentbe916aa2010-06-01 23:49:17 -07001230status_t AudioTrack::attachAuxEffect(int effectId)
1231{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001232 AutoMutex lock(mLock);
Eric Laurent2beeb502010-07-16 07:43:46 -07001233 status_t status = mAudioTrack->attachAuxEffect(effectId);
1234 if (status == NO_ERROR) {
1235 mAuxEffectId = effectId;
1236 }
1237 return status;
Eric Laurentbe916aa2010-06-01 23:49:17 -07001238}
1239
Eric Laurente83b55d2014-11-14 10:06:21 -08001240audio_stream_type_t AudioTrack::streamType() const
1241{
1242 if (mStreamType == AUDIO_STREAM_DEFAULT) {
1243 return audio_attributes_to_stream_type(&mAttributes);
1244 }
1245 return mStreamType;
1246}
1247
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07001248uint32_t AudioTrack::latency()
1249{
1250 AutoMutex lock(mLock);
1251 updateLatency_l();
1252 return mLatency;
1253}
1254
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001255// -------------------------------------------------------------------------
1256
Eric Laurent1703cdf2011-03-07 14:52:59 -08001257// must be called with mLock held
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07001258void AudioTrack::updateLatency_l()
1259{
1260 status_t status = AudioSystem::getLatency(mOutput, &mAfLatency);
1261 if (status != NO_ERROR) {
1262 ALOGW("getLatency(%d) failed status %d", mOutput, status);
1263 } else {
1264 // FIXME don't believe this lie
1265 mLatency = mAfLatency + (1000 * mFrameCount) / mSampleRate;
1266 }
1267}
1268
Glenn Kasten200092b2014-08-15 15:13:30 -07001269status_t AudioTrack::createTrack_l()
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001270{
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001271 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
1272 if (audioFlinger == 0) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001273 ALOGE("Could not get audioflinger");
1274 return NO_INIT;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001275 }
1276
Eric Laurent296fb132015-05-01 11:38:42 -07001277 if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) {
1278 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
1279 }
Eric Laurente83b55d2014-11-14 10:06:21 -08001280 audio_io_handle_t output;
1281 audio_stream_type_t streamType = mStreamType;
1282 audio_attributes_t *attr = (mStreamType == AUDIO_STREAM_DEFAULT) ? &mAttributes : NULL;
Eric Laurente83b55d2014-11-14 10:06:21 -08001283
Haynes Mathew Georgeae34ed22016-01-28 11:58:39 -08001284 // mFlags (not mOrigFlags) is modified depending on whether fast request is accepted.
1285 // After fast request is denied, we will request again if IAudioTrack is re-created.
1286
Paul McLeanaa981192015-03-21 09:55:15 -07001287 status_t status;
Eric Laurent20b9ef02016-12-05 11:03:16 -08001288 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
1289 config.sample_rate = mSampleRate;
1290 config.channel_mask = mChannelMask;
1291 config.format = mFormat;
1292 config.offload_info = mOffloadInfoCopy;
Paul McLeanaa981192015-03-21 09:55:15 -07001293 status = AudioSystem::getOutputForAttr(attr, &output,
Glenn Kastend848eb42016-03-08 13:42:11 -08001294 mSessionId, &streamType, mClientUid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001295 &config,
1296 mFlags, mSelectedDeviceId, &mPortId);
Eric Laurente83b55d2014-11-14 10:06:21 -08001297
1298 if (status != NO_ERROR || output == AUDIO_IO_HANDLE_NONE) {
Glenn Kastend3bb6452016-12-05 18:14:37 -08001299 ALOGE("Could not get audio output for session %d, stream type %d, usage %d, sample rate %u,"
1300 " format %#x, channel mask %#x, flags %#x",
1301 mSessionId, streamType, mAttributes.usage, mSampleRate, mFormat, mChannelMask,
1302 mFlags);
Glenn Kasten38e905b2014-01-13 10:21:48 -08001303 return BAD_VALUE;
1304 }
1305 {
1306 // Now that we have a reference to an I/O handle and have not yet handed it off to AudioFlinger,
1307 // we must release it ourselves if anything goes wrong.
1308
Glenn Kastence8828a2013-09-16 18:07:38 -07001309 // Not all of these values are needed under all conditions, but it is easier to get them all
Andy Hung9f9e21e2015-05-31 21:45:36 -07001310 status = AudioSystem::getLatency(output, &mAfLatency);
Glenn Kastence8828a2013-09-16 18:07:38 -07001311 if (status != NO_ERROR) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001312 ALOGE("getLatency(%d) failed status %d", output, status);
Glenn Kasten38e905b2014-01-13 10:21:48 -08001313 goto release;
Eric Laurentd1b449a2010-05-14 03:26:45 -07001314 }
Andy Hung9f9e21e2015-05-31 21:45:36 -07001315 ALOGV("createTrack_l() output %d afLatency %u", output, mAfLatency);
Eric Laurentd1b449a2010-05-14 03:26:45 -07001316
Andy Hung9f9e21e2015-05-31 21:45:36 -07001317 status = AudioSystem::getFrameCount(output, &mAfFrameCount);
Glenn Kastence8828a2013-09-16 18:07:38 -07001318 if (status != NO_ERROR) {
Jean-Michel Trivib7f24b12014-06-11 10:05:30 -07001319 ALOGE("getFrameCount(output=%d) status %d", output, status);
Glenn Kasten38e905b2014-01-13 10:21:48 -08001320 goto release;
Glenn Kastence8828a2013-09-16 18:07:38 -07001321 }
1322
Glenn Kastenea38ee72016-04-18 11:08:01 -07001323 // TODO consider making this a member variable if there are other uses for it later
1324 size_t afFrameCountHAL;
1325 status = AudioSystem::getFrameCountHAL(output, &afFrameCountHAL);
1326 if (status != NO_ERROR) {
1327 ALOGE("getFrameCountHAL(output=%d) status %d", output, status);
1328 goto release;
1329 }
1330 ALOG_ASSERT(afFrameCountHAL > 0);
1331
Andy Hung9f9e21e2015-05-31 21:45:36 -07001332 status = AudioSystem::getSamplingRate(output, &mAfSampleRate);
Glenn Kastence8828a2013-09-16 18:07:38 -07001333 if (status != NO_ERROR) {
Jean-Michel Trivib7f24b12014-06-11 10:05:30 -07001334 ALOGE("getSamplingRate(output=%d) status %d", output, status);
Glenn Kasten38e905b2014-01-13 10:21:48 -08001335 goto release;
Glenn Kastence8828a2013-09-16 18:07:38 -07001336 }
Eric Laurent0d6db582014-11-12 18:39:44 -08001337 if (mSampleRate == 0) {
Andy Hung9f9e21e2015-05-31 21:45:36 -07001338 mSampleRate = mAfSampleRate;
1339 mOriginalSampleRate = mAfSampleRate;
Eric Laurent0d6db582014-11-12 18:39:44 -08001340 }
Glenn Kasten7fd04222016-02-02 12:38:16 -08001341
Glenn Kastend79072e2016-01-06 08:41:20 -08001342 // Client can only express a preference for FAST. Server will perform additional tests.
Phil Burk33ff89b2015-11-30 11:16:01 -08001343 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
1344 bool useCaseAllowed =
Glenn Kasten4a4a0952012-03-19 11:38:14 -07001345 // either of these use cases:
1346 // use case 1: shared buffer
Glenn Kasten363fb752014-01-15 12:27:31 -08001347 (mSharedBuffer != 0) ||
Glenn Kastenc6ba8232014-02-27 13:34:29 -08001348 // use case 2: callback transfer mode
Glenn Kasten1dfe2f92015-03-09 12:03:14 -07001349 (mTransfer == TRANSFER_CALLBACK) ||
1350 // use case 3: obtain/release mode
Phil Burk33ff89b2015-11-30 11:16:01 -08001351 (mTransfer == TRANSFER_OBTAIN) ||
1352 // use case 4: synchronous write
1353 ((mTransfer == TRANSFER_SYNC) && mThreadCanCallJava);
1354 // sample rates must also match
1355 bool fastAllowed = useCaseAllowed && (mSampleRate == mAfSampleRate);
1356 if (!fastAllowed) {
Glenn Kasten7fd04222016-02-02 12:38:16 -08001357 ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by client; transfer %d, "
Phil Burk33ff89b2015-11-30 11:16:01 -08001358 "track %u Hz, output %u Hz",
Andy Hung9f9e21e2015-05-31 21:45:36 -07001359 mTransfer, mSampleRate, mAfSampleRate);
Phil Burk33ff89b2015-11-30 11:16:01 -08001360 mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_FAST);
1361 }
Glenn Kasten4a4a0952012-03-19 11:38:14 -07001362 }
1363
Eric Laurentd1b449a2010-05-14 03:26:45 -07001364 mNotificationFramesAct = mNotificationFramesReq;
Glenn Kastene0fa4672012-04-24 14:35:14 -07001365
Glenn Kasten363fb752014-01-15 12:27:31 -08001366 size_t frameCount = mReqFrameCount;
Phil Burkfdb3c072016-02-09 10:47:02 -08001367 if (!audio_has_proportional_frames(mFormat)) {
Glenn Kastene0fa4672012-04-24 14:35:14 -07001368
Glenn Kasten363fb752014-01-15 12:27:31 -08001369 if (mSharedBuffer != 0) {
Glenn Kastene0fa4672012-04-24 14:35:14 -07001370 // Same comment as below about ignoring frameCount parameter for set()
Glenn Kasten363fb752014-01-15 12:27:31 -08001371 frameCount = mSharedBuffer->size();
Glenn Kastene0fa4672012-04-24 14:35:14 -07001372 } else if (frameCount == 0) {
Andy Hung9f9e21e2015-05-31 21:45:36 -07001373 frameCount = mAfFrameCount;
Eric Laurentd1b449a2010-05-14 03:26:45 -07001374 }
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001375 if (mNotificationFramesAct != frameCount) {
1376 mNotificationFramesAct = frameCount;
1377 }
Glenn Kasten363fb752014-01-15 12:27:31 -08001378 } else if (mSharedBuffer != 0) {
Andy Hungabdb9902015-01-12 15:08:22 -08001379 // FIXME: Ensure client side memory buffers need
1380 // not have additional alignment beyond sample
1381 // (e.g. 16 bit stereo accessed as 32 bit frame).
1382 size_t alignment = audio_bytes_per_sample(mFormat);
Glenn Kastenb7730382014-04-30 15:50:31 -07001383 if (alignment & 1) {
Andy Hungabdb9902015-01-12 15:08:22 -08001384 // for AUDIO_FORMAT_PCM_24_BIT_PACKED (not exposed through Java).
Glenn Kastenb7730382014-04-30 15:50:31 -07001385 alignment = 1;
1386 }
Glenn Kastena42ff002012-11-14 12:47:55 -08001387 if (mChannelCount > 1) {
Glenn Kastene0fa4672012-04-24 14:35:14 -07001388 // More than 2 channels does not require stronger alignment than stereo
1389 alignment <<= 1;
1390 }
Narayan Kamath1d6fa7a2014-02-11 13:47:53 +00001391 if (((uintptr_t)mSharedBuffer->pointer() & (alignment - 1)) != 0) {
Glenn Kastena42ff002012-11-14 12:47:55 -08001392 ALOGE("Invalid buffer alignment: address %p, channel count %u",
Glenn Kasten363fb752014-01-15 12:27:31 -08001393 mSharedBuffer->pointer(), mChannelCount);
Glenn Kasten38e905b2014-01-13 10:21:48 -08001394 status = BAD_VALUE;
1395 goto release;
Glenn Kastene0fa4672012-04-24 14:35:14 -07001396 }
1397
1398 // When initializing a shared buffer AudioTrack via constructors,
1399 // there's no frameCount parameter.
1400 // But when initializing a shared buffer AudioTrack via set(),
1401 // there _is_ a frameCount parameter. We silently ignore it.
Andy Hungabdb9902015-01-12 15:08:22 -08001402 frameCount = mSharedBuffer->size() / mFrameSize;
Glenn Kastene0fa4672012-04-24 14:35:14 -07001403 } else {
Glenn Kastenea38ee72016-04-18 11:08:01 -07001404 size_t minFrameCount = 0;
1405 // For fast tracks the frame count calculations and checks are mostly done by server,
1406 // but we try to respect the application's request for notifications per buffer.
1407 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
1408 if (mNotificationsPerBufferReq > 0) {
1409 // Avoid possible arithmetic overflow during multiplication.
1410 // mNotificationsPerBuffer is clamped to a small integer earlier, so it is unlikely.
1411 if (mNotificationsPerBufferReq > SIZE_MAX / afFrameCountHAL) {
1412 ALOGE("Requested notificationPerBuffer=%u ignored for HAL frameCount=%zu",
1413 mNotificationsPerBufferReq, afFrameCountHAL);
1414 } else {
1415 minFrameCount = afFrameCountHAL * mNotificationsPerBufferReq;
1416 }
1417 }
1418 } else {
Andy Hung8edb8dc2015-03-26 19:13:55 -07001419 // for normal tracks precompute the frame count based on speed.
Andy Hungff874dc2016-04-11 16:49:09 -07001420 const float speed = !isPurePcmData_l() || isOffloadedOrDirect_l() ? 1.0f :
1421 max(mMaxRequiredSpeed, mPlaybackRate.mSpeed);
Glenn Kastenea38ee72016-04-18 11:08:01 -07001422 minFrameCount = calculateMinFrameCount(
Andy Hung9f9e21e2015-05-31 21:45:36 -07001423 mAfLatency, mAfFrameCount, mAfSampleRate, mSampleRate,
Glenn Kastenea38ee72016-04-18 11:08:01 -07001424 speed /*, 0 mNotificationsPerBufferReq*/);
1425 }
1426 if (frameCount < minFrameCount) {
1427 frameCount = minFrameCount;
Andy Hung8edb8dc2015-03-26 19:13:55 -07001428 }
Eric Laurentd1b449a2010-05-14 03:26:45 -07001429 }
1430
Eric Laurent05067782016-06-01 18:27:28 -07001431 audio_output_flags_t flags = mFlags;
Glenn Kasten3acbd052012-02-28 10:39:56 -08001432
1433 pid_t tid = -1;
Glenn Kasten363fb752014-01-15 12:27:31 -08001434 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
Glenn Kasten47d55172017-05-23 11:19:30 -07001435 // It is currently meaningless to request SCHED_FIFO for a Java thread. Even if the
1436 // application-level code follows all non-blocking design rules, the language runtime
1437 // doesn't also follow those rules, so the thread will not benefit overall.
Phil Burk33ff89b2015-11-30 11:16:01 -08001438 if (mAudioTrackThread != 0 && !mThreadCanCallJava) {
Glenn Kasten3acbd052012-02-28 10:39:56 -08001439 tid = mAudioTrackThread->getTid();
1440 }
Glenn Kasten4a4a0952012-03-19 11:38:14 -07001441 }
1442
Glenn Kasten74935e42013-12-19 08:56:45 -08001443 size_t temp = frameCount; // temp may be replaced by a revised value of frameCount,
1444 // but we will still need the original value also
Glenn Kastend848eb42016-03-08 13:42:11 -08001445 audio_session_t originalSessionId = mSessionId;
Eric Laurente83b55d2014-11-14 10:06:21 -08001446 sp<IAudioTrack> track = audioFlinger->createTrack(streamType,
Glenn Kasten363fb752014-01-15 12:27:31 -08001447 mSampleRate,
Andy Hungabdb9902015-01-12 15:08:22 -08001448 mFormat,
Glenn Kastena42ff002012-11-14 12:47:55 -08001449 mChannelMask,
Glenn Kasten74935e42013-12-19 08:56:45 -08001450 &temp,
Eric Laurent05067782016-06-01 18:27:28 -07001451 &flags,
Glenn Kasten363fb752014-01-15 12:27:31 -08001452 mSharedBuffer,
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001453 output,
Haynes Mathew George9ea77cd2016-04-06 17:07:48 -07001454 mClientPid,
Glenn Kasten3acbd052012-02-28 10:39:56 -08001455 tid,
Eric Laurentbe916aa2010-06-01 23:49:17 -07001456 &mSessionId,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001457 mClientUid,
Eric Laurent20b9ef02016-12-05 11:03:16 -08001458 &status,
1459 mPortId);
Glenn Kasten138d6f92015-03-20 10:54:51 -07001460 ALOGE_IF(originalSessionId != AUDIO_SESSION_ALLOCATE && mSessionId != originalSessionId,
1461 "session ID changed from %d to %d", originalSessionId, mSessionId);
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001462
Glenn Kastenc08d20b2014-02-24 15:21:10 -08001463 if (status != NO_ERROR) {
Steve Block29357bc2012-01-06 19:20:56 +00001464 ALOGE("AudioFlinger could not create track, status: %d", status);
Glenn Kasten38e905b2014-01-13 10:21:48 -08001465 goto release;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001466 }
Glenn Kastenc08d20b2014-02-24 15:21:10 -08001467 ALOG_ASSERT(track != 0);
1468
Glenn Kasten38e905b2014-01-13 10:21:48 -08001469 // AudioFlinger now owns the reference to the I/O handle,
1470 // so we are no longer responsible for releasing it.
1471
Glenn Kasten7fd04222016-02-02 12:38:16 -08001472 // FIXME compare to AudioRecord
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001473 sp<IMemory> iMem = track->getCblk();
1474 if (iMem == 0) {
Steve Block29357bc2012-01-06 19:20:56 +00001475 ALOGE("Could not get control block");
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001476 return NO_INIT;
1477 }
Glenn Kasten0cde0762014-01-16 15:06:36 -08001478 void *iMemPointer = iMem->pointer();
1479 if (iMemPointer == NULL) {
1480 ALOGE("Could not get control block pointer");
1481 return NO_INIT;
1482 }
Glenn Kasten53cec222013-08-29 09:01:02 -07001483 // invariant that mAudioTrack != 0 is true only after set() returns successfully
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001484 if (mAudioTrack != 0) {
Marco Nelissenf8880202014-11-14 07:58:25 -08001485 IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001486 mDeathNotifier.clear();
1487 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001488 mAudioTrack = track;
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001489 mCblkMemory = iMem;
Eric Laurent3bcffa12014-06-12 18:38:45 -07001490 IPCThreadState::self()->flushCommands();
1491
Glenn Kasten0cde0762014-01-16 15:06:36 -08001492 audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMemPointer);
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001493 mCblk = cblk;
Glenn Kasten74935e42013-12-19 08:56:45 -08001494 // note that temp is the (possibly revised) value of frameCount
Glenn Kastenb6037442012-11-14 13:42:25 -08001495 if (temp < frameCount || (frameCount == 0 && temp == 0)) {
1496 // In current design, AudioTrack client checks and ensures frame count validity before
1497 // passing it to AudioFlinger so AudioFlinger should not return a different value except
1498 // for fast track as it uses a special method of assigning frame count.
Mark Salyzyn34fb2962014-06-18 16:30:56 -07001499 ALOGW("Requested frameCount %zu but received frameCount %zu", frameCount, temp);
Glenn Kastenb6037442012-11-14 13:42:25 -08001500 }
1501 frameCount = temp;
Glenn Kasten5f631512014-02-24 15:16:07 -08001502
Glenn Kastena07f17c2013-04-23 12:39:37 -07001503 mAwaitBoost = false;
Glenn Kasten363fb752014-01-15 12:27:31 -08001504 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
Eric Laurent05067782016-06-01 18:27:28 -07001505 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Glenn Kasten6d8018f2017-02-21 13:05:56 -08001506 ALOGI("AUDIO_OUTPUT_FLAG_FAST successful; frameCount %zu -> %zu", frameCount, temp);
Phil Burk33ff89b2015-11-30 11:16:01 -08001507 if (!mThreadCanCallJava) {
1508 mAwaitBoost = true;
1509 }
Glenn Kasten3acbd052012-02-28 10:39:56 -08001510 } else {
Glenn Kasten6d8018f2017-02-21 13:05:56 -08001511 ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %zu -> %zu", frameCount,
1512 temp);
Glenn Kastene0fa4672012-04-24 14:35:14 -07001513 }
Glenn Kasten3acbd052012-02-28 10:39:56 -08001514 }
Eric Laurent05067782016-06-01 18:27:28 -07001515 mFlags = flags;
Glenn Kasten7fd04222016-02-02 12:38:16 -08001516
1517 // Make sure that application is notified with sufficient margin before underrun.
Glenn Kastenea38ee72016-04-18 11:08:01 -07001518 // The client can divide the AudioTrack buffer into sub-buffers,
1519 // and expresses its desire to server as the notification frame count.
Andy Hung0e48d252015-01-26 11:43:15 -08001520 if (mSharedBuffer == 0 && audio_is_linear_pcm(mFormat)) {
Glenn Kastenea38ee72016-04-18 11:08:01 -07001521 size_t maxNotificationFrames;
Eric Laurent05067782016-06-01 18:27:28 -07001522 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
Glenn Kastenea38ee72016-04-18 11:08:01 -07001523 // notify every HAL buffer, regardless of the size of the track buffer
1524 maxNotificationFrames = afFrameCountHAL;
1525 } else {
Glenn Kastenaebe9dc2016-05-02 14:38:21 -07001526 // For normal tracks, use at least double-buffering if no sample rate conversion,
1527 // or at least triple-buffering if there is sample rate conversion
1528 const int nBuffering = mOriginalSampleRate == mAfSampleRate ? 2 : 3;
Glenn Kastenea38ee72016-04-18 11:08:01 -07001529 maxNotificationFrames = frameCount / nBuffering;
Glenn Kasten7fd04222016-02-02 12:38:16 -08001530 }
1531 if (mNotificationFramesAct == 0 || mNotificationFramesAct > maxNotificationFrames) {
Glenn Kastenea38ee72016-04-18 11:08:01 -07001532 if (mNotificationFramesAct == 0) {
1533 ALOGD("Client defaulted notificationFrames to %zu for frameCount %zu",
1534 maxNotificationFrames, frameCount);
1535 } else {
1536 ALOGW("Client adjusted notificationFrames from %u to %zu for frameCount %zu",
Glenn Kasten7fd04222016-02-02 12:38:16 -08001537 mNotificationFramesAct, maxNotificationFrames, frameCount);
Glenn Kastenea38ee72016-04-18 11:08:01 -07001538 }
Glenn Kasten7fd04222016-02-02 12:38:16 -08001539 mNotificationFramesAct = (uint32_t) maxNotificationFrames;
Andy Hung0e48d252015-01-26 11:43:15 -08001540 }
1541 }
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001542
Glenn Kasten38e905b2014-01-13 10:21:48 -08001543 // We retain a copy of the I/O handle, but don't own the reference
1544 mOutput = output;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001545 mRefreshRemaining = true;
1546
1547 // Starting address of buffers in shared memory. If there is a shared buffer, buffers
1548 // is the value of pointer() for the shared buffer, otherwise buffers points
1549 // immediately after the control block. This address is for the mapping within client
1550 // address space. AudioFlinger::TrackBase::mBuffer is for the server address space.
1551 void* buffers;
Glenn Kasten363fb752014-01-15 12:27:31 -08001552 if (mSharedBuffer == 0) {
Glenn Kasten138d6f92015-03-20 10:54:51 -07001553 buffers = cblk + 1;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001554 } else {
Glenn Kasten363fb752014-01-15 12:27:31 -08001555 buffers = mSharedBuffer->pointer();
Glenn Kasten138d6f92015-03-20 10:54:51 -07001556 if (buffers == NULL) {
1557 ALOGE("Could not get buffer pointer");
1558 return NO_INIT;
1559 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001560 }
1561
Eric Laurent2beeb502010-07-16 07:43:46 -07001562 mAudioTrack->attachAuxEffect(mAuxEffectId);
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07001563 updateLatency_l(); // this refetches mAfLatency and sets mLatency
Glenn Kasten5f631512014-02-24 15:16:07 -08001564
Glenn Kastenb6037442012-11-14 13:42:25 -08001565 mFrameCount = frameCount;
Glenn Kasten093000f2012-05-03 09:35:36 -07001566 // If IAudioTrack is re-created, don't let the requested frameCount
1567 // decrease. This can confuse clients that cache frameCount().
Glenn Kastenb6037442012-11-14 13:42:25 -08001568 if (frameCount > mReqFrameCount) {
1569 mReqFrameCount = frameCount;
Glenn Kasten093000f2012-05-03 09:35:36 -07001570 }
Glenn Kastene3aa6592012-12-04 12:22:46 -08001571
Andy Hungd7bd69e2015-07-24 07:52:41 -07001572 // reset server position to 0 as we have new cblk.
1573 mServer = 0;
1574
Glenn Kastene3aa6592012-12-04 12:22:46 -08001575 // update proxy
Glenn Kasten363fb752014-01-15 12:27:31 -08001576 if (mSharedBuffer == 0) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001577 mStaticProxy.clear();
Andy Hungabdb9902015-01-12 15:08:22 -08001578 mProxy = new AudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001579 } else {
Andy Hungabdb9902015-01-12 15:08:22 -08001580 mStaticProxy = new StaticAudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001581 mProxy = mStaticProxy;
1582 }
seunghak.hane6a9d6582014-11-22 15:22:35 +09001583
1584 mProxy->setVolumeLR(gain_minifloat_pack(
1585 gain_from_float(mVolume[AUDIO_INTERLEAVE_LEFT]),
1586 gain_from_float(mVolume[AUDIO_INTERLEAVE_RIGHT])));
1587
Glenn Kastene3aa6592012-12-04 12:22:46 -08001588 mProxy->setSendLevel(mSendLevel);
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001589 const uint32_t effectiveSampleRate = adjustSampleRate(mSampleRate, mPlaybackRate.mPitch);
1590 const float effectiveSpeed = adjustSpeed(mPlaybackRate.mSpeed, mPlaybackRate.mPitch);
1591 const float effectivePitch = adjustPitch(mPlaybackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -07001592 mProxy->setSampleRate(effectiveSampleRate);
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001593
1594 AudioPlaybackRate playbackRateTemp = mPlaybackRate;
1595 playbackRateTemp.mSpeed = effectiveSpeed;
1596 playbackRateTemp.mPitch = effectivePitch;
1597 mProxy->setPlaybackRate(playbackRateTemp);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001598 mProxy->setMinimum(mNotificationFramesAct);
1599
1600 mDeathNotifier = new DeathNotifier(this);
Marco Nelissenf8880202014-11-14 07:58:25 -08001601 IInterface::asBinder(mAudioTrack)->linkToDeath(mDeathNotifier, this);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001602
Eric Laurent296fb132015-05-01 11:38:42 -07001603 if (mDeviceCallback != 0) {
1604 AudioSystem::addAudioDeviceCallback(mDeviceCallback, mOutput);
1605 }
1606
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001607 return NO_ERROR;
Glenn Kasten38e905b2014-01-13 10:21:48 -08001608 }
1609
1610release:
Glenn Kastend848eb42016-03-08 13:42:11 -08001611 AudioSystem::releaseOutput(output, streamType, mSessionId);
Glenn Kasten38e905b2014-01-13 10:21:48 -08001612 if (status == NO_ERROR) {
1613 status = NO_INIT;
1614 }
1615 return status;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001616}
1617
Glenn Kastenb46f3942015-03-09 12:00:30 -07001618status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount, size_t *nonContig)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001619{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001620 if (audioBuffer == NULL) {
Glenn Kasten551b5352015-03-20 11:30:28 -07001621 if (nonContig != NULL) {
1622 *nonContig = 0;
1623 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001624 return BAD_VALUE;
Eric Laurent9b7d9502011-03-21 11:49:00 -07001625 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001626 if (mTransfer != TRANSFER_OBTAIN) {
1627 audioBuffer->frameCount = 0;
1628 audioBuffer->size = 0;
1629 audioBuffer->raw = NULL;
Glenn Kasten551b5352015-03-20 11:30:28 -07001630 if (nonContig != NULL) {
1631 *nonContig = 0;
1632 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001633 return INVALID_OPERATION;
1634 }
Eric Laurent9b7d9502011-03-21 11:49:00 -07001635
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001636 const struct timespec *requested;
Eric Laurentdf576992014-01-27 18:13:39 -08001637 struct timespec timeout;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001638 if (waitCount == -1) {
1639 requested = &ClientProxy::kForever;
1640 } else if (waitCount == 0) {
1641 requested = &ClientProxy::kNonBlocking;
1642 } else if (waitCount > 0) {
1643 long long ms = WAIT_PERIOD_MS * (long long) waitCount;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001644 timeout.tv_sec = ms / 1000;
1645 timeout.tv_nsec = (int) (ms % 1000) * 1000000;
1646 requested = &timeout;
1647 } else {
1648 ALOGE("%s invalid waitCount %d", __func__, waitCount);
1649 requested = NULL;
1650 }
Glenn Kastenb46f3942015-03-09 12:00:30 -07001651 return obtainBuffer(audioBuffer, requested, NULL /*elapsed*/, nonContig);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001652}
Eric Laurent1703cdf2011-03-07 14:52:59 -08001653
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001654status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, const struct timespec *requested,
1655 struct timespec *elapsed, size_t *nonContig)
1656{
1657 // previous and new IAudioTrack sequence numbers are used to detect track re-creation
1658 uint32_t oldSequence = 0;
1659 uint32_t newSequence;
1660
1661 Proxy::Buffer buffer;
1662 status_t status = NO_ERROR;
1663
1664 static const int32_t kMaxTries = 5;
1665 int32_t tryCounter = kMaxTries;
1666
1667 do {
1668 // obtainBuffer() is called with mutex unlocked, so keep extra references to these fields to
1669 // keep them from going away if another thread re-creates the track during obtainBuffer()
1670 sp<AudioTrackClientProxy> proxy;
1671 sp<IMemory> iMem;
1672
1673 { // start of lock scope
1674 AutoMutex lock(mLock);
1675
1676 newSequence = mSequence;
1677 // did previous obtainBuffer() fail due to media server death or voluntary invalidation?
1678 if (status == DEAD_OBJECT) {
1679 // re-create track, unless someone else has already done so
1680 if (newSequence == oldSequence) {
1681 status = restoreTrack_l("obtainBuffer");
1682 if (status != NO_ERROR) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001683 buffer.mFrameCount = 0;
1684 buffer.mRaw = NULL;
1685 buffer.mNonContig = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001686 break;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001687 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001688 }
1689 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001690 oldSequence = newSequence;
1691
Eric Laurent4d231dc2016-03-11 18:38:23 -08001692 if (status == NOT_ENOUGH_DATA) {
1693 restartIfDisabled();
1694 }
1695
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001696 // Keep the extra references
1697 proxy = mProxy;
1698 iMem = mCblkMemory;
1699
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001700 if (mState == STATE_STOPPING) {
1701 status = -EINTR;
1702 buffer.mFrameCount = 0;
1703 buffer.mRaw = NULL;
1704 buffer.mNonContig = 0;
1705 break;
1706 }
1707
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001708 // Non-blocking if track is stopped or paused
1709 if (mState != STATE_ACTIVE) {
1710 requested = &ClientProxy::kNonBlocking;
1711 }
1712
1713 } // end of lock scope
1714
1715 buffer.mFrameCount = audioBuffer->frameCount;
1716 // FIXME starts the requested timeout and elapsed over from scratch
1717 status = proxy->obtainBuffer(&buffer, requested, elapsed);
Eric Laurent4d231dc2016-03-11 18:38:23 -08001718 } while (((status == DEAD_OBJECT) || (status == NOT_ENOUGH_DATA)) && (tryCounter-- > 0));
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001719
1720 audioBuffer->frameCount = buffer.mFrameCount;
Andy Hungabdb9902015-01-12 15:08:22 -08001721 audioBuffer->size = buffer.mFrameCount * mFrameSize;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001722 audioBuffer->raw = buffer.mRaw;
1723 if (nonContig != NULL) {
1724 *nonContig = buffer.mNonContig;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001725 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001726 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001727}
1728
Glenn Kasten54a8a452015-03-09 12:03:00 -07001729void AudioTrack::releaseBuffer(const Buffer* audioBuffer)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001730{
Glenn Kasten3f02be22015-03-09 11:59:04 -07001731 // FIXME add error checking on mode, by adding an internal version
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001732 if (mTransfer == TRANSFER_SHARED) {
1733 return;
1734 }
1735
Andy Hungabdb9902015-01-12 15:08:22 -08001736 size_t stepCount = audioBuffer->size / mFrameSize;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001737 if (stepCount == 0) {
1738 return;
1739 }
1740
1741 Proxy::Buffer buffer;
1742 buffer.mFrameCount = stepCount;
1743 buffer.mRaw = audioBuffer->raw;
Glenn Kastene3aa6592012-12-04 12:22:46 -08001744
Eric Laurent1703cdf2011-03-07 14:52:59 -08001745 AutoMutex lock(mLock);
Glenn Kasten200092b2014-08-15 15:13:30 -07001746 mReleased += stepCount;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001747 mInUnderrun = false;
1748 mProxy->releaseBuffer(&buffer);
1749
1750 // restart track if it was disabled by audioflinger due to previous underrun
Eric Laurent4d231dc2016-03-11 18:38:23 -08001751 restartIfDisabled();
1752}
1753
1754void AudioTrack::restartIfDisabled()
1755{
1756 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
1757 if ((mState == STATE_ACTIVE) && (flags & CBLK_DISABLED)) {
1758 ALOGW("releaseBuffer() track %p disabled due to previous underrun, restarting", this);
1759 // FIXME ignoring status
1760 mAudioTrack->start();
Eric Laurentdf839842012-05-31 14:27:14 -07001761 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001762}
1763
1764// -------------------------------------------------------------------------
1765
Jean-Michel Trivi720ad9d2014-02-04 11:00:59 -08001766ssize_t AudioTrack::write(const void* buffer, size_t userSize, bool blocking)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001767{
Glenn Kastend79072e2016-01-06 08:41:20 -08001768 if (mTransfer != TRANSFER_SYNC) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001769 return INVALID_OPERATION;
1770 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001771
Eric Laurentab5cdba2014-06-09 17:22:27 -07001772 if (isDirect()) {
1773 AutoMutex lock(mLock);
1774 int32_t flags = android_atomic_and(
1775 ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END),
1776 &mCblk->mFlags);
1777 if (flags & CBLK_INVALID) {
1778 return DEAD_OBJECT;
1779 }
1780 }
1781
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001782 if (ssize_t(userSize) < 0 || (buffer == NULL && userSize != 0)) {
Glenn Kasten99e53b82012-01-19 08:59:58 -08001783 // Sanity-check: user is most-likely passing an error code, and it would
1784 // make the return value ambiguous (actualSize vs error).
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001785 ALOGE("AudioTrack::write(buffer=%p, size=%zu (%zd)", buffer, userSize, userSize);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001786 return BAD_VALUE;
1787 }
1788
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001789 size_t written = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001790 Buffer audioBuffer;
1791
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001792 while (userSize >= mFrameSize) {
1793 audioBuffer.frameCount = userSize / mFrameSize;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001794
Jean-Michel Trivi720ad9d2014-02-04 11:00:59 -08001795 status_t err = obtainBuffer(&audioBuffer,
1796 blocking ? &ClientProxy::kForever : &ClientProxy::kNonBlocking);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001797 if (err < 0) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001798 if (written > 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001799 break;
Glenn Kastend65d73c2012-06-22 17:21:07 -07001800 }
Glenn Kasten0a2f1512016-07-22 08:06:37 -07001801 if (err == TIMED_OUT || err == -EINTR) {
1802 err = WOULD_BLOCK;
1803 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001804 return ssize_t(err);
1805 }
1806
Glenn Kastenae4b8792015-03-20 09:04:21 -07001807 size_t toWrite = audioBuffer.size;
Andy Hungabdb9902015-01-12 15:08:22 -08001808 memcpy(audioBuffer.i8, buffer, toWrite);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001809 buffer = ((const char *) buffer) + toWrite;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001810 userSize -= toWrite;
1811 written += toWrite;
1812
1813 releaseBuffer(&audioBuffer);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001814 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001815
Andy Hungea2b9c02016-02-12 17:06:53 -08001816 if (written > 0) {
1817 mFramesWritten += written / mFrameSize;
1818 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001819 return written;
1820}
1821
1822// -------------------------------------------------------------------------
1823
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08001824nsecs_t AudioTrack::processAudioBuffer()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001825{
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001826 // Currently the AudioTrack thread is not created if there are no callbacks.
1827 // Would it ever make sense to run the thread, even without callbacks?
1828 // If so, then replace this by checks at each use for mCbf != NULL.
1829 LOG_ALWAYS_FATAL_IF(mCblk == NULL);
1830
Eric Laurent1703cdf2011-03-07 14:52:59 -08001831 mLock.lock();
Glenn Kastena07f17c2013-04-23 12:39:37 -07001832 if (mAwaitBoost) {
1833 mAwaitBoost = false;
1834 mLock.unlock();
1835 static const int32_t kMaxTries = 5;
1836 int32_t tryCounter = kMaxTries;
1837 uint32_t pollUs = 10000;
1838 do {
Glenn Kasten8255ba72016-08-23 13:54:23 -07001839 int policy = sched_getscheduler(0) & ~SCHED_RESET_ON_FORK;
Glenn Kastena07f17c2013-04-23 12:39:37 -07001840 if (policy == SCHED_FIFO || policy == SCHED_RR) {
1841 break;
1842 }
1843 usleep(pollUs);
1844 pollUs <<= 1;
1845 } while (tryCounter-- > 0);
1846 if (tryCounter < 0) {
1847 ALOGE("did not receive expected priority boost on time");
1848 }
Glenn Kastenb0dfd462013-07-10 16:52:47 -07001849 // Run again immediately
1850 return 0;
Glenn Kastena07f17c2013-04-23 12:39:37 -07001851 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08001852
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001853 // Can only reference mCblk while locked
1854 int32_t flags = android_atomic_and(
Glenn Kasten96f60d82013-07-12 10:21:18 -07001855 ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END), &mCblk->mFlags);
Glenn Kastena47f3162012-11-07 10:13:08 -08001856
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001857 // Check for track invalidation
1858 if (flags & CBLK_INVALID) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001859 // for offloaded tracks restoreTrack_l() will just update the sequence and clear
1860 // AudioSystem cache. We should not exit here but after calling the callback so
1861 // that the upper layers can recreate the track
Eric Laurentab5cdba2014-06-09 17:22:27 -07001862 if (!isOffloadedOrDirect_l() || (mSequence == mObservedSequence)) {
Lajos Molnarf1063e22015-04-17 15:19:42 -07001863 status_t status __unused = restoreTrack_l("processAudioBuffer");
1864 // FIXME unused status
Andy Hung53c3b5f2014-12-15 16:42:05 -08001865 // after restoration, continue below to make sure that the loop and buffer events
1866 // are notified because they have been cleared from mCblk->mFlags above.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001867 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001868 }
1869
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001870 bool waitStreamEnd = mState == STATE_STOPPING;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001871 bool active = mState == STATE_ACTIVE;
1872
1873 // Manage underrun callback, must be done under lock to avoid race with releaseBuffer()
1874 bool newUnderrun = false;
1875 if (flags & CBLK_UNDERRUN) {
1876#if 0
1877 // Currently in shared buffer mode, when the server reaches the end of buffer,
1878 // the track stays active in continuous underrun state. It's up to the application
1879 // to pause or stop the track, or set the position to a new offset within buffer.
1880 // This was some experimental code to auto-pause on underrun. Keeping it here
1881 // in "if 0" so we can re-visit this if we add a real sequencer for shared memory content.
1882 if (mTransfer == TRANSFER_SHARED) {
1883 mState = STATE_PAUSED;
1884 active = false;
1885 }
1886#endif
1887 if (!mInUnderrun) {
1888 mInUnderrun = true;
1889 newUnderrun = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001890 }
1891 }
Eric Laurentc2f1f072009-07-17 12:17:14 -07001892
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001893 // Get current position of server
Andy Hung90e8a972015-11-09 16:42:40 -08001894 Modulo<uint32_t> position(updateAndGetPosition_l());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001895
1896 // Manage marker callback
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001897 bool markerReached = false;
Andy Hung90e8a972015-11-09 16:42:40 -08001898 Modulo<uint32_t> markerPosition(mMarkerPosition);
1899 // uses 32 bit wraparound for comparison with position.
1900 if (!mMarkerReached && markerPosition.value() > 0 && position >= markerPosition) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001901 mMarkerReached = markerReached = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001902 }
1903
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001904 // Determine number of new position callback(s) that will be needed, while locked
1905 size_t newPosCount = 0;
Andy Hung90e8a972015-11-09 16:42:40 -08001906 Modulo<uint32_t> newPosition(mNewPosition);
1907 uint32_t updatePeriod = mUpdatePeriod;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001908 // FIXME fails for wraparound, need 64 bits
1909 if (updatePeriod > 0 && position >= newPosition) {
Andy Hung90e8a972015-11-09 16:42:40 -08001910 newPosCount = ((position - newPosition).value() / updatePeriod) + 1;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001911 mNewPosition += updatePeriod * newPosCount;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001912 }
1913
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001914 // Cache other fields that will be needed soon
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001915 uint32_t sampleRate = mSampleRate;
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001916 float speed = mPlaybackRate.mSpeed;
Andy Hunga7f03352015-05-31 21:54:49 -07001917 const uint32_t notificationFrames = mNotificationFramesAct;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001918 if (mRefreshRemaining) {
1919 mRefreshRemaining = false;
1920 mRemainingFrames = notificationFrames;
1921 mRetryOnPartialBuffer = false;
1922 }
1923 size_t misalignment = mProxy->getMisalignment();
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001924 uint32_t sequence = mSequence;
Glenn Kasten96f04882013-09-20 09:28:56 -07001925 sp<AudioTrackClientProxy> proxy = mProxy;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001926
Andy Hung53c3b5f2014-12-15 16:42:05 -08001927 // Determine the number of new loop callback(s) that will be needed, while locked.
1928 int loopCountNotifications = 0;
1929 uint32_t loopPeriod = 0; // time in frames for next EVENT_LOOP_END or EVENT_BUFFER_END
1930
1931 if (mLoopCount > 0) {
1932 int loopCount;
1933 size_t bufferPosition;
1934 mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount);
1935 loopPeriod = ((loopCount > 0) ? mLoopEnd : mFrameCount) - bufferPosition;
1936 loopCountNotifications = min(mLoopCountNotified - loopCount, kMaxLoopCountNotifications);
1937 mLoopCountNotified = loopCount; // discard any excess notifications
1938 } else if (mLoopCount < 0) {
1939 // FIXME: We're not accurate with notification count and position with infinite looping
1940 // since loopCount from server side will always return -1 (we could decrement it).
1941 size_t bufferPosition = mStaticProxy->getBufferPosition();
1942 loopCountNotifications = int((flags & (CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL)) != 0);
1943 loopPeriod = mLoopEnd - bufferPosition;
1944 } else if (/* mLoopCount == 0 && */ mSharedBuffer != 0) {
1945 size_t bufferPosition = mStaticProxy->getBufferPosition();
1946 loopPeriod = mFrameCount - bufferPosition;
1947 }
1948
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001949 // These fields don't need to be cached, because they are assigned only by set():
Andy Hungabdb9902015-01-12 15:08:22 -08001950 // mTransfer, mCbf, mUserData, mFormat, mFrameSize, mFlags
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001951 // mFlags is also assigned by createTrack_l(), but not the bit we care about.
1952
1953 mLock.unlock();
1954
Andy Hunga7f03352015-05-31 21:54:49 -07001955 // get anchor time to account for callbacks.
1956 const nsecs_t timeBeforeCallbacks = systemTime();
1957
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001958 if (waitStreamEnd) {
Andy Hunga7f03352015-05-31 21:54:49 -07001959 // FIXME: Instead of blocking in proxy->waitStreamEndDone(), Callback thread
1960 // should wait on proxy futex and handle CBLK_STREAM_END_DONE within this function
1961 // (and make sure we don't callback for more data while we're stopping).
1962 // This helps with position, marker notifications, and track invalidation.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001963 struct timespec timeout;
1964 timeout.tv_sec = WAIT_STREAM_END_TIMEOUT_SEC;
1965 timeout.tv_nsec = 0;
1966
Glenn Kasten96f04882013-09-20 09:28:56 -07001967 status_t status = proxy->waitStreamEndDone(&timeout);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001968 switch (status) {
1969 case NO_ERROR:
1970 case DEAD_OBJECT:
1971 case TIMED_OUT:
Andy Hung39609a02015-09-03 16:38:38 -07001972 if (status != DEAD_OBJECT) {
1973 // for DEAD_OBJECT, we do not send a EVENT_STREAM_END after stop();
1974 // instead, the application should handle the EVENT_NEW_IAUDIOTRACK.
1975 mCbf(EVENT_STREAM_END, mUserData, NULL);
1976 }
Glenn Kasten96f04882013-09-20 09:28:56 -07001977 {
1978 AutoMutex lock(mLock);
1979 // The previously assigned value of waitStreamEnd is no longer valid,
1980 // since the mutex has been unlocked and either the callback handler
1981 // or another thread could have re-started the AudioTrack during that time.
1982 waitStreamEnd = mState == STATE_STOPPING;
1983 if (waitStreamEnd) {
1984 mState = STATE_STOPPED;
Andy Hungc2813e52014-10-16 17:54:34 -07001985 mReleased = 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001986 }
1987 }
Glenn Kasten96f04882013-09-20 09:28:56 -07001988 if (waitStreamEnd && status != DEAD_OBJECT) {
1989 return NS_INACTIVE;
1990 }
1991 break;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001992 }
Glenn Kasten96f04882013-09-20 09:28:56 -07001993 return 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001994 }
1995
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001996 // perform callbacks while unlocked
1997 if (newUnderrun) {
1998 mCbf(EVENT_UNDERRUN, mUserData, NULL);
1999 }
Andy Hung53c3b5f2014-12-15 16:42:05 -08002000 while (loopCountNotifications > 0) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002001 mCbf(EVENT_LOOP_END, mUserData, NULL);
Andy Hung53c3b5f2014-12-15 16:42:05 -08002002 --loopCountNotifications;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002003 }
2004 if (flags & CBLK_BUFFER_END) {
2005 mCbf(EVENT_BUFFER_END, mUserData, NULL);
2006 }
2007 if (markerReached) {
2008 mCbf(EVENT_MARKER, mUserData, &markerPosition);
2009 }
2010 while (newPosCount > 0) {
Andy Hung90e8a972015-11-09 16:42:40 -08002011 size_t temp = newPosition.value(); // FIXME size_t != uint32_t
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002012 mCbf(EVENT_NEW_POS, mUserData, &temp);
2013 newPosition += updatePeriod;
2014 newPosCount--;
2015 }
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002016
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002017 if (mObservedSequence != sequence) {
2018 mObservedSequence = sequence;
2019 mCbf(EVENT_NEW_IAUDIOTRACK, mUserData, NULL);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002020 // for offloaded tracks, just wait for the upper layers to recreate the track
Eric Laurentab5cdba2014-06-09 17:22:27 -07002021 if (isOffloadedOrDirect()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002022 return NS_INACTIVE;
2023 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002024 }
2025
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002026 // if inactive, then don't run me again until re-started
2027 if (!active) {
2028 return NS_INACTIVE;
Eric Laurent2267ba12011-09-07 11:13:23 -07002029 }
2030
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002031 // Compute the estimated time until the next timed event (position, markers, loops)
2032 // FIXME only for non-compressed audio
2033 uint32_t minFrames = ~0;
2034 if (!markerReached && position < markerPosition) {
Andy Hung90e8a972015-11-09 16:42:40 -08002035 minFrames = (markerPosition - position).value();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002036 }
2037 if (loopPeriod > 0 && loopPeriod < minFrames) {
Andy Hung2d85f092015-01-07 12:45:13 -08002038 // loopPeriod is already adjusted for actual position.
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002039 minFrames = loopPeriod;
2040 }
Andy Hung2d85f092015-01-07 12:45:13 -08002041 if (updatePeriod > 0) {
Andy Hung90e8a972015-11-09 16:42:40 -08002042 minFrames = min(minFrames, (newPosition - position).value());
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002043 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002044
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002045 // If > 0, poll periodically to recover from a stuck server. A good value is 2.
2046 static const uint32_t kPoll = 0;
2047 if (kPoll > 0 && mTransfer == TRANSFER_CALLBACK && kPoll * notificationFrames < minFrames) {
2048 minFrames = kPoll * notificationFrames;
2049 }
Eric Laurentc2f1f072009-07-17 12:17:14 -07002050
Andy Hunga7f03352015-05-31 21:54:49 -07002051 // This "fudge factor" avoids soaking CPU, and compensates for late progress by server
2052 static const nsecs_t kWaitPeriodNs = WAIT_PERIOD_MS * 1000000LL;
2053 const nsecs_t timeAfterCallbacks = systemTime();
2054
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002055 // Convert frame units to time units
2056 nsecs_t ns = NS_WHENEVER;
2057 if (minFrames != (uint32_t) ~0) {
Andy Hunga7f03352015-05-31 21:54:49 -07002058 ns = framesToNanoseconds(minFrames, sampleRate, speed) + kWaitPeriodNs;
2059 ns -= (timeAfterCallbacks - timeBeforeCallbacks); // account for callback time
2060 // TODO: Should we warn if the callback time is too long?
2061 if (ns < 0) ns = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002062 }
2063
2064 // If not supplying data by EVENT_MORE_DATA, then we're done
2065 if (mTransfer != TRANSFER_CALLBACK) {
2066 return ns;
2067 }
2068
Andy Hunga7f03352015-05-31 21:54:49 -07002069 // EVENT_MORE_DATA callback handling.
2070 // Timing for linear pcm audio data formats can be derived directly from the
2071 // buffer fill level.
2072 // Timing for compressed data is not directly available from the buffer fill level,
2073 // rather indirectly from waiting for blocking mode callbacks or waiting for obtain()
2074 // to return a certain fill level.
2075
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002076 struct timespec timeout;
2077 const struct timespec *requested = &ClientProxy::kForever;
2078 if (ns != NS_WHENEVER) {
2079 timeout.tv_sec = ns / 1000000000LL;
2080 timeout.tv_nsec = ns % 1000000000LL;
2081 ALOGV("timeout %ld.%03d", timeout.tv_sec, (int) timeout.tv_nsec / 1000000);
2082 requested = &timeout;
2083 }
2084
Andy Hungea2b9c02016-02-12 17:06:53 -08002085 size_t writtenFrames = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002086 while (mRemainingFrames > 0) {
2087
2088 Buffer audioBuffer;
2089 audioBuffer.frameCount = mRemainingFrames;
2090 size_t nonContig;
2091 status_t err = obtainBuffer(&audioBuffer, requested, NULL, &nonContig);
2092 LOG_ALWAYS_FATAL_IF((err != NO_ERROR) != (audioBuffer.frameCount == 0),
Mark Salyzyn34fb2962014-06-18 16:30:56 -07002093 "obtainBuffer() err=%d frameCount=%zu", err, audioBuffer.frameCount);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002094 requested = &ClientProxy::kNonBlocking;
2095 size_t avail = audioBuffer.frameCount + nonContig;
Mark Salyzyn34fb2962014-06-18 16:30:56 -07002096 ALOGV("obtainBuffer(%u) returned %zu = %zu + %zu err %d",
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002097 mRemainingFrames, avail, audioBuffer.frameCount, nonContig, err);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002098 if (err != NO_ERROR) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002099 if (err == TIMED_OUT || err == WOULD_BLOCK || err == -EINTR ||
2100 (isOffloaded() && (err == DEAD_OBJECT))) {
Glenn Kasten606fbc12015-10-22 15:28:15 -07002101 // FIXME bug 25195759
2102 return 1000000;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002103 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002104 ALOGE("Error %d obtaining an audio buffer, giving up.", err);
2105 return NS_NEVER;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002106 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002107
Phil Burkfdb3c072016-02-09 10:47:02 -08002108 if (mRetryOnPartialBuffer && audio_has_proportional_frames(mFormat)) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002109 mRetryOnPartialBuffer = false;
2110 if (avail < mRemainingFrames) {
Andy Hunga7f03352015-05-31 21:54:49 -07002111 if (ns > 0) { // account for obtain time
2112 const nsecs_t timeNow = systemTime();
2113 ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks));
2114 }
2115 nsecs_t myns = framesToNanoseconds(mRemainingFrames - avail, sampleRate, speed);
2116 if (ns < 0 /* NS_WHENEVER */ || myns < ns) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002117 ns = myns;
2118 }
2119 return ns;
2120 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07002121 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002122
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002123 size_t reqSize = audioBuffer.size;
2124 mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002125 size_t writtenSize = audioBuffer.size;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002126
2127 // Sanity check on returned size
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002128 if (ssize_t(writtenSize) < 0 || writtenSize > reqSize) {
Mark Salyzyn34fb2962014-06-18 16:30:56 -07002129 ALOGE("EVENT_MORE_DATA requested %zu bytes but callback returned %zd bytes",
2130 reqSize, ssize_t(writtenSize));
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002131 return NS_NEVER;
2132 }
2133
2134 if (writtenSize == 0) {
The Android Open Source Project8555d082009-03-05 14:34:35 -08002135 // The callback is done filling buffers
2136 // Keep this thread going to handle timed events and
2137 // still try to get more data in intervals of WAIT_PERIOD_MS
2138 // but don't just loop and block the CPU, so wait
Andy Hunga7f03352015-05-31 21:54:49 -07002139
2140 // mCbf(EVENT_MORE_DATA, ...) might either
2141 // (1) Block until it can fill the buffer, returning 0 size on EOS.
2142 // (2) Block until it can fill the buffer, returning 0 data (silence) on EOS.
2143 // (3) Return 0 size when no data is available, does not wait for more data.
2144 //
2145 // (1) and (2) occurs with AudioPlayer/AwesomePlayer; (3) occurs with NuPlayer.
2146 // We try to compute the wait time to avoid a tight sleep-wait cycle,
2147 // especially for case (3).
2148 //
2149 // The decision to support (1) and (2) affect the sizing of mRemainingFrames
2150 // and this loop; whereas for case (3) we could simply check once with the full
2151 // buffer size and skip the loop entirely.
2152
2153 nsecs_t myns;
Phil Burkfdb3c072016-02-09 10:47:02 -08002154 if (audio_has_proportional_frames(mFormat)) {
Andy Hunga7f03352015-05-31 21:54:49 -07002155 // time to wait based on buffer occupancy
2156 const nsecs_t datans = mRemainingFrames <= avail ? 0 :
2157 framesToNanoseconds(mRemainingFrames - avail, sampleRate, speed);
2158 // audio flinger thread buffer size (TODO: adjust for fast tracks)
Glenn Kastenea38ee72016-04-18 11:08:01 -07002159 // FIXME: use mAfFrameCountHAL instead of mAfFrameCount below for fast tracks.
Andy Hunga7f03352015-05-31 21:54:49 -07002160 const nsecs_t afns = framesToNanoseconds(mAfFrameCount, mAfSampleRate, speed);
2161 // add a half the AudioFlinger buffer time to avoid soaking CPU if datans is 0.
2162 myns = datans + (afns / 2);
2163 } else {
2164 // FIXME: This could ping quite a bit if the buffer isn't full.
2165 // Note that when mState is stopping we waitStreamEnd, so it never gets here.
2166 myns = kWaitPeriodNs;
2167 }
2168 if (ns > 0) { // account for obtain and callback time
2169 const nsecs_t timeNow = systemTime();
2170 ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks));
2171 }
2172 if (ns < 0 /* NS_WHENEVER */ || myns < ns) {
2173 ns = myns;
2174 }
2175 return ns;
Glenn Kastend65d73c2012-06-22 17:21:07 -07002176 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002177
Glenn Kasten138d6f92015-03-20 10:54:51 -07002178 size_t releasedFrames = writtenSize / mFrameSize;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002179 audioBuffer.frameCount = releasedFrames;
2180 mRemainingFrames -= releasedFrames;
2181 if (misalignment >= releasedFrames) {
2182 misalignment -= releasedFrames;
2183 } else {
2184 misalignment = 0;
2185 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002186
2187 releaseBuffer(&audioBuffer);
Andy Hungea2b9c02016-02-12 17:06:53 -08002188 writtenFrames += releasedFrames;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002189
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002190 // FIXME here is where we would repeat EVENT_MORE_DATA again on same advanced buffer
2191 // if callback doesn't like to accept the full chunk
2192 if (writtenSize < reqSize) {
2193 continue;
2194 }
2195
2196 // There could be enough non-contiguous frames available to satisfy the remaining request
2197 if (mRemainingFrames <= nonContig) {
2198 continue;
2199 }
2200
2201#if 0
2202 // This heuristic tries to collapse a series of EVENT_MORE_DATA that would total to a
2203 // sum <= notificationFrames. It replaces that series by at most two EVENT_MORE_DATA
2204 // that total to a sum == notificationFrames.
2205 if (0 < misalignment && misalignment <= mRemainingFrames) {
2206 mRemainingFrames = misalignment;
Andy Hung8edb8dc2015-03-26 19:13:55 -07002207 return ((double)mRemainingFrames * 1100000000) / ((double)sampleRate * speed);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002208 }
2209#endif
2210
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002211 }
Andy Hungea2b9c02016-02-12 17:06:53 -08002212 if (writtenFrames > 0) {
2213 AutoMutex lock(mLock);
2214 mFramesWritten += writtenFrames;
2215 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002216 mRemainingFrames = notificationFrames;
2217 mRetryOnPartialBuffer = true;
2218
2219 // A lot has transpired since ns was calculated, so run again immediately and re-calculate
2220 return 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002221}
2222
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002223status_t AudioTrack::restoreTrack_l(const char *from)
Eric Laurent1703cdf2011-03-07 14:52:59 -08002224{
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002225 ALOGW("dead IAudioTrack, %s, creating a new one from %s()",
Eric Laurentab5cdba2014-06-09 17:22:27 -07002226 isOffloadedOrDirect_l() ? "Offloaded or Direct" : "PCM", from);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002227 ++mSequence;
Eric Laurent1703cdf2011-03-07 14:52:59 -08002228
Glenn Kastena47f3162012-11-07 10:13:08 -08002229 // refresh the audio configuration cache in this process to make sure we get new
Glenn Kastend2d089f2014-11-05 11:48:12 -08002230 // output parameters and new IAudioFlinger in createTrack_l()
Glenn Kastena47f3162012-11-07 10:13:08 -08002231 AudioSystem::clearAudioConfigCache();
Eric Laurent9f6530f2011-08-30 10:18:54 -07002232
Ronghua Wufaeb0f22015-05-21 12:20:21 -07002233 if (isOffloadedOrDirect_l() || mDoNotReconnect) {
Andy Hung1f1db832015-06-08 13:26:10 -07002234 // FIXME re-creation of offloaded and direct tracks is not yet implemented;
2235 // reconsider enabling for linear PCM encodings when position can be preserved.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002236 return DEAD_OBJECT;
2237 }
2238
Phil Burk2812d9e2016-01-04 10:34:30 -08002239 // Save so we can return count since creation.
2240 mUnderrunCountOffset = getUnderrunCount_l();
2241
Glenn Kasten200092b2014-08-15 15:13:30 -07002242 // save the old static buffer position
Andy Hungf20a4e92016-08-15 19:10:34 -07002243 uint32_t staticPosition = 0;
Andy Hung4ede21d2014-12-12 15:37:34 -08002244 size_t bufferPosition = 0;
2245 int loopCount = 0;
2246 if (mStaticProxy != 0) {
2247 mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount);
Andy Hungf20a4e92016-08-15 19:10:34 -07002248 staticPosition = mStaticProxy->getPosition().unsignedValue();
Andy Hung4ede21d2014-12-12 15:37:34 -08002249 }
Glenn Kasten200092b2014-08-15 15:13:30 -07002250
Haynes Mathew Georgeae34ed22016-01-28 11:58:39 -08002251 mFlags = mOrigFlags;
2252
Glenn Kasten200092b2014-08-15 15:13:30 -07002253 // If a new IAudioTrack is successfully created, createTrack_l() will modify the
Glenn Kastena47f3162012-11-07 10:13:08 -08002254 // following member variables: mAudioTrack, mCblkMemory and mCblk.
Glenn Kasten200092b2014-08-15 15:13:30 -07002255 // It will also delete the strong references on previous IAudioTrack and IMemory.
2256 // If a new IAudioTrack cannot be created, the previous (dead) instance will be left intact.
Glenn Kastenae4b8792015-03-20 09:04:21 -07002257 status_t result = createTrack_l();
Eric Laurentcc21e4f2013-10-16 15:12:32 -07002258
Glenn Kastena47f3162012-11-07 10:13:08 -08002259 if (result == NO_ERROR) {
Andy Hungd7bd69e2015-07-24 07:52:41 -07002260 // take the frames that will be lost by track recreation into account in saved position
2261 // For streaming tracks, this is the amount we obtained from the user/client
2262 // (not the number actually consumed at the server - those are already lost).
2263 if (mStaticProxy == 0) {
2264 mPosition = mReleased;
2265 }
Andy Hung4ede21d2014-12-12 15:37:34 -08002266 // Continue playback from last known position and restore loop.
2267 if (mStaticProxy != 0) {
2268 if (loopCount != 0) {
2269 mStaticProxy->setBufferPositionAndLoop(bufferPosition,
2270 mLoopStart, mLoopEnd, loopCount);
2271 } else {
2272 mStaticProxy->setBufferPosition(bufferPosition);
Andy Hung53c3b5f2014-12-15 16:42:05 -08002273 if (bufferPosition == mFrameCount) {
2274 ALOGD("restoring track at end of static buffer");
2275 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08002276 }
2277 }
Andy Hung4ef88d72017-02-21 19:47:53 -08002278 // restore volume handler
Andy Hung39399b62017-04-21 15:07:45 -07002279 mVolumeHandler->forall([this](const VolumeShaper &shaper) -> VolumeShaper::Status {
2280 sp<VolumeShaper::Operation> operationToEnd =
2281 new VolumeShaper::Operation(shaper.mOperation);
Andy Hung4ef88d72017-02-21 19:47:53 -08002282 // TODO: Ideally we would restore to the exact xOffset position
2283 // as returned by getVolumeShaperState(), but we don't have that
2284 // information when restoring at the client unless we periodically poll
2285 // the server or create shared memory state.
2286 //
Andy Hung39399b62017-04-21 15:07:45 -07002287 // For now, we simply advance to the end of the VolumeShaper effect
2288 // if it has been started.
2289 if (shaper.isStarted()) {
Andy Hungf3702642017-05-05 17:33:32 -07002290 operationToEnd->setNormalizedTime(1.f);
Andy Hung39399b62017-04-21 15:07:45 -07002291 }
2292 return mAudioTrack->applyVolumeShaper(shaper.mConfiguration, operationToEnd);
Andy Hung4ef88d72017-02-21 19:47:53 -08002293 });
2294
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002295 if (mState == STATE_ACTIVE) {
Glenn Kastena47f3162012-11-07 10:13:08 -08002296 result = mAudioTrack->start();
Eric Laurent1703cdf2011-03-07 14:52:59 -08002297 }
Andy Hungf20a4e92016-08-15 19:10:34 -07002298 // server resets to zero so we offset
2299 mFramesWrittenServerOffset =
2300 mStaticProxy.get() != nullptr ? staticPosition : mFramesWritten;
2301 mFramesWrittenAtRestore = mFramesWrittenServerOffset;
Eric Laurent1703cdf2011-03-07 14:52:59 -08002302 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002303 if (result != NO_ERROR) {
2304 ALOGW("restoreTrack_l() failed status %d", result);
2305 mState = STATE_STOPPED;
Andy Hungc2813e52014-10-16 17:54:34 -07002306 mReleased = 0;
Eric Laurent1703cdf2011-03-07 14:52:59 -08002307 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08002308
2309 return result;
2310}
2311
Andy Hung90e8a972015-11-09 16:42:40 -08002312Modulo<uint32_t> AudioTrack::updateAndGetPosition_l()
Glenn Kasten200092b2014-08-15 15:13:30 -07002313{
2314 // This is the sole place to read server consumed frames
Andy Hung90e8a972015-11-09 16:42:40 -08002315 Modulo<uint32_t> newServer(mProxy->getPosition());
2316 const int32_t delta = (newServer - mServer).signedValue();
Glenn Kasten200092b2014-08-15 15:13:30 -07002317 // TODO There is controversy about whether there can be "negative jitter" in server position.
2318 // This should be investigated further, and if possible, it should be addressed.
2319 // A more definite failure mode is infrequent polling by client.
2320 // One could call (void)getPosition_l() in releaseBuffer(),
2321 // so mReleased and mPosition are always lock-step as best possible.
2322 // That should ensure delta never goes negative for infrequent polling
2323 // unless the server has more than 2^31 frames in its buffer,
2324 // in which case the use of uint32_t for these counters has bigger issues.
Andy Hung90e8a972015-11-09 16:42:40 -08002325 ALOGE_IF(delta < 0,
2326 "detected illegal retrograde motion by the server: mServer advanced by %d",
2327 delta);
Chad Brubaker039c27a2015-09-23 15:17:29 -07002328 mServer = newServer;
Andy Hung90e8a972015-11-09 16:42:40 -08002329 if (delta > 0) { // avoid retrograde
2330 mPosition += delta;
2331 }
2332 return mPosition;
Glenn Kasten200092b2014-08-15 15:13:30 -07002333}
2334
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002335bool AudioTrack::isSampleRateSpeedAllowed_l(uint32_t sampleRate, float speed)
Andy Hung8edb8dc2015-03-26 19:13:55 -07002336{
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002337 updateLatency_l();
Andy Hung8edb8dc2015-03-26 19:13:55 -07002338 // applicable for mixing tracks only (not offloaded or direct)
2339 if (mStaticProxy != 0) {
2340 return true; // static tracks do not have issues with buffer sizing.
2341 }
Andy Hung8edb8dc2015-03-26 19:13:55 -07002342 const size_t minFrameCount =
Glenn Kastenea38ee72016-04-18 11:08:01 -07002343 calculateMinFrameCount(mAfLatency, mAfFrameCount, mAfSampleRate, sampleRate, speed
2344 /*, 0 mNotificationsPerBufferReq*/);
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002345 const bool allowed = mFrameCount >= minFrameCount;
2346 ALOGD_IF(!allowed,
2347 "isSampleRateSpeedAllowed_l denied "
2348 "mAfLatency:%u mAfFrameCount:%zu mAfSampleRate:%u sampleRate:%u speed:%f "
2349 "mFrameCount:%zu < minFrameCount:%zu",
2350 mAfLatency, mAfFrameCount, mAfSampleRate, sampleRate, speed,
Andy Hung8edb8dc2015-03-26 19:13:55 -07002351 mFrameCount, minFrameCount);
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002352 return allowed;
Andy Hung8edb8dc2015-03-26 19:13:55 -07002353}
2354
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002355status_t AudioTrack::setParameters(const String8& keyValuePairs)
2356{
2357 AutoMutex lock(mLock);
Glenn Kasten53cec222013-08-29 09:01:02 -07002358 return mAudioTrack->setParameters(keyValuePairs);
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002359}
2360
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002361VolumeShaper::Status AudioTrack::applyVolumeShaper(
2362 const sp<VolumeShaper::Configuration>& configuration,
2363 const sp<VolumeShaper::Operation>& operation)
2364{
2365 AutoMutex lock(mLock);
Andy Hung4ef88d72017-02-21 19:47:53 -08002366 mVolumeHandler->setIdIfNecessary(configuration);
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002367 VolumeShaper::Status status = mAudioTrack->applyVolumeShaper(configuration, operation);
Andy Hung39399b62017-04-21 15:07:45 -07002368
2369 if (status == DEAD_OBJECT) {
2370 if (restoreTrack_l("applyVolumeShaper") == OK) {
2371 status = mAudioTrack->applyVolumeShaper(configuration, operation);
2372 }
2373 }
Andy Hung4ef88d72017-02-21 19:47:53 -08002374 if (status >= 0) {
2375 // save VolumeShaper for restore
2376 mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hung39399b62017-04-21 15:07:45 -07002377 if (mState == STATE_ACTIVE || mState == STATE_STOPPING) {
2378 mVolumeHandler->setStarted();
2379 }
2380 } else {
2381 // warn only if not an expected restore failure.
2382 ALOGW_IF(!((isOffloadedOrDirect_l() || mDoNotReconnect) && status == DEAD_OBJECT),
2383 "applyVolumeShaper failed: %d", status);
Andy Hung4ef88d72017-02-21 19:47:53 -08002384 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002385 return status;
2386}
2387
2388sp<VolumeShaper::State> AudioTrack::getVolumeShaperState(int id)
2389{
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002390 AutoMutex lock(mLock);
Andy Hung39399b62017-04-21 15:07:45 -07002391 sp<VolumeShaper::State> state = mAudioTrack->getVolumeShaperState(id);
2392 if (state.get() == nullptr && (mCblk->mFlags & CBLK_INVALID) != 0) {
2393 if (restoreTrack_l("getVolumeShaperState") == OK) {
2394 state = mAudioTrack->getVolumeShaperState(id);
2395 }
2396 }
2397 return state;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002398}
2399
Andy Hungea2b9c02016-02-12 17:06:53 -08002400status_t AudioTrack::getTimestamp(ExtendedTimestamp *timestamp)
2401{
2402 if (timestamp == nullptr) {
2403 return BAD_VALUE;
2404 }
2405 AutoMutex lock(mLock);
Andy Hunge13f8a62016-03-30 14:20:42 -07002406 return getTimestamp_l(timestamp);
2407}
2408
2409status_t AudioTrack::getTimestamp_l(ExtendedTimestamp *timestamp)
2410{
Andy Hungea2b9c02016-02-12 17:06:53 -08002411 if (mCblk->mFlags & CBLK_INVALID) {
2412 const status_t status = restoreTrack_l("getTimestampExtended");
2413 if (status != OK) {
2414 // per getTimestamp() API doc in header, we return DEAD_OBJECT here,
2415 // recommending that the track be recreated.
2416 return DEAD_OBJECT;
2417 }
2418 }
2419 // check for offloaded/direct here in case restoring somehow changed those flags.
2420 if (isOffloadedOrDirect_l()) {
2421 return INVALID_OPERATION; // not supported
2422 }
2423 status_t status = mProxy->getTimestamp(timestamp);
Andy Hunge1e98462016-04-12 10:18:51 -07002424 LOG_ALWAYS_FATAL_IF(status != OK, "status %d not allowed from proxy getTimestamp", status);
Andy Hungea2b9c02016-02-12 17:06:53 -08002425 bool found = false;
Andy Hunge1e98462016-04-12 10:18:51 -07002426 timestamp->mPosition[ExtendedTimestamp::LOCATION_CLIENT] = mFramesWritten;
2427 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_CLIENT] = 0;
2428 // server side frame offset in case AudioTrack has been restored.
2429 for (int i = ExtendedTimestamp::LOCATION_SERVER;
2430 i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2431 if (timestamp->mTimeNs[i] >= 0) {
2432 // apply server offset (frames flushed is ignored
2433 // so we don't report the jump when the flush occurs).
2434 timestamp->mPosition[i] += mFramesWrittenServerOffset;
2435 found = true;
Andy Hungea2b9c02016-02-12 17:06:53 -08002436 }
2437 }
2438 return found ? OK : WOULD_BLOCK;
2439}
2440
Glenn Kastence703742013-07-19 16:33:58 -07002441status_t AudioTrack::getTimestamp(AudioTimestamp& timestamp)
2442{
Glenn Kasten53cec222013-08-29 09:01:02 -07002443 AutoMutex lock(mLock);
Andy Hung65ffdfc2016-10-10 15:52:11 -07002444 return getTimestamp_l(timestamp);
2445}
Phil Burk1b420972015-04-22 10:52:21 -07002446
Andy Hung65ffdfc2016-10-10 15:52:11 -07002447status_t AudioTrack::getTimestamp_l(AudioTimestamp& timestamp)
2448{
Phil Burk1b420972015-04-22 10:52:21 -07002449 bool previousTimestampValid = mPreviousTimestampValid;
2450 // Set false here to cover all the error return cases.
2451 mPreviousTimestampValid = false;
2452
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002453 switch (mState) {
2454 case STATE_ACTIVE:
2455 case STATE_PAUSED:
2456 break; // handle below
2457 case STATE_FLUSHED:
2458 case STATE_STOPPED:
2459 return WOULD_BLOCK;
2460 case STATE_STOPPING:
2461 case STATE_PAUSED_STOPPING:
2462 if (!isOffloaded_l()) {
2463 return INVALID_OPERATION;
2464 }
2465 break; // offloaded tracks handled below
2466 default:
2467 LOG_ALWAYS_FATAL("Invalid mState in getTimestamp(): %d", mState);
2468 break;
Glenn Kastenfe346c72013-08-30 13:28:22 -07002469 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002470
Eric Laurent275e8e92014-11-30 15:14:47 -08002471 if (mCblk->mFlags & CBLK_INVALID) {
Andy Hung6653c932015-06-08 13:27:48 -07002472 const status_t status = restoreTrack_l("getTimestamp");
2473 if (status != OK) {
2474 // per getTimestamp() API doc in header, we return DEAD_OBJECT here,
2475 // recommending that the track be recreated.
2476 return DEAD_OBJECT;
2477 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002478 }
2479
Glenn Kasten200092b2014-08-15 15:13:30 -07002480 // The presented frame count must always lag behind the consumed frame count.
2481 // To avoid a race, read the presented frames first. This ensures that presented <= consumed.
Andy Hung6ae58432016-02-16 18:32:24 -08002482
2483 status_t status;
Andy Hung818e7a32016-02-16 18:08:07 -08002484 if (isOffloadedOrDirect_l()) {
Andy Hung6ae58432016-02-16 18:32:24 -08002485 // use Binder to get timestamp
2486 status = mAudioTrack->getTimestamp(timestamp);
2487 } else {
2488 // read timestamp from shared memory
2489 ExtendedTimestamp ets;
2490 status = mProxy->getTimestamp(&ets);
2491 if (status == OK) {
Andy Hungb01faa32016-04-27 12:51:32 -07002492 ExtendedTimestamp::Location location;
2493 status = ets.getBestTimestamp(&timestamp, &location);
2494
2495 if (status == OK) {
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002496 updateLatency_l();
Andy Hungb01faa32016-04-27 12:51:32 -07002497 // It is possible that the best location has moved from the kernel to the server.
2498 // In this case we adjust the position from the previous computed latency.
2499 if (location == ExtendedTimestamp::LOCATION_SERVER) {
2500 ALOGW_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_KERNEL,
2501 "getTimestamp() location moved from kernel to server");
Andy Hung07eee802016-06-21 16:47:16 -07002502 // check that the last kernel OK time info exists and the positions
2503 // are valid (if they predate the current track, the positions may
2504 // be zero or negative).
Andy Hungb01faa32016-04-27 12:51:32 -07002505 const int64_t frames =
Andy Hung6d7b1192016-05-07 22:59:48 -07002506 (ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] < 0 ||
Andy Hung07eee802016-06-21 16:47:16 -07002507 ets.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] < 0 ||
2508 ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] <= 0 ||
2509 ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] <= 0)
Andy Hung6d7b1192016-05-07 22:59:48 -07002510 ?
2511 int64_t((double)mAfLatency * mSampleRate * mPlaybackRate.mSpeed
2512 / 1000)
2513 :
2514 (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK]
2515 - ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK]);
2516 ALOGV("frame adjustment:%lld timestamp:%s",
2517 (long long)frames, ets.toString().c_str());
Andy Hungb01faa32016-04-27 12:51:32 -07002518 if (frames >= ets.mPosition[location]) {
2519 timestamp.mPosition = 0;
2520 } else {
2521 timestamp.mPosition = (uint32_t)(ets.mPosition[location] - frames);
2522 }
Andy Hung69488c42016-05-16 18:43:33 -07002523 } else if (location == ExtendedTimestamp::LOCATION_KERNEL) {
2524 ALOGV_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_SERVER,
2525 "getTimestamp() location moved from server to kernel");
Andy Hungb01faa32016-04-27 12:51:32 -07002526 }
Andy Hung5d313802016-10-10 15:09:39 -07002527
2528 // We update the timestamp time even when paused.
2529 if (mState == STATE_PAUSED /* not needed: STATE_PAUSED_STOPPING */) {
2530 const int64_t now = systemTime();
2531 const int64_t at = convertTimespecToNs(timestamp.mTime);
2532 const int64_t lag =
2533 (ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] < 0 ||
2534 ets.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] < 0)
2535 ? int64_t(mAfLatency * 1000000LL)
2536 : (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK]
2537 - ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK])
2538 * NANOS_PER_SECOND / mSampleRate;
2539 const int64_t limit = now - lag; // no earlier than this limit
2540 if (at < limit) {
2541 ALOGV("timestamp pause lag:%lld adjusting from %lld to %lld",
2542 (long long)lag, (long long)at, (long long)limit);
2543 timestamp.mTime.tv_sec = limit / NANOS_PER_SECOND;
2544 timestamp.mTime.tv_nsec = limit % NANOS_PER_SECOND; // compiler opt.
2545 }
2546 }
Andy Hungb01faa32016-04-27 12:51:32 -07002547 mPreviousLocation = location;
2548 } else {
2549 // right after AudioTrack is started, one may not find a timestamp
2550 ALOGV("getBestTimestamp did not find timestamp");
2551 }
Andy Hung6ae58432016-02-16 18:32:24 -08002552 }
2553 if (status == INVALID_OPERATION) {
Andy Hungf20a4e92016-08-15 19:10:34 -07002554 // INVALID_OPERATION occurs when no timestamp has been issued by the server;
2555 // other failures are signaled by a negative time.
2556 // If we come out of FLUSHED or STOPPED where the position is known
2557 // to be zero we convert this to WOULD_BLOCK (with the implicit meaning of
2558 // "zero" for NuPlayer). We don't convert for track restoration as position
2559 // does not reset.
2560 ALOGV("timestamp server offset:%lld restore frames:%lld",
2561 (long long)mFramesWrittenServerOffset, (long long)mFramesWrittenAtRestore);
2562 if (mFramesWrittenServerOffset != mFramesWrittenAtRestore) {
2563 status = WOULD_BLOCK;
2564 }
Andy Hung6ae58432016-02-16 18:32:24 -08002565 }
2566 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002567 if (status != NO_ERROR) {
Glenn Kastendfc34da2014-09-19 09:05:05 -07002568 ALOGV_IF(status != WOULD_BLOCK, "getTimestamp error:%#x", status);
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002569 return status;
2570 }
2571 if (isOffloadedOrDirect_l()) {
2572 if (isOffloaded_l() && (mState == STATE_PAUSED || mState == STATE_PAUSED_STOPPING)) {
2573 // use cached paused position in case another offloaded track is running.
2574 timestamp.mPosition = mPausedPosition;
2575 clock_gettime(CLOCK_MONOTONIC, &timestamp.mTime);
Andy Hung5d313802016-10-10 15:09:39 -07002576 // TODO: adjust for delay
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002577 return NO_ERROR;
2578 }
2579
2580 // Check whether a pending flush or stop has completed, as those commands may
Andy Hungc8e09c62015-06-03 23:43:36 -07002581 // be asynchronous or return near finish or exhibit glitchy behavior.
2582 //
2583 // Originally this showed up as the first timestamp being a continuation of
2584 // the previous song under gapless playback.
2585 // However, we sometimes see zero timestamps, then a glitch of
2586 // the previous song's position, and then correct timestamps afterwards.
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002587 if (mStartUs != 0 && mSampleRate != 0) {
2588 static const int kTimeJitterUs = 100000; // 100 ms
2589 static const int k1SecUs = 1000000;
2590
2591 const int64_t timeNow = getNowUs();
2592
2593 if (timeNow < mStartUs + k1SecUs) { // within first second of starting
2594 const int64_t timestampTimeUs = convertTimespecToUs(timestamp.mTime);
2595 if (timestampTimeUs < mStartUs) {
2596 return WOULD_BLOCK; // stale timestamp time, occurs before start.
2597 }
2598 const int64_t deltaTimeUs = timestampTimeUs - mStartUs;
Andy Hung8edb8dc2015-03-26 19:13:55 -07002599 const int64_t deltaPositionByUs = (double)timestamp.mPosition * 1000000
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07002600 / ((double)mSampleRate * mPlaybackRate.mSpeed);
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002601
2602 if (deltaPositionByUs > deltaTimeUs + kTimeJitterUs) {
2603 // Verify that the counter can't count faster than the sample rate
Andy Hungc8e09c62015-06-03 23:43:36 -07002604 // since the start time. If greater, then that means we may have failed
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002605 // to completely flush or stop the previous playing track.
Andy Hungc8e09c62015-06-03 23:43:36 -07002606 ALOGW_IF(!mTimestampStartupGlitchReported,
2607 "getTimestamp startup glitch detected"
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002608 " deltaTimeUs(%lld) deltaPositionUs(%lld) tsmPosition(%u)",
2609 (long long)deltaTimeUs, (long long)deltaPositionByUs,
2610 timestamp.mPosition);
Andy Hungc8e09c62015-06-03 23:43:36 -07002611 mTimestampStartupGlitchReported = true;
2612 if (previousTimestampValid
2613 && mPreviousTimestamp.mPosition == 0 /* should be true if valid */) {
2614 timestamp = mPreviousTimestamp;
2615 mPreviousTimestampValid = true;
2616 return NO_ERROR;
2617 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002618 return WOULD_BLOCK;
2619 }
Andy Hungc8e09c62015-06-03 23:43:36 -07002620 if (deltaPositionByUs != 0) {
2621 mStartUs = 0; // don't check again, we got valid nonzero position.
2622 }
2623 } else {
2624 mStartUs = 0; // don't check again, start time expired.
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002625 }
Andy Hungc8e09c62015-06-03 23:43:36 -07002626 mTimestampStartupGlitchReported = false;
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002627 }
2628 } else {
Glenn Kasten200092b2014-08-15 15:13:30 -07002629 // Update the mapping between local consumed (mPosition) and server consumed (mServer)
2630 (void) updateAndGetPosition_l();
2631 // Server consumed (mServer) and presented both use the same server time base,
2632 // and server consumed is always >= presented.
2633 // The delta between these represents the number of frames in the buffer pipeline.
2634 // If this delta between these is greater than the client position, it means that
2635 // actually presented is still stuck at the starting line (figuratively speaking),
2636 // waiting for the first frame to go by. So we can't report a valid timestamp yet.
Andy Hung90e8a972015-11-09 16:42:40 -08002637 // Note: We explicitly use non-Modulo comparison here - potential wrap issue when
2638 // mPosition exceeds 32 bits.
2639 // TODO Remove when timestamp is updated to contain pipeline status info.
2640 const int32_t pipelineDepthInFrames = (mServer - timestamp.mPosition).signedValue();
2641 if (pipelineDepthInFrames > 0 /* should be true, but we check anyways */
2642 && (uint32_t)pipelineDepthInFrames > mPosition.value()) {
Glenn Kasten200092b2014-08-15 15:13:30 -07002643 return INVALID_OPERATION;
2644 }
2645 // Convert timestamp position from server time base to client time base.
2646 // TODO The following code should work OK now because timestamp.mPosition is 32-bit.
2647 // But if we change it to 64-bit then this could fail.
Andy Hung90e8a972015-11-09 16:42:40 -08002648 // Use Modulo computation here.
2649 timestamp.mPosition = (mPosition - mServer + timestamp.mPosition).value();
Glenn Kasten200092b2014-08-15 15:13:30 -07002650 // Immediately after a call to getPosition_l(), mPosition and
2651 // mServer both represent the same frame position. mPosition is
2652 // in client's point of view, and mServer is in server's point of
2653 // view. So the difference between them is the "fudge factor"
2654 // between client and server views due to stop() and/or new
2655 // IAudioTrack. And timestamp.mPosition is initially in server's
2656 // point of view, so we need to apply the same fudge factor to it.
Glenn Kastenfe346c72013-08-30 13:28:22 -07002657 }
Phil Burk1b420972015-04-22 10:52:21 -07002658
2659 // Prevent retrograde motion in timestamp.
2660 // This is sometimes caused by erratic reports of the available space in the ALSA drivers.
2661 if (status == NO_ERROR) {
2662 if (previousTimestampValid) {
Andy Hung5d313802016-10-10 15:09:39 -07002663 const int64_t previousTimeNanos = convertTimespecToNs(mPreviousTimestamp.mTime);
2664 const int64_t currentTimeNanos = convertTimespecToNs(timestamp.mTime);
Phil Burk1b420972015-04-22 10:52:21 -07002665 if (currentTimeNanos < previousTimeNanos) {
Andy Hung5d313802016-10-10 15:09:39 -07002666 ALOGW("retrograde timestamp time corrected, %lld < %lld",
2667 (long long)currentTimeNanos, (long long)previousTimeNanos);
2668 timestamp.mTime = mPreviousTimestamp.mTime;
Phil Burk1b420972015-04-22 10:52:21 -07002669 }
2670
2671 // Looking at signed delta will work even when the timestamps
2672 // are wrapping around.
Andy Hung90e8a972015-11-09 16:42:40 -08002673 int32_t deltaPosition = (Modulo<uint32_t>(timestamp.mPosition)
2674 - mPreviousTimestamp.mPosition).signedValue();
Phil Burk4c5a3672015-04-30 16:18:53 -07002675 if (deltaPosition < 0) {
2676 // Only report once per position instead of spamming the log.
2677 if (!mRetrogradeMotionReported) {
2678 ALOGW("retrograde timestamp position corrected, %d = %u - %u",
2679 deltaPosition,
2680 timestamp.mPosition,
2681 mPreviousTimestamp.mPosition);
2682 mRetrogradeMotionReported = true;
2683 }
2684 } else {
2685 mRetrogradeMotionReported = false;
2686 }
Andy Hung5d313802016-10-10 15:09:39 -07002687 if (deltaPosition < 0) {
2688 timestamp.mPosition = mPreviousTimestamp.mPosition;
2689 deltaPosition = 0;
Phil Burk1b420972015-04-22 10:52:21 -07002690 }
Andy Hung5d313802016-10-10 15:09:39 -07002691#if 0
2692 // Uncomment this to verify audio timestamp rate.
2693 const int64_t deltaTime =
2694 convertTimespecToNs(timestamp.mTime) - previousTimeNanos;
2695 if (deltaTime != 0) {
2696 const int64_t computedSampleRate =
2697 deltaPosition * (long long)NANOS_PER_SECOND / deltaTime;
2698 ALOGD("computedSampleRate:%u sampleRate:%u",
2699 (unsigned)computedSampleRate, mSampleRate);
2700 }
2701#endif
Phil Burk1b420972015-04-22 10:52:21 -07002702 }
2703 mPreviousTimestamp = timestamp;
2704 mPreviousTimestampValid = true;
2705 }
2706
Glenn Kastenfe346c72013-08-30 13:28:22 -07002707 return status;
Glenn Kastence703742013-07-19 16:33:58 -07002708}
2709
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002710String8 AudioTrack::getParameters(const String8& keys)
2711{
Glenn Kasten2c6c5292014-01-13 10:29:08 -08002712 audio_io_handle_t output = getOutput();
Glenn Kasten142f5192014-03-25 17:44:59 -07002713 if (output != AUDIO_IO_HANDLE_NONE) {
Glenn Kasten2c6c5292014-01-13 10:29:08 -08002714 return AudioSystem::getParameters(output, keys);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002715 } else {
2716 return String8::empty();
2717 }
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002718}
2719
Glenn Kasten23a75452014-01-13 10:37:17 -08002720bool AudioTrack::isOffloaded() const
2721{
2722 AutoMutex lock(mLock);
2723 return isOffloaded_l();
2724}
2725
Eric Laurentab5cdba2014-06-09 17:22:27 -07002726bool AudioTrack::isDirect() const
2727{
2728 AutoMutex lock(mLock);
2729 return isDirect_l();
2730}
2731
2732bool AudioTrack::isOffloadedOrDirect() const
2733{
2734 AutoMutex lock(mLock);
2735 return isOffloadedOrDirect_l();
2736}
2737
2738
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08002739status_t AudioTrack::dump(int fd, const Vector<String16>& args __unused) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002740{
2741
2742 const size_t SIZE = 256;
2743 char buffer[SIZE];
2744 String8 result;
2745
2746 result.append(" AudioTrack::dump\n");
Glenn Kasten85ab62c2012-11-01 11:11:38 -07002747 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n", mStreamType,
Glenn Kasten877a0ac2014-04-30 17:04:13 -07002748 mVolume[AUDIO_INTERLEAVE_LEFT], mVolume[AUDIO_INTERLEAVE_RIGHT]);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002749 result.append(buffer);
Kévin PETIT377b2ec2014-02-03 12:35:36 +00002750 snprintf(buffer, 255, " format(%d), channel count(%d), frame count(%zu)\n", mFormat,
Glenn Kastenb6037442012-11-14 13:42:25 -08002751 mChannelCount, mFrameCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002752 result.append(buffer);
Andy Hung8edb8dc2015-03-26 19:13:55 -07002753 snprintf(buffer, 255, " sample rate(%u), speed(%f), status(%d)\n",
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07002754 mSampleRate, mPlaybackRate.mSpeed, mStatus);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002755 result.append(buffer);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002756 snprintf(buffer, 255, " state(%d), latency (%d)\n", mState, mLatency);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002757 result.append(buffer);
2758 ::write(fd, result.string(), result.size());
2759 return NO_ERROR;
2760}
2761
Phil Burk2812d9e2016-01-04 10:34:30 -08002762uint32_t AudioTrack::getUnderrunCount() const
2763{
2764 AutoMutex lock(mLock);
2765 return getUnderrunCount_l();
2766}
2767
2768uint32_t AudioTrack::getUnderrunCount_l() const
2769{
2770 return mProxy->getUnderrunCount() + mUnderrunCountOffset;
2771}
2772
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002773uint32_t AudioTrack::getUnderrunFrames() const
2774{
2775 AutoMutex lock(mLock);
2776 return mProxy->getUnderrunFrames();
2777}
2778
Eric Laurent296fb132015-05-01 11:38:42 -07002779status_t AudioTrack::addAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback)
2780{
2781 if (callback == 0) {
2782 ALOGW("%s adding NULL callback!", __FUNCTION__);
2783 return BAD_VALUE;
2784 }
2785 AutoMutex lock(mLock);
2786 if (mDeviceCallback == callback) {
2787 ALOGW("%s adding same callback!", __FUNCTION__);
2788 return INVALID_OPERATION;
2789 }
2790 status_t status = NO_ERROR;
2791 if (mOutput != AUDIO_IO_HANDLE_NONE) {
2792 if (mDeviceCallback != 0) {
2793 ALOGW("%s callback already present!", __FUNCTION__);
2794 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
2795 }
2796 status = AudioSystem::addAudioDeviceCallback(callback, mOutput);
2797 }
2798 mDeviceCallback = callback;
2799 return status;
2800}
2801
2802status_t AudioTrack::removeAudioDeviceCallback(
2803 const sp<AudioSystem::AudioDeviceCallback>& callback)
2804{
2805 if (callback == 0) {
2806 ALOGW("%s removing NULL callback!", __FUNCTION__);
2807 return BAD_VALUE;
2808 }
2809 AutoMutex lock(mLock);
2810 if (mDeviceCallback != callback) {
2811 ALOGW("%s removing different callback!", __FUNCTION__);
2812 return INVALID_OPERATION;
2813 }
2814 if (mOutput != AUDIO_IO_HANDLE_NONE) {
2815 AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
2816 }
2817 mDeviceCallback = 0;
2818 return NO_ERROR;
2819}
2820
Andy Hunge13f8a62016-03-30 14:20:42 -07002821status_t AudioTrack::pendingDuration(int32_t *msec, ExtendedTimestamp::Location location)
2822{
2823 if (msec == nullptr ||
2824 (location != ExtendedTimestamp::LOCATION_SERVER
2825 && location != ExtendedTimestamp::LOCATION_KERNEL)) {
2826 return BAD_VALUE;
2827 }
2828 AutoMutex lock(mLock);
2829 // inclusive of offloaded and direct tracks.
2830 //
2831 // It is possible, but not enabled, to allow duration computation for non-pcm
2832 // audio_has_proportional_frames() formats because currently they have
2833 // the drain rate equivalent to the pcm sample rate * framesize.
2834 if (!isPurePcmData_l()) {
2835 return INVALID_OPERATION;
2836 }
2837 ExtendedTimestamp ets;
2838 if (getTimestamp_l(&ets) == OK
2839 && ets.mTimeNs[location] > 0) {
2840 int64_t diff = ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT]
2841 - ets.mPosition[location];
2842 if (diff < 0) {
2843 *msec = 0;
2844 } else {
2845 // ms is the playback time by frames
2846 int64_t ms = (int64_t)((double)diff * 1000 /
2847 ((double)mSampleRate * mPlaybackRate.mSpeed));
2848 // clockdiff is the timestamp age (negative)
2849 int64_t clockdiff = (mState != STATE_ACTIVE) ? 0 :
2850 ets.mTimeNs[location]
2851 + ets.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_MONOTONIC]
2852 - systemTime(SYSTEM_TIME_MONOTONIC);
2853
2854 //ALOGV("ms: %lld clockdiff: %lld", (long long)ms, (long long)clockdiff);
2855 static const int NANOS_PER_MILLIS = 1000000;
2856 *msec = (int32_t)(ms + clockdiff / NANOS_PER_MILLIS);
2857 }
2858 return NO_ERROR;
2859 }
2860 if (location != ExtendedTimestamp::LOCATION_SERVER) {
2861 return INVALID_OPERATION; // LOCATION_KERNEL is not available
2862 }
2863 // use server position directly (offloaded and direct arrive here)
2864 updateAndGetPosition_l();
2865 int32_t diff = (Modulo<uint32_t>(mFramesWritten) - mPosition).signedValue();
2866 *msec = (diff <= 0) ? 0
2867 : (int32_t)((double)diff * 1000 / ((double)mSampleRate * mPlaybackRate.mSpeed));
2868 return NO_ERROR;
2869}
2870
Andy Hung65ffdfc2016-10-10 15:52:11 -07002871bool AudioTrack::hasStarted()
2872{
2873 AutoMutex lock(mLock);
2874 switch (mState) {
2875 case STATE_STOPPED:
2876 if (isOffloadedOrDirect_l()) {
2877 // check if we have started in the past to return true.
2878 return mStartUs > 0;
2879 }
2880 // A normal audio track may still be draining, so
2881 // check if stream has ended. This covers fasttrack position
2882 // instability and start/stop without any data written.
2883 if (mProxy->getStreamEndDone()) {
2884 return true;
2885 }
2886 // fall through
2887 case STATE_ACTIVE:
2888 case STATE_STOPPING:
2889 break;
2890 case STATE_PAUSED:
2891 case STATE_PAUSED_STOPPING:
2892 case STATE_FLUSHED:
2893 return false; // we're not active
2894 default:
2895 LOG_ALWAYS_FATAL("Invalid mState in hasStarted(): %d", mState);
2896 break;
2897 }
2898
2899 // wait indicates whether we need to wait for a timestamp.
2900 // This is conservatively figured - if we encounter an unexpected error
2901 // then we will not wait.
2902 bool wait = false;
2903 if (isOffloadedOrDirect_l()) {
2904 AudioTimestamp ts;
2905 status_t status = getTimestamp_l(ts);
2906 if (status == WOULD_BLOCK) {
2907 wait = true;
2908 } else if (status == OK) {
2909 wait = (ts.mPosition == 0 || ts.mPosition == mStartTs.mPosition);
2910 }
2911 ALOGV("hasStarted wait:%d ts:%u start position:%lld",
2912 (int)wait,
2913 ts.mPosition,
2914 (long long)mStartTs.mPosition);
2915 } else {
2916 int location = ExtendedTimestamp::LOCATION_SERVER; // for ALOG
2917 ExtendedTimestamp ets;
2918 status_t status = getTimestamp_l(&ets);
2919 if (status == WOULD_BLOCK) { // no SERVER or KERNEL frame info in ets
2920 wait = true;
2921 } else if (status == OK) {
2922 for (location = ExtendedTimestamp::LOCATION_KERNEL;
2923 location >= ExtendedTimestamp::LOCATION_SERVER; --location) {
2924 if (ets.mTimeNs[location] < 0 || mStartEts.mTimeNs[location] < 0) {
2925 continue;
2926 }
2927 wait = ets.mPosition[location] == 0
2928 || ets.mPosition[location] == mStartEts.mPosition[location];
2929 break;
2930 }
2931 }
2932 ALOGV("hasStarted wait:%d ets:%lld start position:%lld",
2933 (int)wait,
2934 (long long)ets.mPosition[location],
2935 (long long)mStartEts.mPosition[location]);
2936 }
2937 return !wait;
2938}
2939
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002940// =========================================================================
2941
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08002942void AudioTrack::DeathNotifier::binderDied(const wp<IBinder>& who __unused)
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002943{
2944 sp<AudioTrack> audioTrack = mAudioTrack.promote();
2945 if (audioTrack != 0) {
2946 AutoMutex lock(audioTrack->mLock);
2947 audioTrack->mProxy->binderDied();
2948 }
2949}
2950
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002951// =========================================================================
2952
2953AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver, bool bCanCallJava)
Glenn Kasten598de6c2013-10-16 17:02:13 -07002954 : Thread(bCanCallJava), mReceiver(receiver), mPaused(true), mPausedInt(false), mPausedNs(0LL),
2955 mIgnoreNextPausedInt(false)
Glenn Kasten3acbd052012-02-28 10:39:56 -08002956{
2957}
2958
2959AudioTrack::AudioTrackThread::~AudioTrackThread()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002960{
2961}
2962
2963bool AudioTrack::AudioTrackThread::threadLoop()
2964{
Glenn Kasten3acbd052012-02-28 10:39:56 -08002965 {
2966 AutoMutex _l(mMyLock);
2967 if (mPaused) {
Glenn Kasten75f79032017-05-23 11:22:44 -07002968 // TODO check return value and handle or log
Glenn Kasten3acbd052012-02-28 10:39:56 -08002969 mMyCond.wait(mMyLock);
2970 // caller will check for exitPending()
2971 return true;
2972 }
Glenn Kasten598de6c2013-10-16 17:02:13 -07002973 if (mIgnoreNextPausedInt) {
2974 mIgnoreNextPausedInt = false;
2975 mPausedInt = false;
2976 }
Glenn Kasten5a6cd222013-09-20 09:20:45 -07002977 if (mPausedInt) {
Glenn Kasten47d55172017-05-23 11:19:30 -07002978 // TODO use futex instead of condition, for event flag "or"
Glenn Kasten5a6cd222013-09-20 09:20:45 -07002979 if (mPausedNs > 0) {
Glenn Kasten75f79032017-05-23 11:22:44 -07002980 // TODO check return value and handle or log
Glenn Kasten5a6cd222013-09-20 09:20:45 -07002981 (void) mMyCond.waitRelative(mMyLock, mPausedNs);
2982 } else {
Glenn Kasten75f79032017-05-23 11:22:44 -07002983 // TODO check return value and handle or log
Glenn Kasten5a6cd222013-09-20 09:20:45 -07002984 mMyCond.wait(mMyLock);
2985 }
Eric Laurent9d2c78c2013-09-23 12:29:42 -07002986 mPausedInt = false;
Glenn Kasten5a6cd222013-09-20 09:20:45 -07002987 return true;
2988 }
Glenn Kasten3acbd052012-02-28 10:39:56 -08002989 }
Eric Laurent7985dcb2014-10-07 15:45:14 -07002990 if (exitPending()) {
2991 return false;
2992 }
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08002993 nsecs_t ns = mReceiver.processAudioBuffer();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002994 switch (ns) {
2995 case 0:
2996 return true;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002997 case NS_INACTIVE:
Glenn Kasten5a6cd222013-09-20 09:20:45 -07002998 pauseInternal();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002999 return true;
3000 case NS_NEVER:
3001 return false;
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003002 case NS_WHENEVER:
Andy Hung3c09c782014-12-29 18:39:32 -08003003 // Event driven: call wake() when callback notifications conditions change.
3004 ns = INT64_MAX;
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003005 // fall through
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003006 default:
Mark Salyzyn34fb2962014-06-18 16:30:56 -07003007 LOG_ALWAYS_FATAL_IF(ns < 0, "processAudioBuffer() returned %" PRId64, ns);
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003008 pauseInternal(ns);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003009 return true;
Glenn Kastenca8b2802012-04-23 13:58:16 -07003010 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08003011}
3012
Glenn Kasten3acbd052012-02-28 10:39:56 -08003013void AudioTrack::AudioTrackThread::requestExit()
3014{
3015 // must be in this order to avoid a race condition
3016 Thread::requestExit();
Glenn Kasten598de6c2013-10-16 17:02:13 -07003017 resume();
Glenn Kasten3acbd052012-02-28 10:39:56 -08003018}
3019
3020void AudioTrack::AudioTrackThread::pause()
3021{
3022 AutoMutex _l(mMyLock);
3023 mPaused = true;
3024}
3025
3026void AudioTrack::AudioTrackThread::resume()
3027{
3028 AutoMutex _l(mMyLock);
Glenn Kasten598de6c2013-10-16 17:02:13 -07003029 mIgnoreNextPausedInt = true;
Eric Laurent9d2c78c2013-09-23 12:29:42 -07003030 if (mPaused || mPausedInt) {
Glenn Kasten3acbd052012-02-28 10:39:56 -08003031 mPaused = false;
Eric Laurent9d2c78c2013-09-23 12:29:42 -07003032 mPausedInt = false;
Glenn Kasten3acbd052012-02-28 10:39:56 -08003033 mMyCond.signal();
3034 }
3035}
3036
Andy Hung3c09c782014-12-29 18:39:32 -08003037void AudioTrack::AudioTrackThread::wake()
3038{
3039 AutoMutex _l(mMyLock);
Andy Hunga8d08902015-07-22 11:52:13 -07003040 if (!mPaused) {
3041 // wake() might be called while servicing a callback - ignore the next
3042 // pause time and call processAudioBuffer.
Andy Hung3c09c782014-12-29 18:39:32 -08003043 mIgnoreNextPausedInt = true;
Andy Hunga8d08902015-07-22 11:52:13 -07003044 if (mPausedInt && mPausedNs > 0) {
3045 // audio track is active and internally paused with timeout.
3046 mPausedInt = false;
3047 mMyCond.signal();
3048 }
Andy Hung3c09c782014-12-29 18:39:32 -08003049 }
3050}
3051
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003052void AudioTrack::AudioTrackThread::pauseInternal(nsecs_t ns)
3053{
3054 AutoMutex _l(mMyLock);
3055 mPausedInt = true;
3056 mPausedNs = ns;
3057}
3058
Glenn Kasten40bc9062015-03-20 09:09:33 -07003059} // namespace android