blob: 8cf22c4b131cc7853141c910d8b664b33773a438 [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>
Andy Hung959b5b82021-09-24 10:46:20 -070024#include <thread>
Mark Salyzyn34fb2962014-06-18 16:30:56 -070025
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080026#include <android/media/IAudioPolicyService.h>
Chih-Hung Hsiehffe35582018-09-13 13:59:28 -070027#include <android-base/macros.h>
Andy Hung2b01f002017-07-05 12:01:36 -070028#include <audio_utils/clock.h>
Glenn Kasten9f80dd22012-12-18 15:57:32 -080029#include <audio_utils/primitives.h>
30#include <binder/IPCThreadState.h>
31#include <media/AudioTrack.h>
32#include <utils/Log.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080033#include <private/media/AudioTrackShared.h>
Suren Baghdasaryan7435e7d2018-12-19 17:09:28 -080034#include <processgroup/sched_policy.h>
Glenn Kasten1ab85ec2013-05-31 09:18:43 -070035#include <media/IAudioFlinger.h>
Dean Wheatleya70eef72018-01-04 14:23:50 +110036#include <media/AudioParameter.h>
Andy Hungcd044842014-08-07 11:04:34 -070037#include <media/AudioResamplerPublic.h>
Michael Chana94fbb22018-04-24 14:31:19 +100038#include <media/AudioSystem.h>
Ray Essickf27e9872019-12-07 06:28:46 -080039#include <media/MediaMetricsItem.h>
Ray Essicked304702017-12-12 14:00:57 -080040#include <media/TypeConverter.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080041
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +010042#define WAIT_PERIOD_MS 10
43#define WAIT_STREAM_END_TIMEOUT_SEC 120
Andy Hung53c3b5f2014-12-15 16:42:05 -080044static const int kMaxLoopCountNotifications = 32;
Glenn Kasten511754b2012-01-11 09:52:19 -080045
Kuowei Lid4adbdb2020-08-13 14:44:25 +080046using ::android::aidl_utils::statusTFromBinderStatus;
47
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080048namespace android {
Chia-chi Yeh33005a92010-06-16 06:33:13 +080049// ---------------------------------------------------------------------------
50
Ivan Lozano8cf3a072017-08-09 09:01:33 -070051using media::VolumeShaper;
Svet Ganov3e5f14f2021-05-13 22:51:08 +000052using android::content::AttributionSourceState;
Ivan Lozano8cf3a072017-08-09 09:01:33 -070053
Andy Hunga7f03352015-05-31 21:54:49 -070054// TODO: Move to a separate .h
55
Andy Hung4ede21d2014-12-12 15:37:34 -080056template <typename T>
Andy Hunga7f03352015-05-31 21:54:49 -070057static inline const T &min(const T &x, const T &y) {
Andy Hung4ede21d2014-12-12 15:37:34 -080058 return x < y ? x : y;
59}
60
Andy Hunga7f03352015-05-31 21:54:49 -070061template <typename T>
62static inline const T &max(const T &x, const T &y) {
63 return x > y ? x : y;
64}
65
66static inline nsecs_t framesToNanoseconds(ssize_t frames, uint32_t sampleRate, float speed)
67{
68 return ((double)frames * 1000000000) / ((double)sampleRate * speed);
69}
70
Andy Hung7f1bc8a2014-09-12 14:43:11 -070071static int64_t convertTimespecToUs(const struct timespec &tv)
72{
Chih-Hung Hsieh50fa06c2018-12-11 13:51:36 -080073 return tv.tv_sec * 1000000LL + tv.tv_nsec / 1000;
Andy Hung7f1bc8a2014-09-12 14:43:11 -070074}
75
Andy Hungffa36952017-08-17 10:41:51 -070076// TODO move to audio_utils.
77static inline struct timespec convertNsToTimespec(int64_t ns) {
78 struct timespec tv;
79 tv.tv_sec = static_cast<time_t>(ns / NANOS_PER_SECOND);
Andy Hung06a730b2020-04-09 13:28:31 -070080 tv.tv_nsec = static_cast<int64_t>(ns % NANOS_PER_SECOND);
Andy Hungffa36952017-08-17 10:41:51 -070081 return tv;
82}
83
Andy Hung7f1bc8a2014-09-12 14:43:11 -070084// current monotonic time in microseconds.
85static int64_t getNowUs()
86{
87 struct timespec tv;
88 (void) clock_gettime(CLOCK_MONOTONIC, &tv);
89 return convertTimespecToUs(tv);
90}
91
Andy Hung26145642015-04-15 21:56:53 -070092// FIXME: we don't use the pitch setting in the time stretcher (not working);
93// instead we emulate it using our sample rate converter.
94static const bool kFixPitch = true; // enable pitch fix
95static inline uint32_t adjustSampleRate(uint32_t sampleRate, float pitch)
96{
97 return kFixPitch ? (sampleRate * pitch + 0.5) : sampleRate;
98}
99
100static inline float adjustSpeed(float speed, float pitch)
101{
Ricardo Garcia6c7f0622015-04-30 18:39:16 -0700102 return kFixPitch ? speed / max(pitch, AUDIO_TIMESTRETCH_PITCH_MIN_DELTA) : speed;
Andy Hung26145642015-04-15 21:56:53 -0700103}
104
105static inline float adjustPitch(float pitch)
106{
107 return kFixPitch ? AUDIO_TIMESTRETCH_PITCH_NORMAL : pitch;
108}
109
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800110// static
111status_t AudioTrack::getMinFrameCount(
Glenn Kastene33054e2012-11-14 12:54:39 -0800112 size_t* frameCount,
Glenn Kastenfff6d712012-01-12 16:38:12 -0800113 audio_stream_type_t streamType,
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800114 uint32_t sampleRate)
115{
Glenn Kastend65d73c2012-06-22 17:21:07 -0700116 if (frameCount == NULL) {
117 return BAD_VALUE;
118 }
Glenn Kasten04cd0182012-06-25 11:49:27 -0700119
Andy Hung0e48d252015-01-26 11:43:15 -0800120 // FIXME handle in server, like createTrack_l(), possible missing info:
Glenn Kastene0fa4672012-04-24 14:35:14 -0700121 // audio_io_handle_t output
122 // audio_format_t format
123 // audio_channel_mask_t channelMask
Andy Hung0e48d252015-01-26 11:43:15 -0800124 // audio_output_flags_t flags (FAST)
Glenn Kasten3b16c762012-11-14 08:44:39 -0800125 uint32_t afSampleRate;
Glenn Kasten66a04672014-01-08 08:53:44 -0800126 status_t status;
127 status = AudioSystem::getOutputSamplingRate(&afSampleRate, streamType);
128 if (status != NO_ERROR) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700129 ALOGE("%s(): Unable to query output sample rate for stream type %d; status %d",
130 __func__, streamType, status);
Glenn Kasten66a04672014-01-08 08:53:44 -0800131 return status;
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800132 }
Glenn Kastene33054e2012-11-14 12:54:39 -0800133 size_t afFrameCount;
Glenn Kasten66a04672014-01-08 08:53:44 -0800134 status = AudioSystem::getOutputFrameCount(&afFrameCount, streamType);
135 if (status != NO_ERROR) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700136 ALOGE("%s(): Unable to query output frame count for stream type %d; status %d",
137 __func__, streamType, status);
Glenn Kasten66a04672014-01-08 08:53:44 -0800138 return status;
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800139 }
140 uint32_t afLatency;
Glenn Kasten66a04672014-01-08 08:53:44 -0800141 status = AudioSystem::getOutputLatency(&afLatency, streamType);
142 if (status != NO_ERROR) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700143 ALOGE("%s(): Unable to query output latency for stream type %d; status %d",
144 __func__, streamType, status);
Glenn Kasten66a04672014-01-08 08:53:44 -0800145 return status;
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800146 }
147
Andy Hung8edb8dc2015-03-26 19:13:55 -0700148 // When called from createTrack, speed is 1.0f (normal speed).
149 // This is rechecked again on setting playback rate (TODO: on setting sample rate, too).
Eric Laurent21da6472017-11-09 16:29:26 -0800150 *frameCount = AudioSystem::calculateMinFrameCount(afLatency, afFrameCount, afSampleRate,
151 sampleRate, 1.0f /*, 0 notificationsPerBufferReq*/);
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800152
Andy Hung0e48d252015-01-26 11:43:15 -0800153 // The formula above should always produce a non-zero value under normal circumstances:
154 // AudioTrack.SAMPLE_RATE_HZ_MIN <= sampleRate <= AudioTrack.SAMPLE_RATE_HZ_MAX.
155 // 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 -0800156 if (*frameCount == 0) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700157 ALOGE("%s(): failed for streamType %d, sampleRate %u",
158 __func__, streamType, sampleRate);
Glenn Kasten66a04672014-01-08 08:53:44 -0800159 return BAD_VALUE;
160 }
Andy Hungfb8ede22018-09-12 19:03:24 -0700161 ALOGV("%s(): getMinFrameCount=%zu: afFrameCount=%zu, afSampleRate=%u, afLatency=%u",
162 __func__, *frameCount, afFrameCount, afSampleRate, afLatency);
Chia-chi Yeh33005a92010-06-16 06:33:13 +0800163 return NO_ERROR;
164}
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800165
Michael Chana94fbb22018-04-24 14:31:19 +1000166// static
167bool AudioTrack::isDirectOutputSupported(const audio_config_base_t& config,
168 const audio_attributes_t& attributes) {
169 ALOGV("%s()", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800170 const sp<media::IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
Michael Chana94fbb22018-04-24 14:31:19 +1000171 if (aps == 0) return false;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800172
173 auto result = [&]() -> ConversionResult<bool> {
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700174 media::audio::common::AudioConfigBase configAidl = VALUE_OR_RETURN(
Mikhail Naganov9dec7012021-07-21 10:30:57 -0700175 legacy2aidl_audio_config_base_t_AudioConfigBase(config, false /*isInput*/));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800176 media::AudioAttributesInternal attributesAidl = VALUE_OR_RETURN(
177 legacy2aidl_audio_attributes_t_AudioAttributesInternal(attributes));
178 bool retAidl;
179 RETURN_IF_ERROR(aidl_utils::statusTFromBinderStatus(
180 aps->isDirectOutputSupported(configAidl, attributesAidl, &retAidl)));
181 return retAidl;
182 }();
183 return result.value_or(false);
Michael Chana94fbb22018-04-24 14:31:19 +1000184}
185
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800186// ---------------------------------------------------------------------------
187
Ray Essicked304702017-12-12 14:00:57 -0800188void AudioTrack::MediaMetrics::gather(const AudioTrack *track)
189{
Ray Essick88394302018-01-24 14:52:05 -0800190 // only if we're in a good state...
191 // XXX: shall we gather alternative info if failing?
192 const status_t lstatus = track->initCheck();
193 if (lstatus != NO_ERROR) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700194 ALOGD("%s(): no metrics gathered, track status=%d", __func__, (int) lstatus);
Ray Essick88394302018-01-24 14:52:05 -0800195 return;
196 }
197
Andy Hungd0979812019-02-21 15:51:44 -0800198#define MM_PREFIX "android.media.audiotrack." // avoid cut-n-paste errors.
Ray Essicked304702017-12-12 14:00:57 -0800199
Andy Hungd0979812019-02-21 15:51:44 -0800200 // Java API 28 entries, do not change.
Ray Essickf27e9872019-12-07 06:28:46 -0800201 mMetricsItem->setCString(MM_PREFIX "streamtype", toString(track->streamType()).c_str());
202 mMetricsItem->setCString(MM_PREFIX "type",
Andy Hungd0979812019-02-21 15:51:44 -0800203 toString(track->mAttributes.content_type).c_str());
Ray Essickf27e9872019-12-07 06:28:46 -0800204 mMetricsItem->setCString(MM_PREFIX "usage", toString(track->mAttributes.usage).c_str());
Ray Essicked304702017-12-12 14:00:57 -0800205
Andy Hungd0979812019-02-21 15:51:44 -0800206 // Non-API entries, these can change due to a Java string mistake.
Ray Essickf27e9872019-12-07 06:28:46 -0800207 mMetricsItem->setInt32(MM_PREFIX "sampleRate", (int32_t)track->mSampleRate);
208 mMetricsItem->setInt64(MM_PREFIX "channelMask", (int64_t)track->mChannelMask);
Andy Hungd0979812019-02-21 15:51:44 -0800209 // Non-API entries, these can change.
Ray Essickf27e9872019-12-07 06:28:46 -0800210 mMetricsItem->setInt32(MM_PREFIX "portId", (int32_t)track->mPortId);
211 mMetricsItem->setCString(MM_PREFIX "encoding", toString(track->mFormat).c_str());
212 mMetricsItem->setInt32(MM_PREFIX "frameCount", (int32_t)track->mFrameCount);
213 mMetricsItem->setCString(MM_PREFIX "attributes", toString(track->mAttributes).c_str());
Andy Hung6f451f02021-02-24 21:53:29 -0800214 mMetricsItem->setCString(MM_PREFIX "logSessionId", track->mLogSessionId.c_str());
Ray Essicked304702017-12-12 14:00:57 -0800215}
216
Ray Essick88394302018-01-24 14:52:05 -0800217// hand the user a snapshot of the metrics.
Ray Essickf27e9872019-12-07 06:28:46 -0800218status_t AudioTrack::getMetrics(mediametrics::Item * &item)
Ray Essick88394302018-01-24 14:52:05 -0800219{
220 mMediaMetrics.gather(this);
Ray Essickf27e9872019-12-07 06:28:46 -0800221 mediametrics::Item *tmp = mMediaMetrics.dup();
Ray Essick88394302018-01-24 14:52:05 -0800222 if (tmp == nullptr) {
223 return BAD_VALUE;
224 }
225 item = tmp;
226 return NO_ERROR;
227}
Ray Essicked304702017-12-12 14:00:57 -0800228
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000229AudioTrack::AudioTrack() : AudioTrack(AttributionSourceState())
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000230{
231}
232
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000233AudioTrack::AudioTrack(const AttributionSourceState& attributionSource)
Glenn Kasten87913512011-06-22 16:15:25 -0700234 : mStatus(NO_INIT),
Haynes Mathew George9b3359f2016-03-23 19:09:10 -0700235 mState(STATE_STOPPED),
John Grossman4ff14ba2012-02-08 16:37:41 -0800236 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800237 mPreviousSchedulingGroup(SP_DEFAULT),
Paul McLeanaa981192015-03-21 09:55:15 -0700238 mPausedPosition(0),
Eric Laurent20b9ef02016-12-05 11:03:16 -0800239 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
jiabinf6eb4c32020-02-25 14:06:25 -0800240 mRoutedDeviceId(AUDIO_PORT_HANDLE_NONE),
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000241 mClientAttributionSource(attributionSource),
jiabinf6eb4c32020-02-25 14:06:25 -0800242 mAudioTrackCallback(new AudioTrackCallback())
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800243{
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700244 mAttributes.content_type = AUDIO_CONTENT_TYPE_UNKNOWN;
245 mAttributes.usage = AUDIO_USAGE_UNKNOWN;
Mikhail Naganov55773032020-10-01 15:08:13 -0700246 mAttributes.flags = AUDIO_FLAG_NONE;
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700247 strcpy(mAttributes.tags, "");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800248}
249
250AudioTrack::AudioTrack(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800251 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800252 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800253 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700254 audio_channel_mask_t channelMask,
Glenn Kastenbce50bf2014-02-27 15:29:51 -0800255 size_t frameCount,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700256 audio_output_flags_t flags,
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000257 callback_t cbf,
Atneyaf86d2692021-10-14 14:02:36 -0400258 void* user,
259 int32_t notificationFrames,
260 audio_session_t sessionId,
261 transfer_type transferType,
262 const audio_offload_info_t *offloadInfo,
263 const AttributionSourceState& attributionSource,
264 const audio_attributes_t* pAttributes,
265 bool doNotReconnect,
266 float maxRequiredSpeed,
267 audio_port_handle_t selectedDeviceId)
268 : mStatus(NO_INIT),
269 mState(STATE_STOPPED),
270 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
271 mPreviousSchedulingGroup(SP_DEFAULT),
272 mPausedPosition(0),
273 mAudioTrackCallback(new AudioTrackCallback())
274{
275 mAttributes = AUDIO_ATTRIBUTES_INITIALIZER;
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000276
Atneyaf86d2692021-10-14 14:02:36 -0400277 (void)set(streamType, sampleRate, format, channelMask,
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000278 frameCount, flags, cbf, user, notificationFrames,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000279 0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId, transferType, offloadInfo,
280 attributionSource, pAttributes, doNotReconnect, maxRequiredSpeed, selectedDeviceId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800281}
282
Andreas Huberc8139852012-01-18 10:51:55 -0800283AudioTrack::AudioTrack(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800284 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800285 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800286 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700287 audio_channel_mask_t channelMask,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800288 const sp<IMemory>& sharedBuffer,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700289 audio_output_flags_t flags,
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000290 callback_t cbf,
291 void* user,
Glenn Kastenea38ee72016-04-18 11:08:01 -0700292 int32_t notificationFrames,
Glenn Kastend848eb42016-03-08 13:42:11 -0800293 audio_session_t sessionId,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000294 transfer_type transferType,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800295 const audio_offload_info_t *offloadInfo,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000296 const AttributionSourceState& attributionSource,
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700297 const audio_attributes_t* pAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -0700298 bool doNotReconnect,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700299 float maxRequiredSpeed)
Glenn Kasten87913512011-06-22 16:15:25 -0700300 : mStatus(NO_INIT),
Haynes Mathew George9b3359f2016-03-23 19:09:10 -0700301 mState(STATE_STOPPED),
John Grossman4ff14ba2012-02-08 16:37:41 -0800302 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Haynes Mathew George7064fd22014-01-08 13:59:53 -0800303 mPreviousSchedulingGroup(SP_DEFAULT),
Paul McLeanaa981192015-03-21 09:55:15 -0700304 mPausedPosition(0),
jiabinf6eb4c32020-02-25 14:06:25 -0800305 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
306 mAudioTrackCallback(new AudioTrackCallback())
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800307{
François Gaffie393f0e02019-04-10 09:09:08 +0200308 mAttributes = AUDIO_ATTRIBUTES_INITIALIZER;
Ippei Murata5fa32ed2018-10-01 17:37:50 +0900309
Eric Laurentf32d7812017-11-30 14:44:07 -0800310 (void)set(streamType, sampleRate, format, channelMask,
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000311 0 /*frameCount*/, flags, cbf, user, notificationFrames,
Marco Nelissend457c972014-02-11 08:47:07 -0800312 sharedBuffer, false /*threadCanCallJava*/, sessionId, transferType, offloadInfo,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000313 attributionSource, pAttributes, doNotReconnect, maxRequiredSpeed);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800314}
315
316AudioTrack::~AudioTrack()
317{
Ray Essicked304702017-12-12 14:00:57 -0800318 // pull together the numbers, before we clean up our structures
319 mMediaMetrics.gather(this);
320
Andy Hungb68f5eb2019-12-03 16:49:17 -0800321 mediametrics::LogItem(mMetricsId)
322 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_DTOR)
Phil Burkd3813f32020-04-23 16:26:15 -0700323 .set(AMEDIAMETRICS_PROP_CALLERNAME,
324 mCallerName.empty()
Andy Hunga6b27032020-04-27 10:34:24 -0700325 ? AMEDIAMETRICS_PROP_CALLERNAME_VALUE_UNKNOWN
Phil Burkd3813f32020-04-23 16:26:15 -0700326 : mCallerName.c_str())
Andy Hungb68f5eb2019-12-03 16:49:17 -0800327 .set(AMEDIAMETRICS_PROP_STATE, stateToString(mState))
328 .set(AMEDIAMETRICS_PROP_STATUS, (int32_t)mStatus)
329 .record();
330
Phil Burk7a9577c2021-03-12 20:12:11 +0000331 stopAndJoinCallbacks(); // checks mStatus
332
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800333 if (mStatus == NO_ERROR) {
Marco Nelissenf8880202014-11-14 07:58:25 -0800334 IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this);
Glenn Kasten53cec222013-08-29 09:01:02 -0700335 mAudioTrack.clear();
Eric Laurent3bcffa12014-06-12 18:38:45 -0700336 mCblkMemory.clear();
337 mSharedBuffer.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800338 IPCThreadState::self()->flushCommands();
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000339 pid_t clientPid = VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(mClientAttributionSource.pid));
Andy Hungfb8ede22018-09-12 19:03:24 -0700340 ALOGV("%s(%d), releasing session id %d from %d on behalf of %d",
Eric Laurent973db022018-11-20 14:54:31 -0800341 __func__, mPortId,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700342 mSessionId, IPCThreadState::self()->getCallingPid(), clientPid);
343 AudioSystem::releaseAudioSessionId(mSessionId, clientPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800344 }
345}
346
Phil Burk7a9577c2021-03-12 20:12:11 +0000347void AudioTrack::stopAndJoinCallbacks() {
348 // Prevent nullptr crash if it did not open properly.
349 if (mStatus != NO_ERROR) return;
350
351 // Make sure that callback function exits in the case where
352 // it is looping on buffer full condition in obtainBuffer().
353 // Otherwise the callback thread will never exit.
354 stop();
355 if (mAudioTrackThread != 0) { // not thread safe
356 mProxy->interrupt();
357 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h
358 mAudioTrackThread->requestExitAndWait();
359 mAudioTrackThread.clear();
360 }
361 // No lock here: worst case we remove a NULL callback which will be a nop
362 if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) {
363 // This may not stop all of these device callbacks!
364 // TODO: Add some sort of protection.
365 AudioSystem::removeAudioDeviceCallback(this, mOutput, mPortId);
366 mDeviceCallback.clear();
367 }
368}
369
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800370status_t AudioTrack::set(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800371 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800372 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800373 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700374 audio_channel_mask_t channelMask,
Glenn Kastenbce50bf2014-02-27 15:29:51 -0800375 size_t frameCount,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700376 audio_output_flags_t flags,
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000377 callback_t cbf,
378 void* user,
Glenn Kastenea38ee72016-04-18 11:08:01 -0700379 int32_t notificationFrames,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800380 const sp<IMemory>& sharedBuffer,
Eric Laurentbe916aa2010-06-01 23:49:17 -0700381 bool threadCanCallJava,
Glenn Kastend848eb42016-03-08 13:42:11 -0800382 audio_session_t sessionId,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000383 transfer_type transferType,
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800384 const audio_offload_info_t *offloadInfo,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000385 const AttributionSourceState& attributionSource,
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700386 const audio_attributes_t* pAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -0700387 bool doNotReconnect,
jiabin156c6872017-10-06 09:47:15 -0700388 float maxRequiredSpeed,
389 audio_port_handle_t selectedDeviceId)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800390{
Eric Laurentf32d7812017-11-30 14:44:07 -0800391 status_t status;
392 uint32_t channelCount;
393 pid_t callingPid;
394 pid_t myPid;
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000395 uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
396 pid_t pid = VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(attributionSource.pid));
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000397
Eric Laurent973db022018-11-20 14:54:31 -0800398 // Note mPortId is not valid until the track is created, so omit mPortId in ALOG for set.
Andy Hungfb8ede22018-09-12 19:03:24 -0700399 ALOGV("%s(): streamType %d, sampleRate %u, format %#x, channelMask %#x, frameCount %zu, "
Glenn Kastenea38ee72016-04-18 11:08:01 -0700400 "flags #%x, notificationFrames %d, sessionId %d, transferType %d, uid %d, pid %d",
Andy Hungfb8ede22018-09-12 19:03:24 -0700401 __func__,
Glenn Kastenbce50bf2014-02-27 15:29:51 -0800402 streamType, sampleRate, format, channelMask, frameCount, flags, notificationFrames,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000403 sessionId, transferType, attributionSource.uid, attributionSource.pid);
Glenn Kasten86f04662014-02-24 15:13:05 -0800404
Phil Burk33ff89b2015-11-30 11:16:01 -0800405 mThreadCanCallJava = threadCanCallJava;
jiabin156c6872017-10-06 09:47:15 -0700406 mSelectedDeviceId = selectedDeviceId;
Eric Laurent21da6472017-11-09 16:29:26 -0800407 mSessionId = sessionId;
Phil Burk33ff89b2015-11-30 11:16:01 -0800408
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800409 switch (transferType) {
410 case TRANSFER_DEFAULT:
411 if (sharedBuffer != 0) {
412 transferType = TRANSFER_SHARED;
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000413 } else if (cbf == NULL || threadCanCallJava) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800414 transferType = TRANSFER_SYNC;
415 } else {
416 transferType = TRANSFER_CALLBACK;
417 }
418 break;
419 case TRANSFER_CALLBACK:
Jean-Michel Trivif4158d82018-09-25 12:43:58 -0700420 case TRANSFER_SYNC_NOTIF_CALLBACK:
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000421 if (cbf == NULL || sharedBuffer != 0) {
422 ALOGE("%s(): Transfer type %s but cbf == NULL || sharedBuffer != 0",
Jean-Michel Trivif4158d82018-09-25 12:43:58 -0700423 convertTransferToText(transferType), __func__);
Eric Laurentf32d7812017-11-30 14:44:07 -0800424 status = BAD_VALUE;
425 goto exit;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800426 }
427 break;
428 case TRANSFER_OBTAIN:
429 case TRANSFER_SYNC:
430 if (sharedBuffer != 0) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700431 ALOGE("%s(): Transfer type TRANSFER_OBTAIN but sharedBuffer != 0", __func__);
Eric Laurentf32d7812017-11-30 14:44:07 -0800432 status = BAD_VALUE;
433 goto exit;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800434 }
435 break;
436 case TRANSFER_SHARED:
437 if (sharedBuffer == 0) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700438 ALOGE("%s(): Transfer type TRANSFER_SHARED but sharedBuffer == 0", __func__);
Eric Laurentf32d7812017-11-30 14:44:07 -0800439 status = BAD_VALUE;
440 goto exit;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800441 }
442 break;
443 default:
Andy Hungfb8ede22018-09-12 19:03:24 -0700444 ALOGE("%s(): Invalid transfer type %d",
445 __func__, transferType);
Eric Laurentf32d7812017-11-30 14:44:07 -0800446 status = BAD_VALUE;
447 goto exit;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800448 }
Glenn Kastendd5f4c82014-01-13 10:26:32 -0800449 mSharedBuffer = sharedBuffer;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800450 mTransfer = transferType;
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700451 mDoNotReconnect = doNotReconnect;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800452
Andy Hungfb8ede22018-09-12 19:03:24 -0700453 ALOGV_IF(sharedBuffer != 0, "%s(): sharedBuffer: %p, size: %zu",
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -0700454 __func__, sharedBuffer->unsecurePointer(), sharedBuffer->size());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800455
Andy Hungfb8ede22018-09-12 19:03:24 -0700456 ALOGV("%s(): streamType %d frameCount %zu flags %04x",
457 __func__, streamType, frameCount, flags);
Eric Laurent1a9ed112012-03-20 18:36:01 -0700458
Glenn Kasten53cec222013-08-29 09:01:02 -0700459 // invariant that mAudioTrack != 0 is true only after set() returns successfully
Eric Laurent1dd70b92009-04-21 07:56:33 -0700460 if (mAudioTrack != 0) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700461 ALOGE("%s(): Track already in use", __func__);
Eric Laurentf32d7812017-11-30 14:44:07 -0800462 status = INVALID_OPERATION;
463 goto exit;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800464 }
465
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800466 // handle default values first.
Eric Laurente83b55d2014-11-14 10:06:21 -0800467 if (streamType == AUDIO_STREAM_DEFAULT) {
Dima Zavinfce7a472011-04-19 22:30:36 -0700468 streamType = AUDIO_STREAM_MUSIC;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800469 }
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700470 if (pAttributes == NULL) {
Eric Laurent223fd5c2014-11-11 13:43:36 -0800471 if (uint32_t(streamType) >= AUDIO_STREAM_PUBLIC_CNT) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700472 ALOGE("%s(): Invalid stream type %d", __func__, streamType);
Eric Laurentf32d7812017-11-30 14:44:07 -0800473 status = BAD_VALUE;
474 goto exit;
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700475 }
Andy Hunga2159aa2021-07-20 13:01:52 -0700476 mOriginalStreamType = streamType;
Eric Laurente83b55d2014-11-14 10:06:21 -0800477
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700478 } else {
Jean-Michel Trivifaabb512014-06-11 16:55:06 -0700479 // stream type shouldn't be looked at, this track has audio attributes
480 memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));
Andy Hungfb8ede22018-09-12 19:03:24 -0700481 ALOGV("%s(): Building AudioTrack with attributes:"
482 " usage=%d content=%d flags=0x%x tags=[%s]",
483 __func__,
484 mAttributes.usage, mAttributes.content_type, mAttributes.flags, mAttributes.tags);
Andy Hunga2159aa2021-07-20 13:01:52 -0700485 mOriginalStreamType = AUDIO_STREAM_DEFAULT;
François Gaffie58d4be52018-11-06 15:30:12 +0100486 audio_flags_to_audio_output_flags(mAttributes.flags, &flags);
Glenn Kastendd5f4c82014-01-13 10:26:32 -0800487 }
Glenn Kastenea7939a2012-03-14 12:56:26 -0700488
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800489 // these below should probably come from the audioFlinger too...
Glenn Kastene1c39622012-01-04 09:36:37 -0800490 if (format == AUDIO_FORMAT_DEFAULT) {
Dima Zavinfce7a472011-04-19 22:30:36 -0700491 format = AUDIO_FORMAT_PCM_16_BIT;
Phil Burkfdb3c072016-02-09 10:47:02 -0800492 } else if (format == AUDIO_FORMAT_IEC61937) { // HDMI pass-through?
Mikhail Naganov55773032020-10-01 15:08:13 -0700493 flags = static_cast<audio_output_flags_t>(flags | AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800494 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800495
496 // validate parameters
Dima Zavinfce7a472011-04-19 22:30:36 -0700497 if (!audio_is_valid_format(format)) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700498 ALOGE("%s(): Invalid format %#x", __func__, format);
Eric Laurentf32d7812017-11-30 14:44:07 -0800499 status = BAD_VALUE;
500 goto exit;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800501 }
Glenn Kastendd5f4c82014-01-13 10:26:32 -0800502 mFormat = format;
Eric Laurentc2f1f072009-07-17 12:17:14 -0700503
Glenn Kasten8ba90322013-10-30 11:29:27 -0700504 if (!audio_is_output_channel(channelMask)) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700505 ALOGE("%s(): Invalid channel mask %#x", __func__, channelMask);
Eric Laurentf32d7812017-11-30 14:44:07 -0800506 status = BAD_VALUE;
507 goto exit;
Glenn Kasten8ba90322013-10-30 11:29:27 -0700508 }
Glenn Kastene3247bf2014-02-24 15:19:07 -0800509 mChannelMask = channelMask;
Eric Laurentf32d7812017-11-30 14:44:07 -0800510 channelCount = audio_channel_count_from_out_mask(channelMask);
Glenn Kastene3247bf2014-02-24 15:19:07 -0800511 mChannelCount = channelCount;
Glenn Kasten8ba90322013-10-30 11:29:27 -0700512
Eric Laurentc2f1f072009-07-17 12:17:14 -0700513 // force direct flag if format is not linear PCM
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100514 // or offload was requested
515 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
516 || !audio_is_linear_pcm(format)) {
517 ALOGV( (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
Andy Hungfb8ede22018-09-12 19:03:24 -0700518 ? "%s(): Offload request, forcing to Direct Output"
519 : "%s(): Not linear PCM, forcing to Direct Output",
520 __func__);
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700521 flags = (audio_output_flags_t)
Glenn Kasten3acbd052012-02-28 10:39:56 -0800522 // FIXME why can't we allow direct AND fast?
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700523 ((flags | AUDIO_OUTPUT_FLAG_DIRECT) & ~AUDIO_OUTPUT_FLAG_FAST);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700524 }
525
Eric Laurentd1f69b02014-12-15 14:33:13 -0800526 // force direct flag if HW A/V sync requested
527 if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
528 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
529 }
530
Glenn Kastenb7730382014-04-30 15:50:31 -0700531 if (flags & AUDIO_OUTPUT_FLAG_DIRECT) {
Phil Burkfdb3c072016-02-09 10:47:02 -0800532 if (audio_has_proportional_frames(format)) {
Glenn Kastenb7730382014-04-30 15:50:31 -0700533 mFrameSize = channelCount * audio_bytes_per_sample(format);
534 } else {
535 mFrameSize = sizeof(uint8_t);
536 }
Glenn Kastene3aa6592012-12-04 12:22:46 -0800537 } else {
Phil Burkfdb3c072016-02-09 10:47:02 -0800538 ALOG_ASSERT(audio_has_proportional_frames(format));
Glenn Kastenb7730382014-04-30 15:50:31 -0700539 mFrameSize = channelCount * audio_bytes_per_sample(format);
Glenn Kastenb7730382014-04-30 15:50:31 -0700540 // createTrack will return an error if PCM format is not supported by server,
541 // so no need to check for specific PCM formats here
Glenn Kastene3aa6592012-12-04 12:22:46 -0800542 }
543
Eric Laurent0d6db582014-11-12 18:39:44 -0800544 // sampling rate must be specified for direct outputs
545 if (sampleRate == 0 && (flags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
Eric Laurentf32d7812017-11-30 14:44:07 -0800546 status = BAD_VALUE;
547 goto exit;
Eric Laurent0d6db582014-11-12 18:39:44 -0800548 }
549 mSampleRate = sampleRate;
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700550 mOriginalSampleRate = sampleRate;
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -0700551 mPlaybackRate = AUDIO_PLAYBACK_RATE_DEFAULT;
Andy Hungff874dc2016-04-11 16:49:09 -0700552 // 1.0 <= mMaxRequiredSpeed <= AUDIO_TIMESTRETCH_SPEED_MAX
553 mMaxRequiredSpeed = min(max(maxRequiredSpeed, 1.0f), AUDIO_TIMESTRETCH_SPEED_MAX);
Eric Laurent0d6db582014-11-12 18:39:44 -0800554
Glenn Kastenb5ccb2d2014-01-13 14:42:43 -0800555 // Make copy of input parameter offloadInfo so that in the future:
556 // (a) createTrack_l doesn't need it as an input parameter
557 // (b) we can support re-creation of offloaded tracks
558 if (offloadInfo != NULL) {
559 mOffloadInfoCopy = *offloadInfo;
560 mOffloadInfo = &mOffloadInfoCopy;
561 } else {
562 mOffloadInfo = NULL;
Eric Laurent20b9ef02016-12-05 11:03:16 -0800563 memset(&mOffloadInfoCopy, 0, sizeof(audio_offload_info_t));
Ytai Ben-Tsviffa2fd92020-10-20 09:13:53 -0700564 mOffloadInfoCopy = AUDIO_INFO_INITIALIZER;
Glenn Kastenb5ccb2d2014-01-13 14:42:43 -0800565 }
566
Glenn Kasten66e46352014-01-16 17:44:23 -0800567 mVolume[AUDIO_INTERLEAVE_LEFT] = 1.0f;
568 mVolume[AUDIO_INTERLEAVE_RIGHT] = 1.0f;
Glenn Kasten05632a52012-01-03 14:22:33 -0800569 mSendLevel = 0.0f;
Glenn Kasten396fabd2014-01-08 08:54:23 -0800570 // mFrameCount is initialized in createTrack_l
Glenn Kastenb6037442012-11-14 13:42:25 -0800571 mReqFrameCount = frameCount;
Glenn Kastenea38ee72016-04-18 11:08:01 -0700572 if (notificationFrames >= 0) {
573 mNotificationFramesReq = notificationFrames;
574 mNotificationsPerBufferReq = 0;
575 } else {
576 if (!(flags & AUDIO_OUTPUT_FLAG_FAST)) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700577 ALOGE("%s(): notificationFrames=%d not permitted for non-fast track",
578 __func__, notificationFrames);
Eric Laurentf32d7812017-11-30 14:44:07 -0800579 status = BAD_VALUE;
580 goto exit;
Glenn Kastenea38ee72016-04-18 11:08:01 -0700581 }
582 if (frameCount > 0) {
Andy Hungfb8ede22018-09-12 19:03:24 -0700583 ALOGE("%s(): notificationFrames=%d not permitted with non-zero frameCount=%zu",
584 __func__, notificationFrames, frameCount);
Eric Laurentf32d7812017-11-30 14:44:07 -0800585 status = BAD_VALUE;
586 goto exit;
Glenn Kastenea38ee72016-04-18 11:08:01 -0700587 }
588 mNotificationFramesReq = 0;
589 const uint32_t minNotificationsPerBuffer = 1;
590 const uint32_t maxNotificationsPerBuffer = 8;
591 mNotificationsPerBufferReq = min(maxNotificationsPerBuffer,
592 max((uint32_t) -notificationFrames, minNotificationsPerBuffer));
593 ALOGW_IF(mNotificationsPerBufferReq != (uint32_t) -notificationFrames,
Andy Hungfb8ede22018-09-12 19:03:24 -0700594 "%s(): notificationFrames=%d clamped to the range -%u to -%u",
595 __func__,
Glenn Kastenea38ee72016-04-18 11:08:01 -0700596 notificationFrames, minNotificationsPerBuffer, maxNotificationsPerBuffer);
597 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800598 mNotificationFramesAct = 0;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700599 // TODO b/182392553: refactor or remove
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000600 mClientAttributionSource = AttributionSourceState(attributionSource);
Eric Laurentf32d7812017-11-30 14:44:07 -0800601 callingPid = IPCThreadState::self()->getCallingPid();
602 myPid = getpid();
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700603 if (uid == -1 || (callingPid != myPid)) {
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000604 mClientAttributionSource.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700605 IPCThreadState::self()->getCallingUid()));
Marco Nelissen462fd2f2013-01-14 14:12:05 -0800606 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700607 if (pid == (pid_t)-1 || (callingPid != myPid)) {
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000608 mClientAttributionSource.pid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(callingPid));
Marco Nelissend457c972014-02-11 08:47:07 -0800609 }
Eric Laurent2beeb502010-07-16 07:43:46 -0700610 mAuxEffectId = 0;
Haynes Mathew Georgeae34ed22016-01-28 11:58:39 -0800611 mOrigFlags = mFlags = flags;
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000612 mCbf = cbf;
Eric Laurentbe916aa2010-06-01 23:49:17 -0700613
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000614 if (cbf != NULL) {
615 mAudioTrackThread = new AudioTrackThread(*this);
Glenn Kastena997e7a2012-08-07 09:44:19 -0700616 mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/);
Glenn Kastenbfd31842015-03-20 09:01:44 -0700617 // thread begins in paused state, and will not reference us until start()
Glenn Kastena997e7a2012-08-07 09:44:19 -0700618 }
619
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800620 // create the IAudioTrack
Francois Gaffie24a9fb02019-01-18 17:51:34 +0100621 {
622 AutoMutex lock(mLock);
623 status = createTrack_l();
624 }
Glenn Kastena997e7a2012-08-07 09:44:19 -0700625 if (status != NO_ERROR) {
626 if (mAudioTrackThread != 0) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100627 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h
628 mAudioTrackThread->requestExitAndWait();
Glenn Kastena997e7a2012-08-07 09:44:19 -0700629 mAudioTrackThread.clear();
630 }
Eric Laurentf32d7812017-11-30 14:44:07 -0800631 goto exit;
Glenn Kasten5d464eb2012-06-22 17:19:53 -0700632 }
633
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000634 mUserData = user;
Andy Hung4ede21d2014-12-12 15:37:34 -0800635 mLoopCount = 0;
636 mLoopStart = 0;
637 mLoopEnd = 0;
Andy Hung53c3b5f2014-12-15 16:42:05 -0800638 mLoopCountNotified = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800639 mMarkerPosition = 0;
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700640 mMarkerReached = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800641 mNewPosition = 0;
642 mUpdatePeriod = 0;
Glenn Kasten200092b2014-08-15 15:13:30 -0700643 mPosition = 0;
644 mReleased = 0;
Andy Hungffa36952017-08-17 10:41:51 -0700645 mStartNs = 0;
646 mStartFromZeroUs = 0;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700647 AudioSystem::acquireAudioSessionId(mSessionId, pid, uid);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800648 mSequence = 1;
649 mObservedSequence = mSequence;
650 mInUnderrun = false;
Phil Burk1b420972015-04-22 10:52:21 -0700651 mPreviousTimestampValid = false;
Andy Hungc8e09c62015-06-03 23:43:36 -0700652 mTimestampStartupGlitchReported = false;
Andy Hungcf3b7152019-04-19 18:29:21 -0700653 mTimestampRetrogradePositionReported = false;
654 mTimestampRetrogradeTimeReported = false;
655 mTimestampStallReported = false;
656 mTimestampStaleTimeReported = false;
Andy Hungb01faa32016-04-27 12:51:32 -0700657 mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;
Andy Hung65ffdfc2016-10-10 15:52:11 -0700658 mStartTs.mPosition = 0;
Phil Burk2812d9e2016-01-04 10:34:30 -0800659 mUnderrunCountOffset = 0;
Andy Hungea2b9c02016-02-12 17:06:53 -0800660 mFramesWritten = 0;
661 mFramesWrittenServerOffset = 0;
Andy Hungf20a4e92016-08-15 19:10:34 -0700662 mFramesWrittenAtRestore = -1; // -1 is a unique initializer.
Ivan Lozano8cf3a072017-08-09 09:01:33 -0700663 mVolumeHandler = new media::VolumeHandler();
Eric Laurentf32d7812017-11-30 14:44:07 -0800664
665exit:
666 mStatus = status;
667 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800668}
669
Mikhail Naganov55773032020-10-01 15:08:13 -0700670
671status_t AudioTrack::set(
672 audio_stream_type_t streamType,
673 uint32_t sampleRate,
674 audio_format_t format,
675 uint32_t channelMask,
676 size_t frameCount,
677 audio_output_flags_t flags,
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000678 callback_t cbf,
Mikhail Naganov55773032020-10-01 15:08:13 -0700679 void* user,
680 int32_t notificationFrames,
681 const sp<IMemory>& sharedBuffer,
682 bool threadCanCallJava,
683 audio_session_t sessionId,
684 transfer_type transferType,
685 const audio_offload_info_t *offloadInfo,
686 uid_t uid,
687 pid_t pid,
688 const audio_attributes_t* pAttributes,
689 bool doNotReconnect,
690 float maxRequiredSpeed,
691 audio_port_handle_t selectedDeviceId)
692{
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000693 AttributionSourceState attributionSource;
694 attributionSource.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(uid));
695 attributionSource.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(pid));
696 attributionSource.token = sp<BBinder>::make();
Daniel Chapinf13b98a2021-10-25 21:58:31 +0000697 return set(streamType, sampleRate, format,
698 static_cast<audio_channel_mask_t>(channelMask),
699 frameCount, flags, cbf, user, notificationFrames, sharedBuffer,
700 threadCanCallJava, sessionId, transferType, offloadInfo, attributionSource,
701 pAttributes, doNotReconnect, maxRequiredSpeed, selectedDeviceId);
Mikhail Naganov55773032020-10-01 15:08:13 -0700702}
703
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800704// -------------------------------------------------------------------------
705
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100706status_t AudioTrack::start()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800707{
Eric Laurentf5aafb22010-11-18 08:40:16 -0800708 AutoMutex lock(mLock);
Andy Hungb68f5eb2019-12-03 16:49:17 -0800709
Andy Hung10fb4be2020-05-27 22:22:22 -0700710 if (mState == STATE_ACTIVE) {
711 return INVALID_OPERATION;
712 }
713
714 ALOGV("%s(%d): prior state:%s", __func__, mPortId, stateToString(mState));
715
716 // Defer logging here due to OpenSL ES repeated start calls.
717 // TODO(b/154868033) after fix, restore this logging back to the beginning of start().
718 const int64_t beginNs = systemTime();
Andy Hungb68f5eb2019-12-03 16:49:17 -0800719 status_t status = NO_ERROR; // logged: make sure to set this before returning.
Andy Hung06a730b2020-04-09 13:28:31 -0700720 mediametrics::Defer defer([&] {
Andy Hungb68f5eb2019-12-03 16:49:17 -0800721 mediametrics::LogItem(mMetricsId)
Andy Hunga6b27032020-04-27 10:34:24 -0700722 .set(AMEDIAMETRICS_PROP_CALLERNAME,
723 mCallerName.empty()
724 ? AMEDIAMETRICS_PROP_CALLERNAME_VALUE_UNKNOWN
725 : mCallerName.c_str())
Andy Hungb68f5eb2019-12-03 16:49:17 -0800726 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_START)
Andy Hungea840382020-05-05 21:50:17 -0700727 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
Andy Hungb68f5eb2019-12-03 16:49:17 -0800728 .set(AMEDIAMETRICS_PROP_STATE, stateToString(mState))
729 .set(AMEDIAMETRICS_PROP_STATUS, (int32_t)status)
730 .record(); });
731
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800732
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800733 mInUnderrun = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800734
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800735 State previousState = mState;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100736 if (previousState == STATE_PAUSED_STOPPING) {
737 mState = STATE_STOPPING;
738 } else {
739 mState = STATE_ACTIVE;
740 }
Glenn Kasten200092b2014-08-15 15:13:30 -0700741 (void) updateAndGetPosition_l();
Andy Hung65ffdfc2016-10-10 15:52:11 -0700742
743 // save start timestamp
744 if (isOffloadedOrDirect_l()) {
745 if (getTimestamp_l(mStartTs) != OK) {
746 mStartTs.mPosition = 0;
747 }
748 } else {
749 if (getTimestamp_l(&mStartEts) != OK) {
750 mStartEts.clear();
751 }
752 }
Andy Hungffa36952017-08-17 10:41:51 -0700753 mStartNs = systemTime(); // save this for timestamp adjustment after starting.
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800754 if (previousState == STATE_STOPPED || previousState == STATE_FLUSHED) {
755 // reset current position as seen by client to 0
Glenn Kasten200092b2014-08-15 15:13:30 -0700756 mPosition = 0;
Phil Burk1b420972015-04-22 10:52:21 -0700757 mPreviousTimestampValid = false;
Andy Hungc8e09c62015-06-03 23:43:36 -0700758 mTimestampStartupGlitchReported = false;
Andy Hungcf3b7152019-04-19 18:29:21 -0700759 mTimestampRetrogradePositionReported = false;
760 mTimestampRetrogradeTimeReported = false;
761 mTimestampStallReported = false;
762 mTimestampStaleTimeReported = false;
Andy Hungb01faa32016-04-27 12:51:32 -0700763 mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;
Phil Burk1b420972015-04-22 10:52:21 -0700764
Andy Hung65ffdfc2016-10-10 15:52:11 -0700765 if (!isOffloadedOrDirect_l()
766 && mStartEts.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] > 0) {
Andy Hunge1e98462016-04-12 10:18:51 -0700767 // Server side has consumed something, but is it finished consuming?
768 // It is possible since flush and stop are asynchronous that the server
769 // is still active at this point.
Andy Hungfb8ede22018-09-12 19:03:24 -0700770 ALOGV("%s(%d): server read:%lld cumulative flushed:%lld client written:%lld",
Eric Laurent973db022018-11-20 14:54:31 -0800771 __func__, mPortId,
Andy Hunge1e98462016-04-12 10:18:51 -0700772 (long long)(mFramesWrittenServerOffset
Andy Hung65ffdfc2016-10-10 15:52:11 -0700773 + mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER]),
774 (long long)mStartEts.mFlushed,
Andy Hunge1e98462016-04-12 10:18:51 -0700775 (long long)mFramesWritten);
Andy Hungc4e60eb2017-09-06 11:14:57 -0700776 // mStartEts is already adjusted by mFramesWrittenServerOffset, so we delta adjust.
777 mFramesWrittenServerOffset -= mStartEts.mPosition[ExtendedTimestamp::LOCATION_SERVER];
Andy Hung61be8412015-10-06 10:51:09 -0700778 }
Andy Hunge1e98462016-04-12 10:18:51 -0700779 mFramesWritten = 0;
780 mProxy->clearTimestamp(); // need new server push for valid timestamp
781 mMarkerReached = false;
Andy Hung61be8412015-10-06 10:51:09 -0700782
Andy Hung7f1bc8a2014-09-12 14:43:11 -0700783 // For offloaded tracks, we don't know if the hardware counters are really zero here,
784 // since the flush is asynchronous and stop may not fully drain.
785 // We save the time when the track is started to later verify whether
786 // the counters are realistic (i.e. start from zero after this time).
Andy Hungffa36952017-08-17 10:41:51 -0700787 mStartFromZeroUs = mStartNs / 1000;
Andy Hung7f1bc8a2014-09-12 14:43:11 -0700788
Eric Laurentec9a0322013-08-28 10:23:01 -0700789 // force refresh of remaining frames by processAudioBuffer() as last
790 // write before stop could be partial.
791 mRefreshRemaining = true;
Tomoharu Kasahara6e8bf982017-06-09 16:17:33 +0900792
793 // for static track, clear the old flags when starting from stopped state
794 if (mSharedBuffer != 0) {
795 android_atomic_and(
796 ~(CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END),
797 &mCblk->mFlags);
798 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800799 }
Glenn Kasten200092b2014-08-15 15:13:30 -0700800 mNewPosition = mPosition + mUpdatePeriod;
Andy Hung4be3b832016-10-13 17:51:43 -0700801 int32_t flags = android_atomic_and(~(CBLK_STREAM_END_DONE | CBLK_DISABLED), &mCblk->mFlags);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800802
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800803 if (!(flags & CBLK_INVALID)) {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -0800804 mAudioTrack->start(&status);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800805 if (status == DEAD_OBJECT) {
806 flags |= CBLK_INVALID;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800807 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800808 }
809 if (flags & CBLK_INVALID) {
810 status = restoreTrack_l("start");
811 }
812
Andy Hung79629f02016-03-24 13:57:40 -0700813 // resume or pause the callback thread as needed.
814 sp<AudioTrackThread> t = mAudioTrackThread;
815 if (status == NO_ERROR) {
816 if (t != 0) {
817 if (previousState == STATE_STOPPING) {
818 mProxy->interrupt();
819 } else {
820 t->resume();
821 }
822 } else {
823 mPreviousPriority = getpriority(PRIO_PROCESS, 0);
824 get_sched_policy(0, &mPreviousSchedulingGroup);
825 androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
826 }
Andy Hung39399b62017-04-21 15:07:45 -0700827
828 // Start our local VolumeHandler for restoration purposes.
829 mVolumeHandler->setStarted();
Andy Hung79629f02016-03-24 13:57:40 -0700830 } else {
Eric Laurent973db022018-11-20 14:54:31 -0800831 ALOGE("%s(%d): status %d", __func__, mPortId, status);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800832 mState = previousState;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800833 if (t != 0) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100834 if (previousState != STATE_STOPPING) {
835 t->pause();
836 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800837 } else {
Glenn Kasten87913512011-06-22 16:15:25 -0700838 setpriority(PRIO_PROCESS, 0, mPreviousPriority);
Glenn Kastena6364332012-04-19 09:35:04 -0700839 set_sched_policy(0, mPreviousSchedulingGroup);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800840 }
841 }
842
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100843 return status;
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800844}
845
846void AudioTrack::stop()
847{
Andy Hungb68f5eb2019-12-03 16:49:17 -0800848 const int64_t beginNs = systemTime();
849
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800850 AutoMutex lock(mLock);
Andy Hung06a730b2020-04-09 13:28:31 -0700851 mediametrics::Defer defer([&]() {
Andy Hungb68f5eb2019-12-03 16:49:17 -0800852 mediametrics::LogItem(mMetricsId)
853 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_STOP)
Andy Hungea840382020-05-05 21:50:17 -0700854 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
Andy Hungb68f5eb2019-12-03 16:49:17 -0800855 .set(AMEDIAMETRICS_PROP_STATE, stateToString(mState))
Phil Burk64e16a72020-06-01 13:25:51 -0700856 .set(AMEDIAMETRICS_PROP_BUFFERSIZEFRAMES, (int32_t)mProxy->getBufferSizeInFrames())
857 .set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t) getUnderrunCount_l())
Phil Burka9876702020-04-20 18:16:15 -0700858 .record();
Phil Burka9876702020-04-20 18:16:15 -0700859 });
Andy Hungb68f5eb2019-12-03 16:49:17 -0800860
Eric Laurent973db022018-11-20 14:54:31 -0800861 ALOGV("%s(%d): prior state:%s", __func__, mPortId, stateToString(mState));
Andy Hungfb8ede22018-09-12 19:03:24 -0700862
Glenn Kasten397edb32013-08-30 15:10:13 -0700863 if (mState != STATE_ACTIVE && mState != STATE_PAUSED) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800864 return;
865 }
866
Glenn Kasten23a75452014-01-13 10:37:17 -0800867 if (isOffloaded_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100868 mState = STATE_STOPPING;
869 } else {
870 mState = STATE_STOPPED;
Andy Hung2148bf02016-11-28 19:01:02 -0800871 ALOGD_IF(mSharedBuffer == nullptr,
Eric Laurent973db022018-11-20 14:54:31 -0800872 "%s(%d): called with %u frames delivered", __func__, mPortId, mReleased.value());
Andy Hungc2813e52014-10-16 17:54:34 -0700873 mReleased = 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100874 }
875
Andy Hung1d3556d2018-03-29 16:30:14 -0700876 mProxy->stop(); // notify server not to read beyond current client position until start().
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800877 mProxy->interrupt();
878 mAudioTrack->stop();
Andy Hung61be8412015-10-06 10:51:09 -0700879
880 // Note: legacy handling - stop does not clear playback marker
881 // and periodic update counter, but flush does for streaming tracks.
Andy Hung9b461582014-12-01 17:56:29 -0800882
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800883 if (mSharedBuffer != 0) {
Andy Hung9b461582014-12-01 17:56:29 -0800884 // clear buffer position and loop count.
Andy Hung9b461582014-12-01 17:56:29 -0800885 mStaticProxy->setBufferPositionAndLoop(0 /* position */,
886 0 /* loopStart */, 0 /* loopEnd */, 0 /* loopCount */);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800887 }
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100888
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800889 sp<AudioTrackThread> t = mAudioTrackThread;
890 if (t != 0) {
Glenn Kasten23a75452014-01-13 10:37:17 -0800891 if (!isOffloaded_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100892 t->pause();
Jean-Michel Trivia60e9a22018-11-15 16:13:36 -0800893 } else if (mTransfer == TRANSFER_SYNC_NOTIF_CALLBACK) {
Jean-Michel Trivi0248a2a2018-11-21 10:05:57 -0800894 // causes wake up of the playback thread, that will callback the client for
895 // EVENT_STREAM_END in processAudioBuffer()
896 t->wake();
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100897 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800898 } else {
899 setpriority(PRIO_PROCESS, 0, mPreviousPriority);
900 set_sched_policy(0, mPreviousSchedulingGroup);
901 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800902}
903
904bool AudioTrack::stopped() const
905{
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800906 AutoMutex lock(mLock);
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800907 return mState != STATE_ACTIVE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800908}
909
910void AudioTrack::flush()
911{
Andy Hungb68f5eb2019-12-03 16:49:17 -0800912 const int64_t beginNs = systemTime();
Andy Hungfb8ede22018-09-12 19:03:24 -0700913 AutoMutex lock(mLock);
Andy Hung06a730b2020-04-09 13:28:31 -0700914 mediametrics::Defer defer([&]() {
Andy Hungb68f5eb2019-12-03 16:49:17 -0800915 mediametrics::LogItem(mMetricsId)
916 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_FLUSH)
Andy Hungea840382020-05-05 21:50:17 -0700917 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
Andy Hungb68f5eb2019-12-03 16:49:17 -0800918 .set(AMEDIAMETRICS_PROP_STATE, stateToString(mState))
919 .record(); });
920
Eric Laurent973db022018-11-20 14:54:31 -0800921 ALOGV("%s(%d): prior state:%s", __func__, mPortId, stateToString(mState));
Andy Hungfb8ede22018-09-12 19:03:24 -0700922
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800923 if (mSharedBuffer != 0) {
924 return;
Glenn Kasten4bae3642012-11-30 13:41:12 -0800925 }
Andy Hung4c5ed302018-05-09 11:16:21 -0700926 if (mState == STATE_ACTIVE) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800927 return;
928 }
929 flush_l();
Eric Laurent1703cdf2011-03-07 14:52:59 -0800930}
931
Eric Laurent1703cdf2011-03-07 14:52:59 -0800932void AudioTrack::flush_l()
933{
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800934 ALOG_ASSERT(mState != STATE_ACTIVE);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700935
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700936 // clear playback marker and periodic update counter
937 mMarkerPosition = 0;
938 mMarkerReached = false;
939 mUpdatePeriod = 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100940 mRefreshRemaining = true;
Eric Laurentc2f1f072009-07-17 12:17:14 -0700941
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800942 mState = STATE_FLUSHED;
Andy Hungc2813e52014-10-16 17:54:34 -0700943 mReleased = 0;
Glenn Kasten23a75452014-01-13 10:37:17 -0800944 if (isOffloaded_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +0100945 mProxy->interrupt();
946 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800947 mProxy->flush();
Glenn Kasten4bae3642012-11-30 13:41:12 -0800948 mAudioTrack->flush();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800949}
950
Andy Hung959b5b82021-09-24 10:46:20 -0700951bool AudioTrack::pauseAndWait(const std::chrono::milliseconds& timeout)
952{
953 using namespace std::chrono_literals;
954
955 pause();
956
957 AutoMutex lock(mLock);
958 // offload and direct tracks do not wait because pause volume ramp is handled by hardware.
959 if (isOffloadedOrDirect_l()) return true;
960
961 // Wait for the track state to be anything besides pausing.
962 // This ensures that the volume has ramped down.
963 constexpr auto SLEEP_INTERVAL_MS = 10ms;
964 auto begin = std::chrono::steady_clock::now();
965 while (true) {
966 // wait for state to change
967 const int state = mProxy->getState();
968
969 mLock.unlock(); // only local variables accessed until lock.
970 auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
971 std::chrono::steady_clock::now() - begin);
972 if (state != CBLK_STATE_PAUSING) {
973 ALOGV("%s: success state:%d after %lld ms", __func__, state, elapsed.count());
974 return true;
975 }
976 std::chrono::milliseconds remaining = timeout - elapsed;
977 if (remaining.count() <= 0) {
978 ALOGW("%s: timeout expired state:%d still pausing:%d after %lld ms",
979 __func__, state, CBLK_STATE_PAUSING, elapsed.count());
980 return false;
981 }
982 // It is conceivable that the track is restored while sleeping;
983 // as this logic is advisory, we allow that.
984 std::this_thread::sleep_for(std::min(remaining, SLEEP_INTERVAL_MS));
985 mLock.lock();
986 }
987}
988
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800989void AudioTrack::pause()
990{
Andy Hungb68f5eb2019-12-03 16:49:17 -0800991 const int64_t beginNs = systemTime();
Eric Laurentf5aafb22010-11-18 08:40:16 -0800992 AutoMutex lock(mLock);
Andy Hunga6b27032020-04-27 10:34:24 -0700993 mediametrics::Defer defer([&]() {
Andy Hungb68f5eb2019-12-03 16:49:17 -0800994 mediametrics::LogItem(mMetricsId)
995 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_PAUSE)
Andy Hungea840382020-05-05 21:50:17 -0700996 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
Andy Hungb68f5eb2019-12-03 16:49:17 -0800997 .set(AMEDIAMETRICS_PROP_STATE, stateToString(mState))
998 .record(); });
999
Eric Laurent973db022018-11-20 14:54:31 -08001000 ALOGV("%s(%d): prior state:%s", __func__, mPortId, stateToString(mState));
Andy Hungfb8ede22018-09-12 19:03:24 -07001001
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001002 if (mState == STATE_ACTIVE) {
1003 mState = STATE_PAUSED;
1004 } else if (mState == STATE_STOPPING) {
1005 mState = STATE_PAUSED_STOPPING;
1006 } else {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001007 return;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001008 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001009 mProxy->interrupt();
1010 mAudioTrack->pause();
Haynes Mathew George7064fd22014-01-08 13:59:53 -08001011
Marco Nelissen3a90f282014-03-10 11:21:43 -07001012 if (isOffloaded_l()) {
Glenn Kasten142f5192014-03-25 17:44:59 -07001013 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Andy Hung7f1bc8a2014-09-12 14:43:11 -07001014 // An offload output can be re-used between two audio tracks having
1015 // the same configuration. A timestamp query for a paused track
1016 // while the other is running would return an incorrect time.
1017 // To fix this, cache the playback position on a pause() and return
1018 // this time when requested until the track is resumed.
1019
1020 // OffloadThread sends HAL pause in its threadLoop. Time saved
1021 // here can be slightly off.
1022
1023 // TODO: check return code for getRenderPosition.
1024
Haynes Mathew George7064fd22014-01-08 13:59:53 -08001025 uint32_t halFrames;
Haynes Mathew George7064fd22014-01-08 13:59:53 -08001026 AudioSystem::getRenderPosition(mOutput, &halFrames, &mPausedPosition);
Andy Hungfb8ede22018-09-12 19:03:24 -07001027 ALOGV("%s(%d): for offload, cache current position %u",
Eric Laurent973db022018-11-20 14:54:31 -08001028 __func__, mPortId, mPausedPosition);
Haynes Mathew George7064fd22014-01-08 13:59:53 -08001029 }
1030 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001031}
1032
Eric Laurentbe916aa2010-06-01 23:49:17 -07001033status_t AudioTrack::setVolume(float left, float right)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001034{
Glenn Kastenc56f3422014-03-21 17:53:17 -07001035 // This duplicates a test by AudioTrack JNI, but that is not the only caller
1036 if (isnanf(left) || left < GAIN_FLOAT_ZERO || left > GAIN_FLOAT_UNITY ||
1037 isnanf(right) || right < GAIN_FLOAT_ZERO || right > GAIN_FLOAT_UNITY) {
Eric Laurentbe916aa2010-06-01 23:49:17 -07001038 return BAD_VALUE;
1039 }
1040
Andy Hungb68f5eb2019-12-03 16:49:17 -08001041 mediametrics::LogItem(mMetricsId)
1042 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETVOLUME)
1043 .set(AMEDIAMETRICS_PROP_VOLUME_LEFT, (double)left)
1044 .set(AMEDIAMETRICS_PROP_VOLUME_RIGHT, (double)right)
1045 .record();
1046
Eric Laurent1703cdf2011-03-07 14:52:59 -08001047 AutoMutex lock(mLock);
Glenn Kasten66e46352014-01-16 17:44:23 -08001048 mVolume[AUDIO_INTERLEAVE_LEFT] = left;
1049 mVolume[AUDIO_INTERLEAVE_RIGHT] = right;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001050
Glenn Kastenc56f3422014-03-21 17:53:17 -07001051 mProxy->setVolumeLR(gain_minifloat_pack(gain_from_float(left), gain_from_float(right)));
Eric Laurentbe916aa2010-06-01 23:49:17 -07001052
Glenn Kasten23a75452014-01-13 10:37:17 -08001053 if (isOffloaded_l()) {
Eric Laurent59fe0102013-09-27 18:48:26 -07001054 mAudioTrack->signal();
1055 }
Eric Laurentbe916aa2010-06-01 23:49:17 -07001056 return NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001057}
1058
Glenn Kastenb1c09932012-02-27 16:21:04 -08001059status_t AudioTrack::setVolume(float volume)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001060{
Glenn Kastenb1c09932012-02-27 16:21:04 -08001061 return setVolume(volume, volume);
Eric Laurentbe916aa2010-06-01 23:49:17 -07001062}
1063
Eric Laurent2beeb502010-07-16 07:43:46 -07001064status_t AudioTrack::setAuxEffectSendLevel(float level)
Eric Laurentbe916aa2010-06-01 23:49:17 -07001065{
Glenn Kastenc56f3422014-03-21 17:53:17 -07001066 // This duplicates a test by AudioTrack JNI, but that is not the only caller
1067 if (isnanf(level) || level < GAIN_FLOAT_ZERO || level > GAIN_FLOAT_UNITY) {
Eric Laurentbe916aa2010-06-01 23:49:17 -07001068 return BAD_VALUE;
1069 }
1070
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001071 AutoMutex lock(mLock);
Eric Laurentbe916aa2010-06-01 23:49:17 -07001072 mSendLevel = level;
Glenn Kastene3aa6592012-12-04 12:22:46 -08001073 mProxy->setSendLevel(level);
Eric Laurentbe916aa2010-06-01 23:49:17 -07001074
1075 return NO_ERROR;
1076}
1077
Glenn Kastena5224f32012-01-04 12:41:44 -08001078void AudioTrack::getAuxEffectSendLevel(float* level) const
Eric Laurentbe916aa2010-06-01 23:49:17 -07001079{
1080 if (level != NULL) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001081 *level = mSendLevel;
Eric Laurentbe916aa2010-06-01 23:49:17 -07001082 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001083}
1084
Glenn Kasten3b16c762012-11-14 08:44:39 -08001085status_t AudioTrack::setSampleRate(uint32_t rate)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001086{
Andy Hung5cbb5782015-03-27 18:39:59 -07001087 AutoMutex lock(mLock);
Eric Laurent973db022018-11-20 14:54:31 -08001088 ALOGV("%s(%d): prior state:%s rate:%u", __func__, mPortId, stateToString(mState), rate);
Andy Hungfb8ede22018-09-12 19:03:24 -07001089
Andy Hung5cbb5782015-03-27 18:39:59 -07001090 if (rate == mSampleRate) {
1091 return NO_ERROR;
1092 }
jiabinf4de6112018-12-19 12:40:08 -08001093 if (isOffloadedOrDirect_l() || (mFlags & AUDIO_OUTPUT_FLAG_FAST)
1094 || (mChannelMask & AUDIO_CHANNEL_HAPTIC_ALL)) {
John Grossman4ff14ba2012-02-08 16:37:41 -08001095 return INVALID_OPERATION;
1096 }
Eric Laurent0d6db582014-11-12 18:39:44 -08001097 if (mOutput == AUDIO_IO_HANDLE_NONE) {
1098 return NO_INIT;
1099 }
Andy Hung5cbb5782015-03-27 18:39:59 -07001100 // NOTE: it is theoretically possible, but highly unlikely, that a device change
1101 // could mean a previously allowed sampling rate is no longer allowed.
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001102 uint32_t afSamplingRate;
Eric Laurent0d6db582014-11-12 18:39:44 -08001103 if (AudioSystem::getSamplingRate(mOutput, &afSamplingRate) != NO_ERROR) {
Eric Laurent57326622009-07-07 07:10:45 -07001104 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001105 }
Andy Hung26145642015-04-15 21:56:53 -07001106 // pitch is emulated by adjusting speed and sampleRate
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001107 const uint32_t effectiveSampleRate = adjustSampleRate(rate, mPlaybackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -07001108 if (rate == 0 || effectiveSampleRate > afSamplingRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001109 return BAD_VALUE;
1110 }
Andy Hung8edb8dc2015-03-26 19:13:55 -07001111 // TODO: Should we also check if the buffer size is compatible?
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001112
Glenn Kastene3aa6592012-12-04 12:22:46 -08001113 mSampleRate = rate;
Andy Hung26145642015-04-15 21:56:53 -07001114 mProxy->setSampleRate(effectiveSampleRate);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001115
Eric Laurent57326622009-07-07 07:10:45 -07001116 return NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001117}
1118
Glenn Kastena5224f32012-01-04 12:41:44 -08001119uint32_t AudioTrack::getSampleRate() const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001120{
Eric Laurent1703cdf2011-03-07 14:52:59 -08001121 AutoMutex lock(mLock);
Eric Laurent6f59db12013-07-26 17:16:50 -07001122
1123 // sample rate can be updated during playback by the offloaded decoder so we need to
1124 // query the HAL and update if needed.
1125// FIXME use Proxy return channel to update the rate from server and avoid polling here
Eric Laurentab5cdba2014-06-09 17:22:27 -07001126 if (isOffloadedOrDirect_l()) {
Glenn Kasten142f5192014-03-25 17:44:59 -07001127 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Eric Laurent6f59db12013-07-26 17:16:50 -07001128 uint32_t sampleRate = 0;
Jean-Michel Trivib7f24b12014-06-11 10:05:30 -07001129 status_t status = AudioSystem::getSamplingRate(mOutput, &sampleRate);
Eric Laurent6f59db12013-07-26 17:16:50 -07001130 if (status == NO_ERROR) {
1131 mSampleRate = sampleRate;
1132 }
1133 }
1134 }
Glenn Kastene3aa6592012-12-04 12:22:46 -08001135 return mSampleRate;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001136}
1137
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001138uint32_t AudioTrack::getOriginalSampleRate() const
1139{
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001140 return mOriginalSampleRate;
1141}
1142
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001143status_t AudioTrack::setDualMonoMode(audio_dual_mono_mode_t mode)
1144{
1145 AutoMutex lock(mLock);
1146 return setDualMonoMode_l(mode);
1147}
1148
1149status_t AudioTrack::setDualMonoMode_l(audio_dual_mono_mode_t mode)
1150{
1151 const status_t status = statusTFromBinderStatus(
1152 mAudioTrack->setDualMonoMode(VALUE_OR_RETURN_STATUS(
1153 legacy2aidl_audio_dual_mono_mode_t_AudioDualMonoMode(mode))));
1154 if (status == NO_ERROR) mDualMonoMode = mode;
1155 return status;
1156}
1157
1158status_t AudioTrack::getDualMonoMode(audio_dual_mono_mode_t* mode) const
1159{
1160 AutoMutex lock(mLock);
1161 media::AudioDualMonoMode mediaMode;
1162 const status_t status = statusTFromBinderStatus(mAudioTrack->getDualMonoMode(&mediaMode));
1163 if (status == NO_ERROR) {
1164 *mode = VALUE_OR_RETURN_STATUS(
1165 aidl2legacy_AudioDualMonoMode_audio_dual_mono_mode_t(mediaMode));
1166 }
1167 return status;
1168}
1169
1170status_t AudioTrack::setAudioDescriptionMixLevel(float leveldB)
1171{
1172 AutoMutex lock(mLock);
1173 return setAudioDescriptionMixLevel_l(leveldB);
1174}
1175
1176status_t AudioTrack::setAudioDescriptionMixLevel_l(float leveldB)
1177{
1178 const status_t status = statusTFromBinderStatus(
1179 mAudioTrack->setAudioDescriptionMixLevel(leveldB));
1180 if (status == NO_ERROR) mAudioDescriptionMixLeveldB = leveldB;
1181 return status;
1182}
1183
1184status_t AudioTrack::getAudioDescriptionMixLevel(float* leveldB) const
1185{
1186 AutoMutex lock(mLock);
1187 return statusTFromBinderStatus(mAudioTrack->getAudioDescriptionMixLevel(leveldB));
1188}
1189
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001190status_t AudioTrack::setPlaybackRate(const AudioPlaybackRate &playbackRate)
Andy Hung8edb8dc2015-03-26 19:13:55 -07001191{
Andy Hung8edb8dc2015-03-26 19:13:55 -07001192 AutoMutex lock(mLock);
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001193 if (isAudioPlaybackRateEqual(playbackRate, mPlaybackRate)) {
Andy Hung8edb8dc2015-03-26 19:13:55 -07001194 return NO_ERROR;
1195 }
Glenn Kastend79072e2016-01-06 08:41:20 -08001196 if (isOffloadedOrDirect_l()) {
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001197 const status_t status = statusTFromBinderStatus(mAudioTrack->setPlaybackRateParameters(
1198 VALUE_OR_RETURN_STATUS(
1199 legacy2aidl_audio_playback_rate_t_AudioPlaybackRate(playbackRate))));
1200 if (status == NO_ERROR) {
1201 mPlaybackRate = playbackRate;
1202 }
1203 return status;
Andy Hung8edb8dc2015-03-26 19:13:55 -07001204 }
1205 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
1206 return INVALID_OPERATION;
1207 }
Andy Hungff874dc2016-04-11 16:49:09 -07001208
Andy Hungfb8ede22018-09-12 19:03:24 -07001209 ALOGV("%s(%d): mSampleRate:%u mSpeed:%f mPitch:%f",
Eric Laurent973db022018-11-20 14:54:31 -08001210 __func__, mPortId, mSampleRate, playbackRate.mSpeed, playbackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -07001211 // pitch is emulated by adjusting speed and sampleRate
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001212 const uint32_t effectiveRate = adjustSampleRate(mSampleRate, playbackRate.mPitch);
1213 const float effectiveSpeed = adjustSpeed(playbackRate.mSpeed, playbackRate.mPitch);
1214 const float effectivePitch = adjustPitch(playbackRate.mPitch);
Ricardo Garcia6c7f0622015-04-30 18:39:16 -07001215 AudioPlaybackRate playbackRateTemp = playbackRate;
1216 playbackRateTemp.mSpeed = effectiveSpeed;
1217 playbackRateTemp.mPitch = effectivePitch;
1218
Andy Hungfb8ede22018-09-12 19:03:24 -07001219 ALOGV("%s(%d) (effective) mSampleRate:%u mSpeed:%f mPitch:%f",
Eric Laurent973db022018-11-20 14:54:31 -08001220 __func__, mPortId, effectiveRate, effectiveSpeed, effectivePitch);
Andy Hungff874dc2016-04-11 16:49:09 -07001221
Ricardo Garcia6c7f0622015-04-30 18:39:16 -07001222 if (!isAudioPlaybackRateValid(playbackRateTemp)) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001223 ALOGW("%s(%d) (%f, %f) failed (effective rate out of bounds)",
Eric Laurent973db022018-11-20 14:54:31 -08001224 __func__, mPortId, playbackRate.mSpeed, playbackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -07001225 return BAD_VALUE;
1226 }
Andy Hung8edb8dc2015-03-26 19:13:55 -07001227 // Check if the buffer size is compatible.
Andy Hung26145642015-04-15 21:56:53 -07001228 if (!isSampleRateSpeedAllowed_l(effectiveRate, effectiveSpeed)) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001229 ALOGW("%s(%d) (%f, %f) failed (buffer size)",
Eric Laurent973db022018-11-20 14:54:31 -08001230 __func__, mPortId, playbackRate.mSpeed, playbackRate.mPitch);
Andy Hung8edb8dc2015-03-26 19:13:55 -07001231 return BAD_VALUE;
1232 }
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001233
Ricardo Garcia6c7f0622015-04-30 18:39:16 -07001234 // Check resampler ratios are within bounds
Glenn Kastend3bb6452016-12-05 18:14:37 -08001235 if ((uint64_t)effectiveRate > (uint64_t)mSampleRate *
1236 (uint64_t)AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001237 ALOGW("%s(%d) (%f, %f) failed. Resample rate exceeds max accepted value",
Eric Laurent973db022018-11-20 14:54:31 -08001238 __func__, mPortId, playbackRate.mSpeed, playbackRate.mPitch);
Ricardo Garcia6c7f0622015-04-30 18:39:16 -07001239 return BAD_VALUE;
1240 }
1241
Dan Austine34eae22015-10-27 16:14:52 -07001242 if ((uint64_t)effectiveRate * (uint64_t)AUDIO_RESAMPLER_UP_RATIO_MAX < (uint64_t)mSampleRate) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001243 ALOGW("%s(%d) (%f, %f) failed. Resample rate below min accepted value",
Eric Laurent973db022018-11-20 14:54:31 -08001244 __func__, mPortId, playbackRate.mSpeed, playbackRate.mPitch);
Ricardo Garcia6c7f0622015-04-30 18:39:16 -07001245 return BAD_VALUE;
1246 }
1247 mPlaybackRate = playbackRate;
1248 //set effective rates
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001249 mProxy->setPlaybackRate(playbackRateTemp);
Andy Hung26145642015-04-15 21:56:53 -07001250 mProxy->setSampleRate(effectiveRate); // FIXME: not quite "atomic" with setPlaybackRate
Andy Hungb68f5eb2019-12-03 16:49:17 -08001251
1252 mediametrics::LogItem(mMetricsId)
1253 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETPLAYBACKPARAM)
1254 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
1255 .set(AMEDIAMETRICS_PROP_PLAYBACK_SPEED, (double)mPlaybackRate.mSpeed)
1256 .set(AMEDIAMETRICS_PROP_PLAYBACK_PITCH, (double)mPlaybackRate.mPitch)
1257 .set(AMEDIAMETRICS_PROP_PREFIX_EFFECTIVE
1258 AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)effectiveRate)
1259 .set(AMEDIAMETRICS_PROP_PREFIX_EFFECTIVE
1260 AMEDIAMETRICS_PROP_PLAYBACK_SPEED, (double)playbackRateTemp.mSpeed)
1261 .set(AMEDIAMETRICS_PROP_PREFIX_EFFECTIVE
1262 AMEDIAMETRICS_PROP_PLAYBACK_PITCH, (double)playbackRateTemp.mPitch)
1263 .record();
1264
Andy Hung8edb8dc2015-03-26 19:13:55 -07001265 return NO_ERROR;
1266}
1267
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001268const AudioPlaybackRate& AudioTrack::getPlaybackRate()
Andy Hung8edb8dc2015-03-26 19:13:55 -07001269{
1270 AutoMutex lock(mLock);
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001271 if (isOffloadedOrDirect_l()) {
1272 media::AudioPlaybackRate playbackRateTemp;
1273 const status_t status = statusTFromBinderStatus(
1274 mAudioTrack->getPlaybackRateParameters(&playbackRateTemp));
1275 if (status == NO_ERROR) { // update local version if changed.
1276 mPlaybackRate =
1277 aidl2legacy_AudioPlaybackRate_audio_playback_rate_t(playbackRateTemp).value();
1278 }
1279 }
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001280 return mPlaybackRate;
Andy Hung8edb8dc2015-03-26 19:13:55 -07001281}
1282
Phil Burkc0adecb2016-01-08 12:44:11 -08001283ssize_t AudioTrack::getBufferSizeInFrames()
1284{
1285 AutoMutex lock(mLock);
1286 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
1287 return NO_INIT;
1288 }
Phil Burka9876702020-04-20 18:16:15 -07001289
Phil Burke8972b02016-03-04 11:29:57 -08001290 return (ssize_t) mProxy->getBufferSizeInFrames();
Phil Burkc0adecb2016-01-08 12:44:11 -08001291}
1292
Andy Hungf2c87b32016-04-07 19:49:29 -07001293status_t AudioTrack::getBufferDurationInUs(int64_t *duration)
1294{
1295 if (duration == nullptr) {
1296 return BAD_VALUE;
1297 }
1298 AutoMutex lock(mLock);
1299 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
1300 return NO_INIT;
1301 }
1302 ssize_t bufferSizeInFrames = (ssize_t) mProxy->getBufferSizeInFrames();
1303 if (bufferSizeInFrames < 0) {
1304 return (status_t)bufferSizeInFrames;
1305 }
1306 *duration = (int64_t)((double)bufferSizeInFrames * 1000000
1307 / ((double)mSampleRate * mPlaybackRate.mSpeed));
1308 return NO_ERROR;
1309}
1310
Phil Burkc0adecb2016-01-08 12:44:11 -08001311ssize_t AudioTrack::setBufferSizeInFrames(size_t bufferSizeInFrames)
1312{
1313 AutoMutex lock(mLock);
1314 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
1315 return NO_INIT;
1316 }
Phil Burka9876702020-04-20 18:16:15 -07001317
1318 ssize_t originalBufferSize = mProxy->getBufferSizeInFrames();
1319 ssize_t finalBufferSize = mProxy->setBufferSizeInFrames((uint32_t) bufferSizeInFrames);
1320 if (originalBufferSize != finalBufferSize) {
Phil Burk64e16a72020-06-01 13:25:51 -07001321 android::mediametrics::LogItem(mMetricsId)
1322 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETBUFFERSIZE)
1323 .set(AMEDIAMETRICS_PROP_BUFFERSIZEFRAMES, (int32_t)mProxy->getBufferSizeInFrames())
1324 .set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t)getUnderrunCount_l())
1325 .record();
Phil Burka9876702020-04-20 18:16:15 -07001326 }
1327 return finalBufferSize;
Phil Burkc0adecb2016-01-08 12:44:11 -08001328}
1329
Andy Hung3c7f47a2021-03-16 17:30:09 -07001330ssize_t AudioTrack::getStartThresholdInFrames() const
1331{
1332 AutoMutex lock(mLock);
1333 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
1334 return NO_INIT;
1335 }
1336 return (ssize_t) mProxy->getStartThresholdInFrames();
1337}
1338
1339ssize_t AudioTrack::setStartThresholdInFrames(size_t startThresholdInFrames)
1340{
1341 if (startThresholdInFrames > INT32_MAX || startThresholdInFrames == 0) {
1342 // contractually we could simply return the current threshold in frames
1343 // to indicate the request was ignored, but we return an error here.
1344 return BAD_VALUE;
1345 }
1346 AutoMutex lock(mLock);
1347 // We do not permit calling setStartThresholdInFrames() between the AudioTrack
1348 // default ctor AudioTrack() and set(...) but rather fail such an attempt.
1349 // (To do so would require a cached mOrigStartThresholdInFrames and we may
1350 // not have proper validation for the actual set value).
1351 if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
1352 return NO_INIT;
1353 }
1354 const uint32_t original = mProxy->getStartThresholdInFrames();
1355 const uint32_t final = mProxy->setStartThresholdInFrames(startThresholdInFrames);
1356 if (original != final) {
1357 android::mediametrics::LogItem(mMetricsId)
1358 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETSTARTTHRESHOLD)
1359 .set(AMEDIAMETRICS_PROP_STARTTHRESHOLDFRAMES, (int32_t)final)
1360 .record();
1361 if (original > final) {
1362 // restart track if it was disabled by audioflinger due to previous underrun
1363 // and we reduced the number of frames for the threshold.
1364 restartIfDisabled();
1365 }
1366 }
1367 return final;
1368}
1369
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001370status_t AudioTrack::setLoop(uint32_t loopStart, uint32_t loopEnd, int loopCount)
1371{
Glenn Kastend79072e2016-01-06 08:41:20 -08001372 if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
Glenn Kasten083d1c12012-11-30 15:00:36 -08001373 return INVALID_OPERATION;
1374 }
1375
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001376 if (loopCount == 0) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001377 ;
1378 } else if (loopCount >= -1 && loopStart < loopEnd && loopEnd <= mFrameCount &&
1379 loopEnd - loopStart >= MIN_LOOP) {
1380 ;
1381 } else {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001382 return BAD_VALUE;
1383 }
1384
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001385 AutoMutex lock(mLock);
1386 // See setPosition() regarding setting parameters such as loop points or position while active
1387 if (mState == STATE_ACTIVE) {
1388 return INVALID_OPERATION;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001389 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001390 setLoop_l(loopStart, loopEnd, loopCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001391 return NO_ERROR;
1392}
1393
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001394void AudioTrack::setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount)
1395{
Andy Hung4ede21d2014-12-12 15:37:34 -08001396 // We do not update the periodic notification point.
1397 // mNewPosition = updateAndGetPosition_l() + mUpdatePeriod;
1398 mLoopCount = loopCount;
1399 mLoopEnd = loopEnd;
1400 mLoopStart = loopStart;
Andy Hung53c3b5f2014-12-15 16:42:05 -08001401 mLoopCountNotified = loopCount;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001402 mStaticProxy->setLoop(loopStart, loopEnd, loopCount);
Andy Hung3c09c782014-12-29 18:39:32 -08001403
1404 // Waking the AudioTrackThread is not needed as this cannot be called when active.
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001405}
1406
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001407status_t AudioTrack::setMarkerPosition(uint32_t marker)
1408{
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001409 // The only purpose of setting marker position is to get a callback
Daniel Chapinf13b98a2021-10-25 21:58:31 +00001410 if (mCbf == NULL || isOffloadedOrDirect()) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001411 return INVALID_OPERATION;
1412 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001413
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001414 AutoMutex lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001415 mMarkerPosition = marker;
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -07001416 mMarkerReached = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001417
Andy Hung3c09c782014-12-29 18:39:32 -08001418 sp<AudioTrackThread> t = mAudioTrackThread;
1419 if (t != 0) {
1420 t->wake();
1421 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001422 return NO_ERROR;
1423}
1424
Glenn Kastena5224f32012-01-04 12:41:44 -08001425status_t AudioTrack::getMarkerPosition(uint32_t *marker) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001426{
Eric Laurentab5cdba2014-06-09 17:22:27 -07001427 if (isOffloadedOrDirect()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001428 return INVALID_OPERATION;
1429 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07001430 if (marker == NULL) {
1431 return BAD_VALUE;
1432 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001433
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001434 AutoMutex lock(mLock);
Andy Hung90e8a972015-11-09 16:42:40 -08001435 mMarkerPosition.getValue(marker);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001436
1437 return NO_ERROR;
1438}
1439
1440status_t AudioTrack::setPositionUpdatePeriod(uint32_t updatePeriod)
1441{
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07001442 // The only purpose of setting position update period is to get a callback
Daniel Chapinf13b98a2021-10-25 21:58:31 +00001443 if (mCbf == NULL || isOffloadedOrDirect()) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001444 return INVALID_OPERATION;
1445 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001446
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001447 AutoMutex lock(mLock);
Glenn Kasten200092b2014-08-15 15:13:30 -07001448 mNewPosition = updateAndGetPosition_l() + updatePeriod;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001449 mUpdatePeriod = updatePeriod;
Glenn Kasten2b2165c2014-01-13 08:53:36 -08001450
Andy Hung3c09c782014-12-29 18:39:32 -08001451 sp<AudioTrackThread> t = mAudioTrackThread;
1452 if (t != 0) {
1453 t->wake();
1454 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001455 return NO_ERROR;
1456}
1457
Glenn Kastena5224f32012-01-04 12:41:44 -08001458status_t AudioTrack::getPositionUpdatePeriod(uint32_t *updatePeriod) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001459{
Eric Laurentab5cdba2014-06-09 17:22:27 -07001460 if (isOffloadedOrDirect()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001461 return INVALID_OPERATION;
1462 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07001463 if (updatePeriod == NULL) {
1464 return BAD_VALUE;
1465 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001466
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001467 AutoMutex lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001468 *updatePeriod = mUpdatePeriod;
1469
1470 return NO_ERROR;
1471}
1472
1473status_t AudioTrack::setPosition(uint32_t position)
1474{
Glenn Kastend79072e2016-01-06 08:41:20 -08001475 if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001476 return INVALID_OPERATION;
1477 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001478 if (position > mFrameCount) {
1479 return BAD_VALUE;
1480 }
John Grossman4ff14ba2012-02-08 16:37:41 -08001481
Eric Laurent1703cdf2011-03-07 14:52:59 -08001482 AutoMutex lock(mLock);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001483 // Currently we require that the player is inactive before setting parameters such as position
1484 // or loop points. Otherwise, there could be a race condition: the application could read the
1485 // current position, compute a new position or loop parameters, and then set that position or
1486 // loop parameters but it would do the "wrong" thing since the position has continued to advance
1487 // in the mean time. If we ever provide a sequencer in server, we could allow a way for the app
1488 // to specify how it wants to handle such scenarios.
1489 if (mState == STATE_ACTIVE) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001490 return INVALID_OPERATION;
1491 }
Andy Hung9b461582014-12-01 17:56:29 -08001492 // After setting the position, use full update period before notification.
Glenn Kasten200092b2014-08-15 15:13:30 -07001493 mNewPosition = updateAndGetPosition_l() + mUpdatePeriod;
Andy Hung9b461582014-12-01 17:56:29 -08001494 mStaticProxy->setBufferPosition(position);
Andy Hung3c09c782014-12-29 18:39:32 -08001495
1496 // Waking the AudioTrackThread is not needed as this cannot be called when active.
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001497 return NO_ERROR;
1498}
1499
Glenn Kasten200092b2014-08-15 15:13:30 -07001500status_t AudioTrack::getPosition(uint32_t *position)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001501{
Glenn Kastend65d73c2012-06-22 17:21:07 -07001502 if (position == NULL) {
1503 return BAD_VALUE;
1504 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001505
Eric Laurent1703cdf2011-03-07 14:52:59 -08001506 AutoMutex lock(mLock);
Andy Hung7a490e72016-03-23 15:58:10 -07001507 // FIXME: offloaded and direct tracks call into the HAL for render positions
1508 // for compressed/synced data; however, we use proxy position for pure linear pcm data
1509 // as we do not know the capability of the HAL for pcm position support and standby.
1510 // There may be some latency differences between the HAL position and the proxy position.
1511 if (isOffloadedOrDirect_l() && !isPurePcmData_l()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001512 uint32_t dspFrames = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001513
Eric Laurentab5cdba2014-06-09 17:22:27 -07001514 if (isOffloaded_l() && ((mState == STATE_PAUSED) || (mState == STATE_PAUSED_STOPPING))) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001515 ALOGV("%s(%d): called in paused state, return cached position %u",
Eric Laurent973db022018-11-20 14:54:31 -08001516 __func__, mPortId, mPausedPosition);
Haynes Mathew George7064fd22014-01-08 13:59:53 -08001517 *position = mPausedPosition;
1518 return NO_ERROR;
1519 }
1520
Glenn Kasten142f5192014-03-25 17:44:59 -07001521 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Andy Hung1f1db832015-06-08 13:26:10 -07001522 uint32_t halFrames; // actually unused
1523 (void) AudioSystem::getRenderPosition(mOutput, &halFrames, &dspFrames);
1524 // FIXME: on getRenderPosition() error, we return OK with frame position 0.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001525 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07001526 // FIXME: dspFrames may not be zero in (mState == STATE_STOPPED || mState == STATE_FLUSHED)
1527 // due to hardware latency. We leave this behavior for now.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001528 *position = dspFrames;
1529 } else {
Eric Laurent275e8e92014-11-30 15:14:47 -08001530 if (mCblk->mFlags & CBLK_INVALID) {
Andy Hung1f1db832015-06-08 13:26:10 -07001531 (void) restoreTrack_l("getPosition");
1532 // FIXME: for compatibility with the Java API we ignore the restoreTrack_l()
1533 // error here (e.g. DEAD_OBJECT) and return OK with the last recorded server position.
Eric Laurent275e8e92014-11-30 15:14:47 -08001534 }
1535
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001536 // IAudioTrack::stop() isn't synchronous; we don't know when presentation completes
Glenn Kasten200092b2014-08-15 15:13:30 -07001537 *position = (mState == STATE_STOPPED || mState == STATE_FLUSHED) ?
Andy Hung90e8a972015-11-09 16:42:40 -08001538 0 : updateAndGetPosition_l().value();
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001539 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001540 return NO_ERROR;
1541}
1542
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001543status_t AudioTrack::getBufferPosition(uint32_t *position)
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001544{
Glenn Kastend79072e2016-01-06 08:41:20 -08001545 if (mSharedBuffer == 0) {
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001546 return INVALID_OPERATION;
1547 }
1548 if (position == NULL) {
1549 return BAD_VALUE;
1550 }
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001551
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001552 AutoMutex lock(mLock);
1553 *position = mStaticProxy->getBufferPosition();
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001554 return NO_ERROR;
1555}
Glenn Kasten9c6745f2012-11-30 13:35:29 -08001556
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001557status_t AudioTrack::reload()
1558{
Glenn Kastend79072e2016-01-06 08:41:20 -08001559 if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
Glenn Kasten083d1c12012-11-30 15:00:36 -08001560 return INVALID_OPERATION;
1561 }
1562
Eric Laurent1703cdf2011-03-07 14:52:59 -08001563 AutoMutex lock(mLock);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001564 // See setPosition() regarding setting parameters such as loop points or position while active
1565 if (mState == STATE_ACTIVE) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001566 return INVALID_OPERATION;
1567 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001568 mNewPosition = mUpdatePeriod;
Andy Hung9b461582014-12-01 17:56:29 -08001569 (void) updateAndGetPosition_l();
1570 mPosition = 0;
Phil Burk1b420972015-04-22 10:52:21 -07001571 mPreviousTimestampValid = false;
Andy Hung53c3b5f2014-12-15 16:42:05 -08001572#if 0
Andy Hung9b461582014-12-01 17:56:29 -08001573 // The documentation is not clear on the behavior of reload() and the restoration
Andy Hung53c3b5f2014-12-15 16:42:05 -08001574 // of loop count. Historically we have not restored loop count, start, end,
1575 // but it makes sense if one desires to repeat playing a particular sound.
1576 if (mLoopCount != 0) {
1577 mLoopCountNotified = mLoopCount;
1578 mStaticProxy->setLoop(mLoopStart, mLoopEnd, mLoopCount);
1579 }
1580#endif
Andy Hung9b461582014-12-01 17:56:29 -08001581 mStaticProxy->setBufferPosition(0);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001582 return NO_ERROR;
1583}
1584
Glenn Kasten38e905b2014-01-13 10:21:48 -08001585audio_io_handle_t AudioTrack::getOutput() const
Eric Laurentc2f1f072009-07-17 12:17:14 -07001586{
Eric Laurent1703cdf2011-03-07 14:52:59 -08001587 AutoMutex lock(mLock);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001588 return mOutput;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001589}
1590
Paul McLeanaa981192015-03-21 09:55:15 -07001591status_t AudioTrack::setOutputDevice(audio_port_handle_t deviceId) {
1592 AutoMutex lock(mLock);
Eric Laurent2f2c1982021-06-02 14:03:11 +02001593 ALOGV("%s(%d): deviceId=%d mSelectedDeviceId=%d",
1594 __func__, mPortId, deviceId, mSelectedDeviceId);
Paul McLeanaa981192015-03-21 09:55:15 -07001595 if (mSelectedDeviceId != deviceId) {
1596 mSelectedDeviceId = deviceId;
Eric Laurentfb00fc72017-05-25 18:17:12 -07001597 if (mStatus == NO_ERROR) {
1598 android_atomic_or(CBLK_INVALID, &mCblk->mFlags);
jiabin156c6872017-10-06 09:47:15 -07001599 mProxy->interrupt();
Eric Laurentfb00fc72017-05-25 18:17:12 -07001600 }
Paul McLeanaa981192015-03-21 09:55:15 -07001601 }
Eric Laurent493404d2015-04-21 15:07:36 -07001602 return NO_ERROR;
Paul McLeanaa981192015-03-21 09:55:15 -07001603}
1604
1605audio_port_handle_t AudioTrack::getOutputDevice() {
1606 AutoMutex lock(mLock);
1607 return mSelectedDeviceId;
1608}
1609
Eric Laurentad2e7b92017-09-14 20:06:42 -07001610// must be called with mLock held
1611void AudioTrack::updateRoutedDeviceId_l()
1612{
1613 // if the track is inactive, do not update actual device as the output stream maybe routed
1614 // to a device not relevant to this client because of other active use cases.
1615 if (mState != STATE_ACTIVE) {
1616 return;
1617 }
1618 if (mOutput != AUDIO_IO_HANDLE_NONE) {
1619 audio_port_handle_t deviceId = AudioSystem::getDeviceIdForIo(mOutput);
1620 if (deviceId != AUDIO_PORT_HANDLE_NONE) {
1621 mRoutedDeviceId = deviceId;
1622 }
1623 }
1624}
1625
Eric Laurent296fb132015-05-01 11:38:42 -07001626audio_port_handle_t AudioTrack::getRoutedDeviceId() {
1627 AutoMutex lock(mLock);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001628 updateRoutedDeviceId_l();
1629 return mRoutedDeviceId;
Eric Laurent296fb132015-05-01 11:38:42 -07001630}
1631
Eric Laurentbe916aa2010-06-01 23:49:17 -07001632status_t AudioTrack::attachAuxEffect(int effectId)
1633{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001634 AutoMutex lock(mLock);
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08001635 status_t status;
1636 mAudioTrack->attachAuxEffect(effectId, &status);
Eric Laurent2beeb502010-07-16 07:43:46 -07001637 if (status == NO_ERROR) {
1638 mAuxEffectId = effectId;
1639 }
1640 return status;
Eric Laurentbe916aa2010-06-01 23:49:17 -07001641}
1642
Eric Laurente83b55d2014-11-14 10:06:21 -08001643audio_stream_type_t AudioTrack::streamType() const
1644{
Eric Laurente83b55d2014-11-14 10:06:21 -08001645 return mStreamType;
1646}
1647
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07001648uint32_t AudioTrack::latency()
1649{
1650 AutoMutex lock(mLock);
1651 updateLatency_l();
1652 return mLatency;
1653}
1654
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001655// -------------------------------------------------------------------------
1656
Eric Laurent1703cdf2011-03-07 14:52:59 -08001657// must be called with mLock held
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07001658void AudioTrack::updateLatency_l()
1659{
1660 status_t status = AudioSystem::getLatency(mOutput, &mAfLatency);
1661 if (status != NO_ERROR) {
Eric Laurent973db022018-11-20 14:54:31 -08001662 ALOGW("%s(%d): getLatency(%d) failed status %d", __func__, mPortId, mOutput, status);
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07001663 } else {
1664 // FIXME don't believe this lie
Andy Hung13969262017-09-11 17:24:21 -07001665 mLatency = mAfLatency + (1000LL * mFrameCount) / mSampleRate;
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07001666 }
1667}
1668
Phil Burkadbb75a2017-06-16 12:19:42 -07001669// TODO Move this macro to a common header file for enum to string conversion in audio framework.
1670#define MEDIA_CASE_ENUM(name) case name: return #name
1671const char * AudioTrack::convertTransferToText(transfer_type transferType) {
1672 switch (transferType) {
1673 MEDIA_CASE_ENUM(TRANSFER_DEFAULT);
1674 MEDIA_CASE_ENUM(TRANSFER_CALLBACK);
1675 MEDIA_CASE_ENUM(TRANSFER_OBTAIN);
1676 MEDIA_CASE_ENUM(TRANSFER_SYNC);
1677 MEDIA_CASE_ENUM(TRANSFER_SHARED);
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07001678 MEDIA_CASE_ENUM(TRANSFER_SYNC_NOTIF_CALLBACK);
Phil Burkadbb75a2017-06-16 12:19:42 -07001679 default:
1680 return "UNRECOGNIZED";
1681 }
1682}
1683
Glenn Kasten200092b2014-08-15 15:13:30 -07001684status_t AudioTrack::createTrack_l()
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001685{
Eric Laurentf32d7812017-11-30 14:44:07 -08001686 status_t status;
1687 bool callbackAdded = false;
1688
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001689 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
1690 if (audioFlinger == 0) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001691 ALOGE("%s(%d): Could not get audioflinger",
Eric Laurent973db022018-11-20 14:54:31 -08001692 __func__, mPortId);
Eric Laurentf32d7812017-11-30 14:44:07 -08001693 status = NO_INIT;
1694 goto exit;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001695 }
1696
Eric Laurent21da6472017-11-09 16:29:26 -08001697 {
Haynes Mathew Georgeae34ed22016-01-28 11:58:39 -08001698 // mFlags (not mOrigFlags) is modified depending on whether fast request is accepted.
1699 // After fast request is denied, we will request again if IAudioTrack is re-created.
Glenn Kastend79072e2016-01-06 08:41:20 -08001700 // Client can only express a preference for FAST. Server will perform additional tests.
Phil Burk33ff89b2015-11-30 11:16:01 -08001701 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
Phil Burkadbb75a2017-06-16 12:19:42 -07001702 // either of these use cases:
1703 // use case 1: shared buffer
1704 bool sharedBuffer = mSharedBuffer != 0;
1705 bool transferAllowed =
Glenn Kastenc6ba8232014-02-27 13:34:29 -08001706 // use case 2: callback transfer mode
Glenn Kasten1dfe2f92015-03-09 12:03:14 -07001707 (mTransfer == TRANSFER_CALLBACK) ||
1708 // use case 3: obtain/release mode
Phil Burk33ff89b2015-11-30 11:16:01 -08001709 (mTransfer == TRANSFER_OBTAIN) ||
1710 // use case 4: synchronous write
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07001711 ((mTransfer == TRANSFER_SYNC || mTransfer == TRANSFER_SYNC_NOTIF_CALLBACK)
1712 && mThreadCanCallJava);
Phil Burkadbb75a2017-06-16 12:19:42 -07001713
Eric Laurent21da6472017-11-09 16:29:26 -08001714 bool fastAllowed = sharedBuffer || transferAllowed;
1715 if (!fastAllowed) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001716 ALOGW("%s(%d): AUDIO_OUTPUT_FLAG_FAST denied by client,"
1717 " not shared buffer and transfer = %s",
Eric Laurent973db022018-11-20 14:54:31 -08001718 __func__, mPortId,
Phil Burkadbb75a2017-06-16 12:19:42 -07001719 convertTransferToText(mTransfer));
Phil Burk33ff89b2015-11-30 11:16:01 -08001720 mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_FAST);
1721 }
Glenn Kasten4a4a0952012-03-19 11:38:14 -07001722 }
1723
Eric Laurent21da6472017-11-09 16:29:26 -08001724 IAudioFlinger::CreateTrackInput input;
Andy Hunga2159aa2021-07-20 13:01:52 -07001725 if (mOriginalStreamType != AUDIO_STREAM_DEFAULT) {
1726 // Legacy: This is based on original parameters even if the track is recreated.
1727 input.attr = AudioSystem::streamTypeToAttributes(mOriginalStreamType);
Glenn Kastene0fa4672012-04-24 14:35:14 -07001728 } else {
Eric Laurent21da6472017-11-09 16:29:26 -08001729 input.attr = mAttributes;
Eric Laurentd1b449a2010-05-14 03:26:45 -07001730 }
Eric Laurent21da6472017-11-09 16:29:26 -08001731 input.config = AUDIO_CONFIG_INITIALIZER;
1732 input.config.sample_rate = mSampleRate;
1733 input.config.channel_mask = mChannelMask;
1734 input.config.format = mFormat;
1735 input.config.offload_info = mOffloadInfoCopy;
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001736 input.clientInfo.attributionSource = mClientAttributionSource;
Eric Laurent21da6472017-11-09 16:29:26 -08001737 input.clientInfo.clientTid = -1;
Glenn Kasten363fb752014-01-15 12:27:31 -08001738 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
Glenn Kasten47d55172017-05-23 11:19:30 -07001739 // It is currently meaningless to request SCHED_FIFO for a Java thread. Even if the
1740 // application-level code follows all non-blocking design rules, the language runtime
1741 // doesn't also follow those rules, so the thread will not benefit overall.
Phil Burk33ff89b2015-11-30 11:16:01 -08001742 if (mAudioTrackThread != 0 && !mThreadCanCallJava) {
Eric Laurent21da6472017-11-09 16:29:26 -08001743 input.clientInfo.clientTid = mAudioTrackThread->getTid();
Glenn Kasten3acbd052012-02-28 10:39:56 -08001744 }
Glenn Kasten4a4a0952012-03-19 11:38:14 -07001745 }
Eric Laurent21da6472017-11-09 16:29:26 -08001746 input.sharedBuffer = mSharedBuffer;
1747 input.notificationsPerBuffer = mNotificationsPerBufferReq;
1748 input.speed = 1.0;
1749 if (audio_has_proportional_frames(mFormat) && mSharedBuffer == 0 &&
1750 (mFlags & AUDIO_OUTPUT_FLAG_FAST) == 0) {
1751 input.speed = !isPurePcmData_l() || isOffloadedOrDirect_l() ? 1.0f :
1752 max(mMaxRequiredSpeed, mPlaybackRate.mSpeed);
1753 }
1754 input.flags = mFlags;
1755 input.frameCount = mReqFrameCount;
1756 input.notificationFrameCount = mNotificationFramesReq;
1757 input.selectedDeviceId = mSelectedDeviceId;
1758 input.sessionId = mSessionId;
jiabinf6eb4c32020-02-25 14:06:25 -08001759 input.audioTrackCallback = mAudioTrackCallback;
Glenn Kasten4a4a0952012-03-19 11:38:14 -07001760
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -08001761 media::CreateTrackResponse response;
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001762 status = audioFlinger->createTrack(VALUE_OR_FATAL(input.toAidl()), response);
Ytai Ben-Tsvi357e26a2021-01-05 13:21:19 -08001763
1764 IAudioFlinger::CreateTrackOutput output{};
1765 if (status == NO_ERROR) {
1766 output = VALUE_OR_FATAL(IAudioFlinger::CreateTrackOutput::fromAidl(response));
1767 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001768
Eric Laurent21da6472017-11-09 16:29:26 -08001769 if (status != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001770 ALOGE("%s(%d): AudioFlinger could not create track, status: %d output %d",
Eric Laurent973db022018-11-20 14:54:31 -08001771 __func__, mPortId, status, output.outputId);
Eric Laurentf32d7812017-11-30 14:44:07 -08001772 if (status == NO_ERROR) {
1773 status = NO_INIT;
1774 }
1775 goto exit;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001776 }
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001777 ALOG_ASSERT(output.audioTrack != 0);
Glenn Kastenc08d20b2014-02-24 15:21:10 -08001778
Eric Laurent21da6472017-11-09 16:29:26 -08001779 mFrameCount = output.frameCount;
1780 mNotificationFramesAct = (uint32_t)output.notificationFrameCount;
1781 mRoutedDeviceId = output.selectedDeviceId;
1782 mSessionId = output.sessionId;
Andy Hunga2159aa2021-07-20 13:01:52 -07001783 mStreamType = output.streamType;
Eric Laurent21da6472017-11-09 16:29:26 -08001784
1785 mSampleRate = output.sampleRate;
1786 if (mOriginalSampleRate == 0) {
1787 mOriginalSampleRate = mSampleRate;
1788 }
1789
1790 mAfFrameCount = output.afFrameCount;
1791 mAfSampleRate = output.afSampleRate;
1792 mAfLatency = output.afLatencyMs;
1793
1794 mLatency = mAfLatency + (1000LL * mFrameCount) / mSampleRate;
1795
Glenn Kasten38e905b2014-01-13 10:21:48 -08001796 // AudioFlinger now owns the reference to the I/O handle,
1797 // so we are no longer responsible for releasing it.
1798
Glenn Kasten7fd04222016-02-02 12:38:16 -08001799 // FIXME compare to AudioRecord
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08001800 std::optional<media::SharedFileRegion> sfr;
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001801 output.audioTrack->getCblk(&sfr);
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08001802 sp<IMemory> iMem = VALUE_OR_FATAL(aidl2legacy_NullableSharedFileRegion_IMemory(sfr));
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001803 if (iMem == 0) {
Eric Laurent973db022018-11-20 14:54:31 -08001804 ALOGE("%s(%d): Could not get control block", __func__, mPortId);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001805 status = NO_INIT;
Eric Laurentf32d7812017-11-30 14:44:07 -08001806 goto exit;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001807 }
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07001808 // TODO: Using unsecurePointer() has some associated security pitfalls
1809 // (see declaration for details).
1810 // Either document why it is safe in this case or address the
1811 // issue (e.g. by copying).
1812 void *iMemPointer = iMem->unsecurePointer();
Glenn Kasten0cde0762014-01-16 15:06:36 -08001813 if (iMemPointer == NULL) {
Eric Laurent973db022018-11-20 14:54:31 -08001814 ALOGE("%s(%d): Could not get control block pointer", __func__, mPortId);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001815 status = NO_INIT;
Eric Laurentf32d7812017-11-30 14:44:07 -08001816 goto exit;
Glenn Kasten0cde0762014-01-16 15:06:36 -08001817 }
Glenn Kasten53cec222013-08-29 09:01:02 -07001818 // invariant that mAudioTrack != 0 is true only after set() returns successfully
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001819 if (mAudioTrack != 0) {
Marco Nelissenf8880202014-11-14 07:58:25 -08001820 IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001821 mDeathNotifier.clear();
1822 }
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -08001823 mAudioTrack = output.audioTrack;
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001824 mCblkMemory = iMem;
Eric Laurent3bcffa12014-06-12 18:38:45 -07001825 IPCThreadState::self()->flushCommands();
1826
Glenn Kasten0cde0762014-01-16 15:06:36 -08001827 audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMemPointer);
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001828 mCblk = cblk;
Glenn Kasten5f631512014-02-24 15:16:07 -08001829
Glenn Kastena07f17c2013-04-23 12:39:37 -07001830 mAwaitBoost = false;
Glenn Kasten363fb752014-01-15 12:27:31 -08001831 if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
Eric Laurent21da6472017-11-09 16:29:26 -08001832 if (output.flags & AUDIO_OUTPUT_FLAG_FAST) {
Andy Hungfb8ede22018-09-12 19:03:24 -07001833 ALOGI("%s(%d): AUDIO_OUTPUT_FLAG_FAST successful; frameCount %zu -> %zu",
Eric Laurent973db022018-11-20 14:54:31 -08001834 __func__, mPortId, mReqFrameCount, mFrameCount);
Phil Burk33ff89b2015-11-30 11:16:01 -08001835 if (!mThreadCanCallJava) {
1836 mAwaitBoost = true;
1837 }
Glenn Kasten3acbd052012-02-28 10:39:56 -08001838 } else {
Robert Wuc121cd12021-08-13 17:51:40 +00001839 ALOGV("%s(%d): AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %zu -> %zu",
Eric Laurent973db022018-11-20 14:54:31 -08001840 __func__, mPortId, mReqFrameCount, mFrameCount);
Glenn Kastene0fa4672012-04-24 14:35:14 -07001841 }
Glenn Kasten3acbd052012-02-28 10:39:56 -08001842 }
Eric Laurent21da6472017-11-09 16:29:26 -08001843 mFlags = output.flags;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01001844
Eric Laurentad2e7b92017-09-14 20:06:42 -07001845 //mOutput != output includes the case where mOutput == AUDIO_IO_HANDLE_NONE for first creation
Eric Laurent09f1ed22019-04-24 17:45:17 -07001846 if (mDeviceCallback != 0) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07001847 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Eric Laurent09f1ed22019-04-24 17:45:17 -07001848 AudioSystem::removeAudioDeviceCallback(this, mOutput, mPortId);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001849 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07001850 AudioSystem::addAudioDeviceCallback(this, output.outputId, output.portId);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001851 callbackAdded = true;
1852 }
1853
Eric Laurent09f1ed22019-04-24 17:45:17 -07001854 mPortId = output.portId;
Glenn Kasten38e905b2014-01-13 10:21:48 -08001855 // We retain a copy of the I/O handle, but don't own the reference
Eric Laurent21da6472017-11-09 16:29:26 -08001856 mOutput = output.outputId;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001857 mRefreshRemaining = true;
1858
1859 // Starting address of buffers in shared memory. If there is a shared buffer, buffers
1860 // is the value of pointer() for the shared buffer, otherwise buffers points
1861 // immediately after the control block. This address is for the mapping within client
1862 // address space. AudioFlinger::TrackBase::mBuffer is for the server address space.
1863 void* buffers;
Glenn Kasten363fb752014-01-15 12:27:31 -08001864 if (mSharedBuffer == 0) {
Glenn Kasten138d6f92015-03-20 10:54:51 -07001865 buffers = cblk + 1;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001866 } else {
Ytai Ben-Tsvi7dd39722019-09-05 15:14:30 -07001867 // TODO: Using unsecurePointer() has some associated security pitfalls
1868 // (see declaration for details).
1869 // Either document why it is safe in this case or address the
1870 // issue (e.g. by copying).
1871 buffers = mSharedBuffer->unsecurePointer();
Glenn Kasten138d6f92015-03-20 10:54:51 -07001872 if (buffers == NULL) {
Eric Laurent973db022018-11-20 14:54:31 -08001873 ALOGE("%s(%d): Could not get buffer pointer", __func__, mPortId);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001874 status = NO_INIT;
Eric Laurentf32d7812017-11-30 14:44:07 -08001875 goto exit;
Glenn Kasten138d6f92015-03-20 10:54:51 -07001876 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001877 }
1878
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08001879 mAudioTrack->attachAuxEffect(mAuxEffectId, &status);
Glenn Kasten5f631512014-02-24 15:16:07 -08001880
Glenn Kasten093000f2012-05-03 09:35:36 -07001881 // If IAudioTrack is re-created, don't let the requested frameCount
1882 // decrease. This can confuse clients that cache frameCount().
Eric Laurent21da6472017-11-09 16:29:26 -08001883 if (mFrameCount > mReqFrameCount) {
1884 mReqFrameCount = mFrameCount;
Glenn Kasten093000f2012-05-03 09:35:36 -07001885 }
Glenn Kastene3aa6592012-12-04 12:22:46 -08001886
Andy Hungd7bd69e2015-07-24 07:52:41 -07001887 // reset server position to 0 as we have new cblk.
1888 mServer = 0;
1889
Glenn Kastene3aa6592012-12-04 12:22:46 -08001890 // update proxy
Glenn Kasten363fb752014-01-15 12:27:31 -08001891 if (mSharedBuffer == 0) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001892 mStaticProxy.clear();
Eric Laurent21da6472017-11-09 16:29:26 -08001893 mProxy = new AudioTrackClientProxy(cblk, buffers, mFrameCount, mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001894 } else {
Eric Laurent21da6472017-11-09 16:29:26 -08001895 mStaticProxy = new StaticAudioTrackClientProxy(cblk, buffers, mFrameCount, mFrameSize);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001896 mProxy = mStaticProxy;
1897 }
seunghak.hane6a9d6582014-11-22 15:22:35 +09001898
1899 mProxy->setVolumeLR(gain_minifloat_pack(
1900 gain_from_float(mVolume[AUDIO_INTERLEAVE_LEFT]),
1901 gain_from_float(mVolume[AUDIO_INTERLEAVE_RIGHT])));
1902
Glenn Kastene3aa6592012-12-04 12:22:46 -08001903 mProxy->setSendLevel(mSendLevel);
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001904 const uint32_t effectiveSampleRate = adjustSampleRate(mSampleRate, mPlaybackRate.mPitch);
1905 const float effectiveSpeed = adjustSpeed(mPlaybackRate.mSpeed, mPlaybackRate.mPitch);
1906 const float effectivePitch = adjustPitch(mPlaybackRate.mPitch);
Andy Hung26145642015-04-15 21:56:53 -07001907 mProxy->setSampleRate(effectiveSampleRate);
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07001908
1909 AudioPlaybackRate playbackRateTemp = mPlaybackRate;
1910 playbackRateTemp.mSpeed = effectiveSpeed;
1911 playbackRateTemp.mPitch = effectivePitch;
1912 mProxy->setPlaybackRate(playbackRateTemp);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001913 mProxy->setMinimum(mNotificationFramesAct);
1914
Kuowei Lid4adbdb2020-08-13 14:44:25 +08001915 if (mDualMonoMode != AUDIO_DUAL_MONO_MODE_OFF) {
1916 setDualMonoMode_l(mDualMonoMode);
1917 }
1918 if (mAudioDescriptionMixLeveldB != -std::numeric_limits<float>::infinity()) {
1919 setAudioDescriptionMixLevel_l(mAudioDescriptionMixLeveldB);
1920 }
1921
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001922 mDeathNotifier = new DeathNotifier(this);
Marco Nelissenf8880202014-11-14 07:58:25 -08001923 IInterface::asBinder(mAudioTrack)->linkToDeath(mDeathNotifier, this);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001924
Andy Hungb68f5eb2019-12-03 16:49:17 -08001925 // This is the first log sent from the AudioTrack client.
1926 // The creation of the audio track by AudioFlinger (in the code above)
1927 // is the first log of the AudioTrack and must be present before
1928 // any AudioTrack client logs will be accepted.
Andy Hungea840382020-05-05 21:50:17 -07001929
Andy Hungb68f5eb2019-12-03 16:49:17 -08001930 mMetricsId = std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_TRACK) + std::to_string(mPortId);
1931 mediametrics::LogItem(mMetricsId)
1932 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CREATE)
1933 // the following are immutable
Andy Hunga629bd12020-06-05 16:03:53 -07001934 .set(AMEDIAMETRICS_PROP_FLAGS, toString(mFlags).c_str())
1935 .set(AMEDIAMETRICS_PROP_ORIGINALFLAGS, toString(mOrigFlags).c_str())
Andy Hungb68f5eb2019-12-03 16:49:17 -08001936 .set(AMEDIAMETRICS_PROP_SESSIONID, (int32_t)mSessionId)
Andy Hung3a5c2f32021-02-17 15:06:42 -08001937 .set(AMEDIAMETRICS_PROP_LOGSESSIONID, mLogSessionId)
Andy Hung839a3062021-02-17 11:15:16 -08001938 .set(AMEDIAMETRICS_PROP_PLAYERIID, mPlayerIId)
Andy Hungb68f5eb2019-12-03 16:49:17 -08001939 .set(AMEDIAMETRICS_PROP_TRACKID, mPortId) // dup from key
Andy Hungb68f5eb2019-12-03 16:49:17 -08001940 .set(AMEDIAMETRICS_PROP_CONTENTTYPE, toString(mAttributes.content_type).c_str())
1941 .set(AMEDIAMETRICS_PROP_USAGE, toString(mAttributes.usage).c_str())
1942 .set(AMEDIAMETRICS_PROP_THREADID, (int32_t)output.outputId)
1943 .set(AMEDIAMETRICS_PROP_SELECTEDDEVICEID, (int32_t)mSelectedDeviceId)
1944 .set(AMEDIAMETRICS_PROP_ROUTEDDEVICEID, (int32_t)mRoutedDeviceId)
1945 .set(AMEDIAMETRICS_PROP_ENCODING, toString(mFormat).c_str())
1946 .set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)mChannelMask)
1947 .set(AMEDIAMETRICS_PROP_FRAMECOUNT, (int32_t)mFrameCount)
1948 // the following are NOT immutable
1949 .set(AMEDIAMETRICS_PROP_VOLUME_LEFT, (double)mVolume[AUDIO_INTERLEAVE_LEFT])
1950 .set(AMEDIAMETRICS_PROP_VOLUME_RIGHT, (double)mVolume[AUDIO_INTERLEAVE_RIGHT])
1951 .set(AMEDIAMETRICS_PROP_STATE, stateToString(mState))
1952 .set(AMEDIAMETRICS_PROP_AUXEFFECTID, (int32_t)mAuxEffectId)
1953 .set(AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)mSampleRate)
1954 .set(AMEDIAMETRICS_PROP_PLAYBACK_SPEED, (double)mPlaybackRate.mSpeed)
1955 .set(AMEDIAMETRICS_PROP_PLAYBACK_PITCH, (double)mPlaybackRate.mPitch)
1956 .set(AMEDIAMETRICS_PROP_PREFIX_EFFECTIVE
1957 AMEDIAMETRICS_PROP_SAMPLERATE, (int32_t)effectiveSampleRate)
1958 .set(AMEDIAMETRICS_PROP_PREFIX_EFFECTIVE
1959 AMEDIAMETRICS_PROP_PLAYBACK_SPEED, (double)effectiveSpeed)
1960 .set(AMEDIAMETRICS_PROP_PREFIX_EFFECTIVE
1961 AMEDIAMETRICS_PROP_PLAYBACK_PITCH, (double)effectivePitch)
1962 .record();
1963
1964 // mSendLevel
1965 // mReqFrameCount?
1966 // mNotificationFramesAct, mNotificationFramesReq, mNotificationsPerBufferReq
1967 // mLatency, mAfLatency, mAfFrameCount, mAfSampleRate
1968
Glenn Kasten38e905b2014-01-13 10:21:48 -08001969 }
1970
Eric Laurentf32d7812017-11-30 14:44:07 -08001971exit:
1972 if (status != NO_ERROR && callbackAdded) {
Eric Laurentad2e7b92017-09-14 20:06:42 -07001973 // note: mOutput is always valid is callbackAdded is true
Eric Laurent09f1ed22019-04-24 17:45:17 -07001974 AudioSystem::removeAudioDeviceCallback(this, mOutput, mPortId);
Eric Laurentad2e7b92017-09-14 20:06:42 -07001975 }
Eric Laurentf32d7812017-11-30 14:44:07 -08001976
1977 mStatus = status;
Eric Laurent21da6472017-11-09 16:29:26 -08001978
1979 // sp<IAudioTrack> track destructor will cause releaseOutput() to be called by AudioFlinger
Glenn Kasten38e905b2014-01-13 10:21:48 -08001980 return status;
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001981}
1982
Glenn Kastenb46f3942015-03-09 12:00:30 -07001983status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount, size_t *nonContig)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001984{
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001985 if (audioBuffer == NULL) {
Glenn Kasten551b5352015-03-20 11:30:28 -07001986 if (nonContig != NULL) {
1987 *nonContig = 0;
1988 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001989 return BAD_VALUE;
Eric Laurent9b7d9502011-03-21 11:49:00 -07001990 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001991 if (mTransfer != TRANSFER_OBTAIN) {
1992 audioBuffer->frameCount = 0;
1993 audioBuffer->size = 0;
1994 audioBuffer->raw = NULL;
Glenn Kasten551b5352015-03-20 11:30:28 -07001995 if (nonContig != NULL) {
1996 *nonContig = 0;
1997 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001998 return INVALID_OPERATION;
1999 }
Eric Laurent9b7d9502011-03-21 11:49:00 -07002000
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002001 const struct timespec *requested;
Eric Laurentdf576992014-01-27 18:13:39 -08002002 struct timespec timeout;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002003 if (waitCount == -1) {
2004 requested = &ClientProxy::kForever;
2005 } else if (waitCount == 0) {
2006 requested = &ClientProxy::kNonBlocking;
2007 } else if (waitCount > 0) {
Chih-Hung Hsiehbca74292018-08-10 16:06:07 -07002008 time_t ms = WAIT_PERIOD_MS * (time_t) waitCount;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002009 timeout.tv_sec = ms / 1000;
Andy Hung06a730b2020-04-09 13:28:31 -07002010 timeout.tv_nsec = (ms % 1000) * 1000000;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002011 requested = &timeout;
2012 } else {
Eric Laurent973db022018-11-20 14:54:31 -08002013 ALOGE("%s(%d): invalid waitCount %d", __func__, mPortId, waitCount);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002014 requested = NULL;
2015 }
Glenn Kastenb46f3942015-03-09 12:00:30 -07002016 return obtainBuffer(audioBuffer, requested, NULL /*elapsed*/, nonContig);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002017}
Eric Laurent1703cdf2011-03-07 14:52:59 -08002018
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002019status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, const struct timespec *requested,
2020 struct timespec *elapsed, size_t *nonContig)
2021{
2022 // previous and new IAudioTrack sequence numbers are used to detect track re-creation
2023 uint32_t oldSequence = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002024
2025 Proxy::Buffer buffer;
2026 status_t status = NO_ERROR;
2027
2028 static const int32_t kMaxTries = 5;
2029 int32_t tryCounter = kMaxTries;
2030
2031 do {
2032 // obtainBuffer() is called with mutex unlocked, so keep extra references to these fields to
2033 // keep them from going away if another thread re-creates the track during obtainBuffer()
2034 sp<AudioTrackClientProxy> proxy;
2035 sp<IMemory> iMem;
2036
2037 { // start of lock scope
2038 AutoMutex lock(mLock);
2039
Glenn Kasten305996c2020-01-27 08:03:37 -08002040 uint32_t newSequence = mSequence;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002041 // did previous obtainBuffer() fail due to media server death or voluntary invalidation?
2042 if (status == DEAD_OBJECT) {
2043 // re-create track, unless someone else has already done so
2044 if (newSequence == oldSequence) {
2045 status = restoreTrack_l("obtainBuffer");
2046 if (status != NO_ERROR) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002047 buffer.mFrameCount = 0;
2048 buffer.mRaw = NULL;
2049 buffer.mNonContig = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002050 break;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002051 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002052 }
2053 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002054 oldSequence = newSequence;
2055
Eric Laurent4d231dc2016-03-11 18:38:23 -08002056 if (status == NOT_ENOUGH_DATA) {
2057 restartIfDisabled();
2058 }
2059
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002060 // Keep the extra references
2061 proxy = mProxy;
2062 iMem = mCblkMemory;
2063
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002064 if (mState == STATE_STOPPING) {
2065 status = -EINTR;
2066 buffer.mFrameCount = 0;
2067 buffer.mRaw = NULL;
2068 buffer.mNonContig = 0;
2069 break;
2070 }
2071
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002072 // Non-blocking if track is stopped or paused
2073 if (mState != STATE_ACTIVE) {
2074 requested = &ClientProxy::kNonBlocking;
2075 }
2076
2077 } // end of lock scope
2078
2079 buffer.mFrameCount = audioBuffer->frameCount;
2080 // FIXME starts the requested timeout and elapsed over from scratch
2081 status = proxy->obtainBuffer(&buffer, requested, elapsed);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002082 } while (((status == DEAD_OBJECT) || (status == NOT_ENOUGH_DATA)) && (tryCounter-- > 0));
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002083
2084 audioBuffer->frameCount = buffer.mFrameCount;
Andy Hungabdb9902015-01-12 15:08:22 -08002085 audioBuffer->size = buffer.mFrameCount * mFrameSize;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002086 audioBuffer->raw = buffer.mRaw;
Glenn Kasten305996c2020-01-27 08:03:37 -08002087 audioBuffer->sequence = oldSequence;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002088 if (nonContig != NULL) {
2089 *nonContig = buffer.mNonContig;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002090 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002091 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002092}
2093
Glenn Kasten54a8a452015-03-09 12:03:00 -07002094void AudioTrack::releaseBuffer(const Buffer* audioBuffer)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002095{
Glenn Kasten3f02be22015-03-09 11:59:04 -07002096 // FIXME add error checking on mode, by adding an internal version
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002097 if (mTransfer == TRANSFER_SHARED) {
2098 return;
2099 }
2100
Andy Hungabdb9902015-01-12 15:08:22 -08002101 size_t stepCount = audioBuffer->size / mFrameSize;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002102 if (stepCount == 0) {
2103 return;
2104 }
2105
2106 Proxy::Buffer buffer;
2107 buffer.mFrameCount = stepCount;
2108 buffer.mRaw = audioBuffer->raw;
Glenn Kastene3aa6592012-12-04 12:22:46 -08002109
Eric Laurent1703cdf2011-03-07 14:52:59 -08002110 AutoMutex lock(mLock);
Glenn Kasten305996c2020-01-27 08:03:37 -08002111 if (audioBuffer->sequence != mSequence) {
2112 // This Buffer came from a different IAudioTrack instance, so ignore the releaseBuffer
2113 ALOGD("%s is no-op due to IAudioTrack sequence mismatch %u != %u",
2114 __func__, audioBuffer->sequence, mSequence);
2115 return;
2116 }
Glenn Kasten200092b2014-08-15 15:13:30 -07002117 mReleased += stepCount;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002118 mInUnderrun = false;
2119 mProxy->releaseBuffer(&buffer);
2120
2121 // restart track if it was disabled by audioflinger due to previous underrun
Eric Laurent4d231dc2016-03-11 18:38:23 -08002122 restartIfDisabled();
2123}
2124
2125void AudioTrack::restartIfDisabled()
2126{
2127 int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
2128 if ((mState == STATE_ACTIVE) && (flags & CBLK_DISABLED)) {
Andy Hungfb8ede22018-09-12 19:03:24 -07002129 ALOGW("%s(%d): releaseBuffer() track %p disabled due to previous underrun, restarting",
Eric Laurent973db022018-11-20 14:54:31 -08002130 __func__, mPortId, this);
Eric Laurent4d231dc2016-03-11 18:38:23 -08002131 // FIXME ignoring status
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002132 status_t status;
2133 mAudioTrack->start(&status);
Eric Laurentdf839842012-05-31 14:27:14 -07002134 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002135}
2136
2137// -------------------------------------------------------------------------
2138
Jean-Michel Trivi720ad9d2014-02-04 11:00:59 -08002139ssize_t AudioTrack::write(const void* buffer, size_t userSize, bool blocking)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002140{
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07002141 if (mTransfer != TRANSFER_SYNC && mTransfer != TRANSFER_SYNC_NOTIF_CALLBACK) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07002142 return INVALID_OPERATION;
2143 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002144
Eric Laurentab5cdba2014-06-09 17:22:27 -07002145 if (isDirect()) {
2146 AutoMutex lock(mLock);
2147 int32_t flags = android_atomic_and(
2148 ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END),
2149 &mCblk->mFlags);
2150 if (flags & CBLK_INVALID) {
2151 return DEAD_OBJECT;
2152 }
2153 }
2154
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002155 if (ssize_t(userSize) < 0 || (buffer == NULL && userSize != 0)) {
Jiabin Huang447cea72020-07-28 22:35:18 +00002156 // Validation: user is most-likely passing an error code, and it would
Glenn Kasten99e53b82012-01-19 08:59:58 -08002157 // make the return value ambiguous (actualSize vs error).
Andy Hungfb8ede22018-09-12 19:03:24 -07002158 ALOGE("%s(%d): AudioTrack::write(buffer=%p, size=%zu (%zd)",
Eric Laurent973db022018-11-20 14:54:31 -08002159 __func__, mPortId, buffer, userSize, userSize);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002160 return BAD_VALUE;
2161 }
2162
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002163 size_t written = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002164 Buffer audioBuffer;
2165
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002166 while (userSize >= mFrameSize) {
2167 audioBuffer.frameCount = userSize / mFrameSize;
Eric Laurentc2f1f072009-07-17 12:17:14 -07002168
Jean-Michel Trivi720ad9d2014-02-04 11:00:59 -08002169 status_t err = obtainBuffer(&audioBuffer,
2170 blocking ? &ClientProxy::kForever : &ClientProxy::kNonBlocking);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002171 if (err < 0) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002172 if (written > 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002173 break;
Glenn Kastend65d73c2012-06-22 17:21:07 -07002174 }
Glenn Kasten0a2f1512016-07-22 08:06:37 -07002175 if (err == TIMED_OUT || err == -EINTR) {
2176 err = WOULD_BLOCK;
2177 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002178 return ssize_t(err);
2179 }
2180
Glenn Kastenae4b8792015-03-20 09:04:21 -07002181 size_t toWrite = audioBuffer.size;
Andy Hungabdb9902015-01-12 15:08:22 -08002182 memcpy(audioBuffer.i8, buffer, toWrite);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002183 buffer = ((const char *) buffer) + toWrite;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002184 userSize -= toWrite;
2185 written += toWrite;
2186
2187 releaseBuffer(&audioBuffer);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002188 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002189
Andy Hungea2b9c02016-02-12 17:06:53 -08002190 if (written > 0) {
2191 mFramesWritten += written / mFrameSize;
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07002192
2193 if (mTransfer == TRANSFER_SYNC_NOTIF_CALLBACK) {
2194 const sp<AudioTrackThread> t = mAudioTrackThread;
2195 if (t != 0) {
2196 // causes wake up of the playback thread, that will callback the client for
2197 // more data (with EVENT_CAN_WRITE_MORE_DATA) in processAudioBuffer()
2198 t->wake();
2199 }
2200 }
Andy Hungea2b9c02016-02-12 17:06:53 -08002201 }
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07002202
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002203 return written;
2204}
2205
2206// -------------------------------------------------------------------------
2207
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08002208nsecs_t AudioTrack::processAudioBuffer()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002209{
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07002210 // Currently the AudioTrack thread is not created if there are no callbacks.
2211 // Would it ever make sense to run the thread, even without callbacks?
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002212 // If so, then replace this by checks at each use for mCbf != NULL.
Glenn Kastenfb1fdc92013-07-10 17:03:19 -07002213 LOG_ALWAYS_FATAL_IF(mCblk == NULL);
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002214
Eric Laurent1703cdf2011-03-07 14:52:59 -08002215 mLock.lock();
Glenn Kastena07f17c2013-04-23 12:39:37 -07002216 if (mAwaitBoost) {
2217 mAwaitBoost = false;
2218 mLock.unlock();
2219 static const int32_t kMaxTries = 5;
2220 int32_t tryCounter = kMaxTries;
2221 uint32_t pollUs = 10000;
2222 do {
Glenn Kasten8255ba72016-08-23 13:54:23 -07002223 int policy = sched_getscheduler(0) & ~SCHED_RESET_ON_FORK;
Glenn Kastena07f17c2013-04-23 12:39:37 -07002224 if (policy == SCHED_FIFO || policy == SCHED_RR) {
2225 break;
2226 }
2227 usleep(pollUs);
2228 pollUs <<= 1;
2229 } while (tryCounter-- > 0);
2230 if (tryCounter < 0) {
Andy Hungfb8ede22018-09-12 19:03:24 -07002231 ALOGE("%s(%d): did not receive expected priority boost on time",
Eric Laurent973db022018-11-20 14:54:31 -08002232 __func__, mPortId);
Glenn Kastena07f17c2013-04-23 12:39:37 -07002233 }
Glenn Kastenb0dfd462013-07-10 16:52:47 -07002234 // Run again immediately
2235 return 0;
Glenn Kastena07f17c2013-04-23 12:39:37 -07002236 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08002237
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002238 // Can only reference mCblk while locked
2239 int32_t flags = android_atomic_and(
Glenn Kasten96f60d82013-07-12 10:21:18 -07002240 ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END), &mCblk->mFlags);
Glenn Kastena47f3162012-11-07 10:13:08 -08002241
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002242 // Check for track invalidation
2243 if (flags & CBLK_INVALID) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002244 // for offloaded tracks restoreTrack_l() will just update the sequence and clear
2245 // AudioSystem cache. We should not exit here but after calling the callback so
2246 // that the upper layers can recreate the track
Eric Laurentab5cdba2014-06-09 17:22:27 -07002247 if (!isOffloadedOrDirect_l() || (mSequence == mObservedSequence)) {
Lajos Molnarf1063e22015-04-17 15:19:42 -07002248 status_t status __unused = restoreTrack_l("processAudioBuffer");
2249 // FIXME unused status
Andy Hung53c3b5f2014-12-15 16:42:05 -08002250 // after restoration, continue below to make sure that the loop and buffer events
2251 // are notified because they have been cleared from mCblk->mFlags above.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002252 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002253 }
2254
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002255 bool waitStreamEnd = mState == STATE_STOPPING;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002256 bool active = mState == STATE_ACTIVE;
2257
2258 // Manage underrun callback, must be done under lock to avoid race with releaseBuffer()
2259 bool newUnderrun = false;
2260 if (flags & CBLK_UNDERRUN) {
2261#if 0
2262 // Currently in shared buffer mode, when the server reaches the end of buffer,
2263 // the track stays active in continuous underrun state. It's up to the application
2264 // to pause or stop the track, or set the position to a new offset within buffer.
2265 // This was some experimental code to auto-pause on underrun. Keeping it here
2266 // in "if 0" so we can re-visit this if we add a real sequencer for shared memory content.
2267 if (mTransfer == TRANSFER_SHARED) {
2268 mState = STATE_PAUSED;
2269 active = false;
2270 }
2271#endif
2272 if (!mInUnderrun) {
2273 mInUnderrun = true;
2274 newUnderrun = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002275 }
2276 }
Eric Laurentc2f1f072009-07-17 12:17:14 -07002277
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002278 // Get current position of server
Andy Hung90e8a972015-11-09 16:42:40 -08002279 Modulo<uint32_t> position(updateAndGetPosition_l());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002280
2281 // Manage marker callback
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002282 bool markerReached = false;
Andy Hung90e8a972015-11-09 16:42:40 -08002283 Modulo<uint32_t> markerPosition(mMarkerPosition);
2284 // uses 32 bit wraparound for comparison with position.
2285 if (!mMarkerReached && markerPosition.value() > 0 && position >= markerPosition) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002286 mMarkerReached = markerReached = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002287 }
2288
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002289 // Determine number of new position callback(s) that will be needed, while locked
2290 size_t newPosCount = 0;
Andy Hung90e8a972015-11-09 16:42:40 -08002291 Modulo<uint32_t> newPosition(mNewPosition);
2292 uint32_t updatePeriod = mUpdatePeriod;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002293 // FIXME fails for wraparound, need 64 bits
2294 if (updatePeriod > 0 && position >= newPosition) {
Andy Hung90e8a972015-11-09 16:42:40 -08002295 newPosCount = ((position - newPosition).value() / updatePeriod) + 1;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002296 mNewPosition += updatePeriod * newPosCount;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002297 }
2298
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002299 // Cache other fields that will be needed soon
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002300 uint32_t sampleRate = mSampleRate;
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07002301 float speed = mPlaybackRate.mSpeed;
Andy Hunga7f03352015-05-31 21:54:49 -07002302 const uint32_t notificationFrames = mNotificationFramesAct;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002303 if (mRefreshRemaining) {
2304 mRefreshRemaining = false;
2305 mRemainingFrames = notificationFrames;
2306 mRetryOnPartialBuffer = false;
2307 }
2308 size_t misalignment = mProxy->getMisalignment();
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002309 uint32_t sequence = mSequence;
Glenn Kasten96f04882013-09-20 09:28:56 -07002310 sp<AudioTrackClientProxy> proxy = mProxy;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002311
Andy Hung53c3b5f2014-12-15 16:42:05 -08002312 // Determine the number of new loop callback(s) that will be needed, while locked.
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002313 int loopCountNotifications = 0;
Andy Hung53c3b5f2014-12-15 16:42:05 -08002314 uint32_t loopPeriod = 0; // time in frames for next EVENT_LOOP_END or EVENT_BUFFER_END
2315
2316 if (mLoopCount > 0) {
2317 int loopCount;
2318 size_t bufferPosition;
2319 mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount);
2320 loopPeriod = ((loopCount > 0) ? mLoopEnd : mFrameCount) - bufferPosition;
2321 loopCountNotifications = min(mLoopCountNotified - loopCount, kMaxLoopCountNotifications);
2322 mLoopCountNotified = loopCount; // discard any excess notifications
2323 } else if (mLoopCount < 0) {
2324 // FIXME: We're not accurate with notification count and position with infinite looping
2325 // since loopCount from server side will always return -1 (we could decrement it).
2326 size_t bufferPosition = mStaticProxy->getBufferPosition();
2327 loopCountNotifications = int((flags & (CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL)) != 0);
2328 loopPeriod = mLoopEnd - bufferPosition;
2329 } else if (/* mLoopCount == 0 && */ mSharedBuffer != 0) {
2330 size_t bufferPosition = mStaticProxy->getBufferPosition();
2331 loopPeriod = mFrameCount - bufferPosition;
2332 }
2333
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002334 // These fields don't need to be cached, because they are assigned only by set():
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002335 // mTransfer, mCbf, mUserData, mFormat, mFrameSize, mFlags
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002336 // mFlags is also assigned by createTrack_l(), but not the bit we care about.
2337
2338 mLock.unlock();
2339
Andy Hunga7f03352015-05-31 21:54:49 -07002340 // get anchor time to account for callbacks.
2341 const nsecs_t timeBeforeCallbacks = systemTime();
2342
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002343 if (waitStreamEnd) {
Andy Hunga7f03352015-05-31 21:54:49 -07002344 // FIXME: Instead of blocking in proxy->waitStreamEndDone(), Callback thread
2345 // should wait on proxy futex and handle CBLK_STREAM_END_DONE within this function
2346 // (and make sure we don't callback for more data while we're stopping).
2347 // This helps with position, marker notifications, and track invalidation.
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002348 struct timespec timeout;
2349 timeout.tv_sec = WAIT_STREAM_END_TIMEOUT_SEC;
2350 timeout.tv_nsec = 0;
2351
Glenn Kasten96f04882013-09-20 09:28:56 -07002352 status_t status = proxy->waitStreamEndDone(&timeout);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002353 switch (status) {
2354 case NO_ERROR:
2355 case DEAD_OBJECT:
2356 case TIMED_OUT:
Andy Hung39609a02015-09-03 16:38:38 -07002357 if (status != DEAD_OBJECT) {
2358 // for DEAD_OBJECT, we do not send a EVENT_STREAM_END after stop();
2359 // instead, the application should handle the EVENT_NEW_IAUDIOTRACK.
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002360 mCbf(EVENT_STREAM_END, mUserData, NULL);
Andy Hung39609a02015-09-03 16:38:38 -07002361 }
Glenn Kasten96f04882013-09-20 09:28:56 -07002362 {
2363 AutoMutex lock(mLock);
2364 // The previously assigned value of waitStreamEnd is no longer valid,
2365 // since the mutex has been unlocked and either the callback handler
2366 // or another thread could have re-started the AudioTrack during that time.
2367 waitStreamEnd = mState == STATE_STOPPING;
2368 if (waitStreamEnd) {
2369 mState = STATE_STOPPED;
Andy Hungc2813e52014-10-16 17:54:34 -07002370 mReleased = 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002371 }
2372 }
Glenn Kasten96f04882013-09-20 09:28:56 -07002373 if (waitStreamEnd && status != DEAD_OBJECT) {
2374 return NS_INACTIVE;
2375 }
2376 break;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002377 }
Glenn Kasten96f04882013-09-20 09:28:56 -07002378 return 0;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002379 }
2380
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002381 // perform callbacks while unlocked
2382 if (newUnderrun) {
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002383 mCbf(EVENT_UNDERRUN, mUserData, NULL);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002384 }
Andy Hung53c3b5f2014-12-15 16:42:05 -08002385 while (loopCountNotifications > 0) {
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002386 mCbf(EVENT_LOOP_END, mUserData, NULL);
Andy Hung53c3b5f2014-12-15 16:42:05 -08002387 --loopCountNotifications;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002388 }
2389 if (flags & CBLK_BUFFER_END) {
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002390 mCbf(EVENT_BUFFER_END, mUserData, NULL);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002391 }
2392 if (markerReached) {
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002393 mCbf(EVENT_MARKER, mUserData, &markerPosition);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002394 }
2395 while (newPosCount > 0) {
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002396 size_t temp = newPosition.value(); // FIXME size_t != uint32_t
2397 mCbf(EVENT_NEW_POS, mUserData, &temp);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002398 newPosition += updatePeriod;
2399 newPosCount--;
2400 }
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002401
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002402 if (mObservedSequence != sequence) {
2403 mObservedSequence = sequence;
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002404 mCbf(EVENT_NEW_IAUDIOTRACK, mUserData, NULL);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002405 // for offloaded tracks, just wait for the upper layers to recreate the track
Eric Laurentab5cdba2014-06-09 17:22:27 -07002406 if (isOffloadedOrDirect()) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002407 return NS_INACTIVE;
2408 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002409 }
2410
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002411 // if inactive, then don't run me again until re-started
2412 if (!active) {
2413 return NS_INACTIVE;
Eric Laurent2267ba12011-09-07 11:13:23 -07002414 }
2415
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002416 // Compute the estimated time until the next timed event (position, markers, loops)
2417 // FIXME only for non-compressed audio
2418 uint32_t minFrames = ~0;
2419 if (!markerReached && position < markerPosition) {
Andy Hung90e8a972015-11-09 16:42:40 -08002420 minFrames = (markerPosition - position).value();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002421 }
2422 if (loopPeriod > 0 && loopPeriod < minFrames) {
Andy Hung2d85f092015-01-07 12:45:13 -08002423 // loopPeriod is already adjusted for actual position.
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002424 minFrames = loopPeriod;
2425 }
Andy Hung2d85f092015-01-07 12:45:13 -08002426 if (updatePeriod > 0) {
Andy Hung90e8a972015-11-09 16:42:40 -08002427 minFrames = min(minFrames, (newPosition - position).value());
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002428 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002429
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002430 // If > 0, poll periodically to recover from a stuck server. A good value is 2.
2431 static const uint32_t kPoll = 0;
2432 if (kPoll > 0 && mTransfer == TRANSFER_CALLBACK && kPoll * notificationFrames < minFrames) {
2433 minFrames = kPoll * notificationFrames;
2434 }
Eric Laurentc2f1f072009-07-17 12:17:14 -07002435
Andy Hunga7f03352015-05-31 21:54:49 -07002436 // This "fudge factor" avoids soaking CPU, and compensates for late progress by server
2437 static const nsecs_t kWaitPeriodNs = WAIT_PERIOD_MS * 1000000LL;
2438 const nsecs_t timeAfterCallbacks = systemTime();
2439
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002440 // Convert frame units to time units
2441 nsecs_t ns = NS_WHENEVER;
2442 if (minFrames != (uint32_t) ~0) {
jiabinc7bb8322017-09-06 18:20:11 -07002443 // AudioFlinger consumption of client data may be irregular when coming out of device
2444 // standby since the kernel buffers require filling. This is throttled to no more than 2x
2445 // the expected rate in the MixerThread. Hence, we reduce the estimated time to wait by one
2446 // half (but no more than half a second) to improve callback accuracy during these temporary
2447 // data surges.
2448 const nsecs_t estimatedNs = framesToNanoseconds(minFrames, sampleRate, speed);
2449 constexpr nsecs_t maxThrottleCompensationNs = 500000000LL;
2450 ns = estimatedNs - min(estimatedNs / 2, maxThrottleCompensationNs) + kWaitPeriodNs;
Andy Hunga7f03352015-05-31 21:54:49 -07002451 ns -= (timeAfterCallbacks - timeBeforeCallbacks); // account for callback time
2452 // TODO: Should we warn if the callback time is too long?
2453 if (ns < 0) ns = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002454 }
2455
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07002456 // If not supplying data by EVENT_MORE_DATA or EVENT_CAN_WRITE_MORE_DATA, then we're done
2457 if (mTransfer != TRANSFER_CALLBACK && mTransfer != TRANSFER_SYNC_NOTIF_CALLBACK) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002458 return ns;
2459 }
2460
Andy Hunga7f03352015-05-31 21:54:49 -07002461 // EVENT_MORE_DATA callback handling.
2462 // Timing for linear pcm audio data formats can be derived directly from the
2463 // buffer fill level.
2464 // Timing for compressed data is not directly available from the buffer fill level,
2465 // rather indirectly from waiting for blocking mode callbacks or waiting for obtain()
2466 // to return a certain fill level.
2467
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002468 struct timespec timeout;
2469 const struct timespec *requested = &ClientProxy::kForever;
2470 if (ns != NS_WHENEVER) {
2471 timeout.tv_sec = ns / 1000000000LL;
2472 timeout.tv_nsec = ns % 1000000000LL;
Andy Hungfb8ede22018-09-12 19:03:24 -07002473 ALOGV("%s(%d): timeout %ld.%03d",
Eric Laurent973db022018-11-20 14:54:31 -08002474 __func__, mPortId, timeout.tv_sec, (int) timeout.tv_nsec / 1000000);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002475 requested = &timeout;
2476 }
2477
Andy Hungea2b9c02016-02-12 17:06:53 -08002478 size_t writtenFrames = 0;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002479 while (mRemainingFrames > 0) {
2480
2481 Buffer audioBuffer;
2482 audioBuffer.frameCount = mRemainingFrames;
2483 size_t nonContig;
2484 status_t err = obtainBuffer(&audioBuffer, requested, NULL, &nonContig);
2485 LOG_ALWAYS_FATAL_IF((err != NO_ERROR) != (audioBuffer.frameCount == 0),
Andy Hungfb8ede22018-09-12 19:03:24 -07002486 "%s(%d): obtainBuffer() err=%d frameCount=%zu",
Eric Laurent973db022018-11-20 14:54:31 -08002487 __func__, mPortId, err, audioBuffer.frameCount);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002488 requested = &ClientProxy::kNonBlocking;
2489 size_t avail = audioBuffer.frameCount + nonContig;
Andy Hungfb8ede22018-09-12 19:03:24 -07002490 ALOGV("%s(%d): obtainBuffer(%u) returned %zu = %zu + %zu err %d",
Eric Laurent973db022018-11-20 14:54:31 -08002491 __func__, mPortId, mRemainingFrames, avail, audioBuffer.frameCount, nonContig, err);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002492 if (err != NO_ERROR) {
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002493 if (err == TIMED_OUT || err == WOULD_BLOCK || err == -EINTR ||
2494 (isOffloaded() && (err == DEAD_OBJECT))) {
Glenn Kasten606fbc12015-10-22 15:28:15 -07002495 // FIXME bug 25195759
2496 return 1000000;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002497 }
Andy Hungfb8ede22018-09-12 19:03:24 -07002498 ALOGE("%s(%d): Error %d obtaining an audio buffer, giving up.",
Eric Laurent973db022018-11-20 14:54:31 -08002499 __func__, mPortId, err);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002500 return NS_NEVER;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002501 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002502
Phil Burkfdb3c072016-02-09 10:47:02 -08002503 if (mRetryOnPartialBuffer && audio_has_proportional_frames(mFormat)) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002504 mRetryOnPartialBuffer = false;
2505 if (avail < mRemainingFrames) {
Andy Hunga7f03352015-05-31 21:54:49 -07002506 if (ns > 0) { // account for obtain time
2507 const nsecs_t timeNow = systemTime();
2508 ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks));
2509 }
Andy Hungeb6e6502019-04-29 13:47:40 -07002510
2511 // delayNs is first computed by the additional frames required in the buffer.
2512 nsecs_t delayNs = framesToNanoseconds(
2513 mRemainingFrames - avail, sampleRate, speed);
2514
2515 // afNs is the AudioFlinger mixer period in ns.
2516 const nsecs_t afNs = framesToNanoseconds(mAfFrameCount, mAfSampleRate, speed);
2517
2518 // If the AudioTrack is double buffered based on the AudioFlinger mixer period,
2519 // we may have a race if we wait based on the number of frames desired.
2520 // This is a possible issue with resampling and AAudio.
2521 //
2522 // The granularity of audioflinger processing is one mixer period; if
2523 // our wait time is less than one mixer period, wait at most half the period.
2524 if (delayNs < afNs) {
2525 delayNs = std::min(delayNs, afNs / 2);
2526 }
2527
2528 // adjust our ns wait by delayNs.
2529 if (ns < 0 /* NS_WHENEVER */ || delayNs < ns) {
2530 ns = delayNs;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002531 }
2532 return ns;
2533 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07002534 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002535
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002536 size_t reqSize = audioBuffer.size;
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07002537 if (mTransfer == TRANSFER_SYNC_NOTIF_CALLBACK) {
2538 // when notifying client it can write more data, pass the total size that can be
2539 // written in the next write() call, since it's not passed through the callback
2540 audioBuffer.size += nonContig;
2541 }
Daniel Chapinf13b98a2021-10-25 21:58:31 +00002542 mCbf(mTransfer == TRANSFER_CALLBACK ? EVENT_MORE_DATA : EVENT_CAN_WRITE_MORE_DATA,
2543 mUserData, &audioBuffer);
2544 size_t writtenSize = audioBuffer.size;
2545
Jiabin Huang447cea72020-07-28 22:35:18 +00002546 // Validate on returned size
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002547 if (ssize_t(writtenSize) < 0 || writtenSize > reqSize) {
Andy Hungfb8ede22018-09-12 19:03:24 -07002548 ALOGE("%s(%d): EVENT_MORE_DATA requested %zu bytes but callback returned %zd bytes",
Eric Laurent973db022018-11-20 14:54:31 -08002549 __func__, mPortId, reqSize, ssize_t(writtenSize));
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002550 return NS_NEVER;
2551 }
2552
2553 if (writtenSize == 0) {
Jean-Michel Trivif4158d82018-09-25 12:43:58 -07002554 if (mTransfer == TRANSFER_SYNC_NOTIF_CALLBACK) {
2555 // The callback EVENT_CAN_WRITE_MORE_DATA was processed in the JNI of
2556 // android.media.AudioTrack. The JNI is not using the callback to provide data,
2557 // it only signals to the Java client that it can provide more data, which
2558 // this track is read to accept now.
2559 // The playback thread will be awaken at the next ::write()
2560 return NS_WHENEVER;
2561 }
The Android Open Source Project8555d082009-03-05 14:34:35 -08002562 // The callback is done filling buffers
2563 // Keep this thread going to handle timed events and
2564 // still try to get more data in intervals of WAIT_PERIOD_MS
2565 // but don't just loop and block the CPU, so wait
Andy Hunga7f03352015-05-31 21:54:49 -07002566
2567 // mCbf(EVENT_MORE_DATA, ...) might either
2568 // (1) Block until it can fill the buffer, returning 0 size on EOS.
2569 // (2) Block until it can fill the buffer, returning 0 data (silence) on EOS.
2570 // (3) Return 0 size when no data is available, does not wait for more data.
2571 //
2572 // (1) and (2) occurs with AudioPlayer/AwesomePlayer; (3) occurs with NuPlayer.
2573 // We try to compute the wait time to avoid a tight sleep-wait cycle,
2574 // especially for case (3).
2575 //
2576 // The decision to support (1) and (2) affect the sizing of mRemainingFrames
2577 // and this loop; whereas for case (3) we could simply check once with the full
2578 // buffer size and skip the loop entirely.
2579
2580 nsecs_t myns;
Phil Burkfdb3c072016-02-09 10:47:02 -08002581 if (audio_has_proportional_frames(mFormat)) {
Andy Hunga7f03352015-05-31 21:54:49 -07002582 // time to wait based on buffer occupancy
2583 const nsecs_t datans = mRemainingFrames <= avail ? 0 :
2584 framesToNanoseconds(mRemainingFrames - avail, sampleRate, speed);
2585 // audio flinger thread buffer size (TODO: adjust for fast tracks)
Glenn Kastenea38ee72016-04-18 11:08:01 -07002586 // FIXME: use mAfFrameCountHAL instead of mAfFrameCount below for fast tracks.
Andy Hunga7f03352015-05-31 21:54:49 -07002587 const nsecs_t afns = framesToNanoseconds(mAfFrameCount, mAfSampleRate, speed);
2588 // add a half the AudioFlinger buffer time to avoid soaking CPU if datans is 0.
2589 myns = datans + (afns / 2);
2590 } else {
2591 // FIXME: This could ping quite a bit if the buffer isn't full.
2592 // Note that when mState is stopping we waitStreamEnd, so it never gets here.
2593 myns = kWaitPeriodNs;
2594 }
2595 if (ns > 0) { // account for obtain and callback time
2596 const nsecs_t timeNow = systemTime();
2597 ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks));
2598 }
2599 if (ns < 0 /* NS_WHENEVER */ || myns < ns) {
2600 ns = myns;
2601 }
2602 return ns;
Glenn Kastend65d73c2012-06-22 17:21:07 -07002603 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002604
Glenn Kasten138d6f92015-03-20 10:54:51 -07002605 size_t releasedFrames = writtenSize / mFrameSize;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002606 audioBuffer.frameCount = releasedFrames;
2607 mRemainingFrames -= releasedFrames;
2608 if (misalignment >= releasedFrames) {
2609 misalignment -= releasedFrames;
2610 } else {
2611 misalignment = 0;
2612 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002613
2614 releaseBuffer(&audioBuffer);
Andy Hungea2b9c02016-02-12 17:06:53 -08002615 writtenFrames += releasedFrames;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002616
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002617 // FIXME here is where we would repeat EVENT_MORE_DATA again on same advanced buffer
2618 // if callback doesn't like to accept the full chunk
2619 if (writtenSize < reqSize) {
2620 continue;
2621 }
2622
2623 // There could be enough non-contiguous frames available to satisfy the remaining request
2624 if (mRemainingFrames <= nonContig) {
2625 continue;
2626 }
2627
2628#if 0
2629 // This heuristic tries to collapse a series of EVENT_MORE_DATA that would total to a
2630 // sum <= notificationFrames. It replaces that series by at most two EVENT_MORE_DATA
2631 // that total to a sum == notificationFrames.
2632 if (0 < misalignment && misalignment <= mRemainingFrames) {
2633 mRemainingFrames = misalignment;
Andy Hung8edb8dc2015-03-26 19:13:55 -07002634 return ((double)mRemainingFrames * 1100000000) / ((double)sampleRate * speed);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002635 }
2636#endif
2637
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002638 }
Andy Hungea2b9c02016-02-12 17:06:53 -08002639 if (writtenFrames > 0) {
2640 AutoMutex lock(mLock);
2641 mFramesWritten += writtenFrames;
2642 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002643 mRemainingFrames = notificationFrames;
2644 mRetryOnPartialBuffer = true;
2645
2646 // A lot has transpired since ns was calculated, so run again immediately and re-calculate
2647 return 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002648}
2649
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002650status_t AudioTrack::restoreTrack_l(const char *from)
Eric Laurent1703cdf2011-03-07 14:52:59 -08002651{
Andy Hungb68f5eb2019-12-03 16:49:17 -08002652 status_t result = NO_ERROR; // logged: make sure to set this before returning.
2653 const int64_t beginNs = systemTime();
Andy Hunga6b27032020-04-27 10:34:24 -07002654 mediametrics::Defer defer([&] {
Andy Hungb68f5eb2019-12-03 16:49:17 -08002655 mediametrics::LogItem(mMetricsId)
2656 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_RESTORE)
Andy Hungea840382020-05-05 21:50:17 -07002657 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
Andy Hungb68f5eb2019-12-03 16:49:17 -08002658 .set(AMEDIAMETRICS_PROP_STATE, stateToString(mState))
2659 .set(AMEDIAMETRICS_PROP_STATUS, (int32_t)result)
2660 .set(AMEDIAMETRICS_PROP_WHERE, from)
2661 .record(); });
2662
Andy Hungfb8ede22018-09-12 19:03:24 -07002663 ALOGW("%s(%d): dead IAudioTrack, %s, creating a new one from %s()",
Eric Laurent973db022018-11-20 14:54:31 -08002664 __func__, mPortId, isOffloadedOrDirect_l() ? "Offloaded or Direct" : "PCM", from);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002665 ++mSequence;
Eric Laurent1703cdf2011-03-07 14:52:59 -08002666
Glenn Kastena47f3162012-11-07 10:13:08 -08002667 // refresh the audio configuration cache in this process to make sure we get new
Glenn Kastend2d089f2014-11-05 11:48:12 -08002668 // output parameters and new IAudioFlinger in createTrack_l()
Glenn Kastena47f3162012-11-07 10:13:08 -08002669 AudioSystem::clearAudioConfigCache();
Eric Laurent9f6530f2011-08-30 10:18:54 -07002670
Ronghua Wufaeb0f22015-05-21 12:20:21 -07002671 if (isOffloadedOrDirect_l() || mDoNotReconnect) {
Andy Hung1f1db832015-06-08 13:26:10 -07002672 // FIXME re-creation of offloaded and direct tracks is not yet implemented;
2673 // reconsider enabling for linear PCM encodings when position can be preserved.
Andy Hungb68f5eb2019-12-03 16:49:17 -08002674 result = DEAD_OBJECT;
2675 return result;
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01002676 }
2677
Phil Burk2812d9e2016-01-04 10:34:30 -08002678 // Save so we can return count since creation.
2679 mUnderrunCountOffset = getUnderrunCount_l();
2680
Glenn Kasten200092b2014-08-15 15:13:30 -07002681 // save the old static buffer position
Andy Hungf20a4e92016-08-15 19:10:34 -07002682 uint32_t staticPosition = 0;
Andy Hung4ede21d2014-12-12 15:37:34 -08002683 size_t bufferPosition = 0;
2684 int loopCount = 0;
2685 if (mStaticProxy != 0) {
2686 mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount);
Andy Hungf20a4e92016-08-15 19:10:34 -07002687 staticPosition = mStaticProxy->getPosition().unsignedValue();
Andy Hung4ede21d2014-12-12 15:37:34 -08002688 }
Glenn Kasten200092b2014-08-15 15:13:30 -07002689
Andy Hung3c7f47a2021-03-16 17:30:09 -07002690 // save the old startThreshold and framecount
2691 const uint32_t originalStartThresholdInFrames = mProxy->getStartThresholdInFrames();
2692 const uint32_t originalFrameCount = mProxy->frameCount();
2693
Mikhail Naganovb13b35d2018-03-30 17:21:14 -07002694 // See b/74409267. Connecting to a BT A2DP device supporting multiple codecs
2695 // causes a lot of churn on the service side, and it can reject starting
2696 // playback of a previously created track. May also apply to other cases.
2697 const int INITIAL_RETRIES = 3;
2698 int retries = INITIAL_RETRIES;
2699retry:
2700 if (retries < INITIAL_RETRIES) {
2701 // See the comment for clearAudioConfigCache at the start of the function.
2702 AudioSystem::clearAudioConfigCache();
2703 }
Haynes Mathew Georgeae34ed22016-01-28 11:58:39 -08002704 mFlags = mOrigFlags;
2705
Glenn Kasten200092b2014-08-15 15:13:30 -07002706 // If a new IAudioTrack is successfully created, createTrack_l() will modify the
Glenn Kastena47f3162012-11-07 10:13:08 -08002707 // following member variables: mAudioTrack, mCblkMemory and mCblk.
Glenn Kasten200092b2014-08-15 15:13:30 -07002708 // It will also delete the strong references on previous IAudioTrack and IMemory.
2709 // If a new IAudioTrack cannot be created, the previous (dead) instance will be left intact.
Andy Hungb68f5eb2019-12-03 16:49:17 -08002710 result = createTrack_l();
Eric Laurentcc21e4f2013-10-16 15:12:32 -07002711
Eric Laurent6ec546d2018-10-10 16:52:14 -07002712 if (result == NO_ERROR) {
Andy Hungd7bd69e2015-07-24 07:52:41 -07002713 // take the frames that will be lost by track recreation into account in saved position
2714 // For streaming tracks, this is the amount we obtained from the user/client
2715 // (not the number actually consumed at the server - those are already lost).
2716 if (mStaticProxy == 0) {
2717 mPosition = mReleased;
2718 }
Andy Hung4ede21d2014-12-12 15:37:34 -08002719 // Continue playback from last known position and restore loop.
2720 if (mStaticProxy != 0) {
2721 if (loopCount != 0) {
2722 mStaticProxy->setBufferPositionAndLoop(bufferPosition,
2723 mLoopStart, mLoopEnd, loopCount);
2724 } else {
2725 mStaticProxy->setBufferPosition(bufferPosition);
Andy Hung53c3b5f2014-12-15 16:42:05 -08002726 if (bufferPosition == mFrameCount) {
Eric Laurent973db022018-11-20 14:54:31 -08002727 ALOGD("%s(%d): restoring track at end of static buffer", __func__, mPortId);
Andy Hung53c3b5f2014-12-15 16:42:05 -08002728 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08002729 }
2730 }
Andy Hung4ef88d72017-02-21 19:47:53 -08002731 // restore volume handler
Andy Hung39399b62017-04-21 15:07:45 -07002732 mVolumeHandler->forall([this](const VolumeShaper &shaper) -> VolumeShaper::Status {
2733 sp<VolumeShaper::Operation> operationToEnd =
2734 new VolumeShaper::Operation(shaper.mOperation);
Andy Hung4ef88d72017-02-21 19:47:53 -08002735 // TODO: Ideally we would restore to the exact xOffset position
2736 // as returned by getVolumeShaperState(), but we don't have that
2737 // information when restoring at the client unless we periodically poll
2738 // the server or create shared memory state.
2739 //
Andy Hung39399b62017-04-21 15:07:45 -07002740 // For now, we simply advance to the end of the VolumeShaper effect
2741 // if it has been started.
2742 if (shaper.isStarted()) {
Andy Hungf3702642017-05-05 17:33:32 -07002743 operationToEnd->setNormalizedTime(1.f);
Andy Hung39399b62017-04-21 15:07:45 -07002744 }
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002745 media::VolumeShaperConfiguration config;
2746 shaper.mConfiguration->writeToParcelable(&config);
2747 media::VolumeShaperOperation operation;
2748 operationToEnd->writeToParcelable(&operation);
2749 status_t status;
2750 mAudioTrack->applyVolumeShaper(config, operation, &status);
2751 return status;
Andy Hung4ef88d72017-02-21 19:47:53 -08002752 });
2753
Andy Hung3c7f47a2021-03-16 17:30:09 -07002754 // restore the original start threshold if different than frameCount.
2755 if (originalStartThresholdInFrames != originalFrameCount) {
2756 // Note: mProxy->setStartThresholdInFrames() call is in the Proxy
2757 // and does not trigger a restart.
2758 // (Also CBLK_DISABLED is not set, buffers are empty after track recreation).
2759 // Any start would be triggered on the mState == ACTIVE check below.
2760 const uint32_t currentThreshold =
2761 mProxy->setStartThresholdInFrames(originalStartThresholdInFrames);
2762 ALOGD_IF(originalStartThresholdInFrames != currentThreshold,
2763 "%s(%d) startThresholdInFrames changing from %u to %u",
2764 __func__, mPortId, originalStartThresholdInFrames, currentThreshold);
2765 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002766 if (mState == STATE_ACTIVE) {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002767 mAudioTrack->start(&result);
Eric Laurent1703cdf2011-03-07 14:52:59 -08002768 }
Andy Hungf20a4e92016-08-15 19:10:34 -07002769 // server resets to zero so we offset
2770 mFramesWrittenServerOffset =
2771 mStaticProxy.get() != nullptr ? staticPosition : mFramesWritten;
2772 mFramesWrittenAtRestore = mFramesWrittenServerOffset;
Eric Laurent1703cdf2011-03-07 14:52:59 -08002773 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002774 if (result != NO_ERROR) {
Eric Laurent973db022018-11-20 14:54:31 -08002775 ALOGW("%s(%d): failed status %d, retries %d", __func__, mPortId, result, retries);
Mikhail Naganovb13b35d2018-03-30 17:21:14 -07002776 if (--retries > 0) {
Eric Laurent6ec546d2018-10-10 16:52:14 -07002777 // leave time for an eventual race condition to clear before retrying
2778 usleep(500000);
Mikhail Naganovb13b35d2018-03-30 17:21:14 -07002779 goto retry;
2780 }
Eric Laurent6ec546d2018-10-10 16:52:14 -07002781 // if no retries left, set invalid bit to force restoring at next occasion
2782 // and avoid inconsistent active state on client and server sides
2783 if (mCblk != nullptr) {
2784 android_atomic_or(CBLK_INVALID, &mCblk->mFlags);
2785 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08002786 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08002787 return result;
2788}
2789
Andy Hung90e8a972015-11-09 16:42:40 -08002790Modulo<uint32_t> AudioTrack::updateAndGetPosition_l()
Glenn Kasten200092b2014-08-15 15:13:30 -07002791{
2792 // This is the sole place to read server consumed frames
Andy Hung90e8a972015-11-09 16:42:40 -08002793 Modulo<uint32_t> newServer(mProxy->getPosition());
2794 const int32_t delta = (newServer - mServer).signedValue();
Glenn Kasten200092b2014-08-15 15:13:30 -07002795 // TODO There is controversy about whether there can be "negative jitter" in server position.
2796 // This should be investigated further, and if possible, it should be addressed.
2797 // A more definite failure mode is infrequent polling by client.
2798 // One could call (void)getPosition_l() in releaseBuffer(),
2799 // so mReleased and mPosition are always lock-step as best possible.
2800 // That should ensure delta never goes negative for infrequent polling
2801 // unless the server has more than 2^31 frames in its buffer,
2802 // in which case the use of uint32_t for these counters has bigger issues.
Andy Hung90e8a972015-11-09 16:42:40 -08002803 ALOGE_IF(delta < 0,
Andy Hungfb8ede22018-09-12 19:03:24 -07002804 "%s(%d): detected illegal retrograde motion by the server: mServer advanced by %d",
Eric Laurent973db022018-11-20 14:54:31 -08002805 __func__, mPortId, delta);
Chad Brubaker039c27a2015-09-23 15:17:29 -07002806 mServer = newServer;
Andy Hung90e8a972015-11-09 16:42:40 -08002807 if (delta > 0) { // avoid retrograde
2808 mPosition += delta;
2809 }
2810 return mPosition;
Glenn Kasten200092b2014-08-15 15:13:30 -07002811}
2812
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002813bool AudioTrack::isSampleRateSpeedAllowed_l(uint32_t sampleRate, float speed)
Andy Hung8edb8dc2015-03-26 19:13:55 -07002814{
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002815 updateLatency_l();
Andy Hung8edb8dc2015-03-26 19:13:55 -07002816 // applicable for mixing tracks only (not offloaded or direct)
2817 if (mStaticProxy != 0) {
2818 return true; // static tracks do not have issues with buffer sizing.
2819 }
Andy Hung8edb8dc2015-03-26 19:13:55 -07002820 const size_t minFrameCount =
Eric Laurent21da6472017-11-09 16:29:26 -08002821 AudioSystem::calculateMinFrameCount(mAfLatency, mAfFrameCount, mAfSampleRate,
2822 sampleRate, speed /*, 0 mNotificationsPerBufferReq*/);
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002823 const bool allowed = mFrameCount >= minFrameCount;
2824 ALOGD_IF(!allowed,
Andy Hungfb8ede22018-09-12 19:03:24 -07002825 "%s(%d): denied "
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002826 "mAfLatency:%u mAfFrameCount:%zu mAfSampleRate:%u sampleRate:%u speed:%f "
2827 "mFrameCount:%zu < minFrameCount:%zu",
Eric Laurent973db022018-11-20 14:54:31 -08002828 __func__, mPortId,
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002829 mAfLatency, mAfFrameCount, mAfSampleRate, sampleRate, speed,
Andy Hung8edb8dc2015-03-26 19:13:55 -07002830 mFrameCount, minFrameCount);
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07002831 return allowed;
Andy Hung8edb8dc2015-03-26 19:13:55 -07002832}
2833
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002834status_t AudioTrack::setParameters(const String8& keyValuePairs)
2835{
2836 AutoMutex lock(mLock);
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002837 status_t status;
2838 mAudioTrack->setParameters(keyValuePairs.c_str(), &status);
2839 return status;
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002840}
2841
Dean Wheatleya70eef72018-01-04 14:23:50 +11002842status_t AudioTrack::selectPresentation(int presentationId, int programId)
2843{
2844 AutoMutex lock(mLock);
Eric Laurent973db022018-11-20 14:54:31 -08002845 AudioParameter param = AudioParameter();
2846 param.addInt(String8(AudioParameter::keyPresentationId), presentationId);
2847 param.addInt(String8(AudioParameter::keyProgramId), programId);
2848 ALOGV("%s(%d): PresentationId/ProgramId[%s]",
2849 __func__, mPortId, param.toString().string());
2850
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002851 status_t status;
2852 mAudioTrack->setParameters(param.toString().c_str(), &status);
2853 return status;
Dean Wheatleya70eef72018-01-04 14:23:50 +11002854}
2855
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002856VolumeShaper::Status AudioTrack::applyVolumeShaper(
2857 const sp<VolumeShaper::Configuration>& configuration,
2858 const sp<VolumeShaper::Operation>& operation)
2859{
2860 AutoMutex lock(mLock);
Andy Hung4ef88d72017-02-21 19:47:53 -08002861 mVolumeHandler->setIdIfNecessary(configuration);
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002862 media::VolumeShaperConfiguration config;
2863 configuration->writeToParcelable(&config);
2864 media::VolumeShaperOperation op;
2865 operation->writeToParcelable(&op);
2866 VolumeShaper::Status status;
2867 mAudioTrack->applyVolumeShaper(config, op, &status);
Andy Hung39399b62017-04-21 15:07:45 -07002868
2869 if (status == DEAD_OBJECT) {
2870 if (restoreTrack_l("applyVolumeShaper") == OK) {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002871 mAudioTrack->applyVolumeShaper(config, op, &status);
Andy Hung39399b62017-04-21 15:07:45 -07002872 }
2873 }
Andy Hung4ef88d72017-02-21 19:47:53 -08002874 if (status >= 0) {
2875 // save VolumeShaper for restore
2876 mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hung39399b62017-04-21 15:07:45 -07002877 if (mState == STATE_ACTIVE || mState == STATE_STOPPING) {
2878 mVolumeHandler->setStarted();
2879 }
2880 } else {
2881 // warn only if not an expected restore failure.
2882 ALOGW_IF(!((isOffloadedOrDirect_l() || mDoNotReconnect) && status == DEAD_OBJECT),
Eric Laurent973db022018-11-20 14:54:31 -08002883 "%s(%d): applyVolumeShaper failed: %d", __func__, mPortId, status);
Andy Hung4ef88d72017-02-21 19:47:53 -08002884 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002885 return status;
2886}
2887
2888sp<VolumeShaper::State> AudioTrack::getVolumeShaperState(int id)
2889{
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002890 AutoMutex lock(mLock);
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002891 std::optional<media::VolumeShaperState> vss;
2892 mAudioTrack->getVolumeShaperState(id, &vss);
2893 sp<VolumeShaper::State> state;
2894 if (vss.has_value()) {
2895 state = new VolumeShaper::State();
2896 state->readFromParcelable(vss.value());
2897 }
Andy Hung39399b62017-04-21 15:07:45 -07002898 if (state.get() == nullptr && (mCblk->mFlags & CBLK_INVALID) != 0) {
2899 if (restoreTrack_l("getVolumeShaperState") == OK) {
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002900 mAudioTrack->getVolumeShaperState(id, &vss);
2901 if (vss.has_value()) {
2902 state = new VolumeShaper::State();
2903 state->readFromParcelable(vss.value());
2904 }
Andy Hung39399b62017-04-21 15:07:45 -07002905 }
2906 }
2907 return state;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002908}
2909
Andy Hungea2b9c02016-02-12 17:06:53 -08002910status_t AudioTrack::getTimestamp(ExtendedTimestamp *timestamp)
2911{
2912 if (timestamp == nullptr) {
2913 return BAD_VALUE;
2914 }
2915 AutoMutex lock(mLock);
Andy Hunge13f8a62016-03-30 14:20:42 -07002916 return getTimestamp_l(timestamp);
2917}
2918
2919status_t AudioTrack::getTimestamp_l(ExtendedTimestamp *timestamp)
2920{
Andy Hungea2b9c02016-02-12 17:06:53 -08002921 if (mCblk->mFlags & CBLK_INVALID) {
2922 const status_t status = restoreTrack_l("getTimestampExtended");
2923 if (status != OK) {
2924 // per getTimestamp() API doc in header, we return DEAD_OBJECT here,
2925 // recommending that the track be recreated.
2926 return DEAD_OBJECT;
2927 }
2928 }
2929 // check for offloaded/direct here in case restoring somehow changed those flags.
2930 if (isOffloadedOrDirect_l()) {
2931 return INVALID_OPERATION; // not supported
2932 }
2933 status_t status = mProxy->getTimestamp(timestamp);
Andy Hungfb8ede22018-09-12 19:03:24 -07002934 LOG_ALWAYS_FATAL_IF(status != OK, "%s(%d): status %d not allowed from proxy getTimestamp",
Eric Laurent973db022018-11-20 14:54:31 -08002935 __func__, mPortId, status);
Andy Hungea2b9c02016-02-12 17:06:53 -08002936 bool found = false;
Andy Hunge1e98462016-04-12 10:18:51 -07002937 timestamp->mPosition[ExtendedTimestamp::LOCATION_CLIENT] = mFramesWritten;
2938 timestamp->mTimeNs[ExtendedTimestamp::LOCATION_CLIENT] = 0;
2939 // server side frame offset in case AudioTrack has been restored.
2940 for (int i = ExtendedTimestamp::LOCATION_SERVER;
2941 i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2942 if (timestamp->mTimeNs[i] >= 0) {
2943 // apply server offset (frames flushed is ignored
2944 // so we don't report the jump when the flush occurs).
2945 timestamp->mPosition[i] += mFramesWrittenServerOffset;
2946 found = true;
Andy Hungea2b9c02016-02-12 17:06:53 -08002947 }
2948 }
2949 return found ? OK : WOULD_BLOCK;
2950}
2951
Glenn Kastence703742013-07-19 16:33:58 -07002952status_t AudioTrack::getTimestamp(AudioTimestamp& timestamp)
2953{
Glenn Kasten53cec222013-08-29 09:01:02 -07002954 AutoMutex lock(mLock);
Andy Hung65ffdfc2016-10-10 15:52:11 -07002955 return getTimestamp_l(timestamp);
2956}
Phil Burk1b420972015-04-22 10:52:21 -07002957
Andy Hung65ffdfc2016-10-10 15:52:11 -07002958status_t AudioTrack::getTimestamp_l(AudioTimestamp& timestamp)
2959{
Phil Burk1b420972015-04-22 10:52:21 -07002960 bool previousTimestampValid = mPreviousTimestampValid;
2961 // Set false here to cover all the error return cases.
2962 mPreviousTimestampValid = false;
2963
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002964 switch (mState) {
2965 case STATE_ACTIVE:
2966 case STATE_PAUSED:
2967 break; // handle below
2968 case STATE_FLUSHED:
2969 case STATE_STOPPED:
2970 return WOULD_BLOCK;
2971 case STATE_STOPPING:
2972 case STATE_PAUSED_STOPPING:
2973 if (!isOffloaded_l()) {
2974 return INVALID_OPERATION;
2975 }
2976 break; // offloaded tracks handled below
2977 default:
Andy Hungfb8ede22018-09-12 19:03:24 -07002978 LOG_ALWAYS_FATAL("%s(%d): Invalid mState in getTimestamp(): %d",
Eric Laurent973db022018-11-20 14:54:31 -08002979 __func__, mPortId, mState);
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002980 break;
Glenn Kastenfe346c72013-08-30 13:28:22 -07002981 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07002982
Eric Laurent275e8e92014-11-30 15:14:47 -08002983 if (mCblk->mFlags & CBLK_INVALID) {
Andy Hung6653c932015-06-08 13:27:48 -07002984 const status_t status = restoreTrack_l("getTimestamp");
2985 if (status != OK) {
2986 // per getTimestamp() API doc in header, we return DEAD_OBJECT here,
2987 // recommending that the track be recreated.
2988 return DEAD_OBJECT;
2989 }
Eric Laurent275e8e92014-11-30 15:14:47 -08002990 }
2991
Glenn Kasten200092b2014-08-15 15:13:30 -07002992 // The presented frame count must always lag behind the consumed frame count.
2993 // To avoid a race, read the presented frames first. This ensures that presented <= consumed.
Andy Hung6ae58432016-02-16 18:32:24 -08002994
2995 status_t status;
Andy Hung818e7a32016-02-16 18:08:07 -08002996 if (isOffloadedOrDirect_l()) {
Andy Hung6ae58432016-02-16 18:32:24 -08002997 // use Binder to get timestamp
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08002998 media::AudioTimestampInternal ts;
2999 mAudioTrack->getTimestamp(&ts, &status);
3000 if (status == OK) {
Andy Hung973638a2020-12-08 20:47:45 -08003001 timestamp = VALUE_OR_FATAL(aidl2legacy_AudioTimestampInternal_AudioTimestamp(ts));
Ytai Ben-Tsvibdc293a2020-11-02 17:01:38 -08003002 }
Andy Hung6ae58432016-02-16 18:32:24 -08003003 } else {
3004 // read timestamp from shared memory
3005 ExtendedTimestamp ets;
3006 status = mProxy->getTimestamp(&ets);
3007 if (status == OK) {
Andy Hungb01faa32016-04-27 12:51:32 -07003008 ExtendedTimestamp::Location location;
3009 status = ets.getBestTimestamp(&timestamp, &location);
3010
3011 if (status == OK) {
Haynes Mathew Georgefb12e202017-04-06 12:24:42 -07003012 updateLatency_l();
Andy Hungb01faa32016-04-27 12:51:32 -07003013 // It is possible that the best location has moved from the kernel to the server.
3014 // In this case we adjust the position from the previous computed latency.
3015 if (location == ExtendedTimestamp::LOCATION_SERVER) {
3016 ALOGW_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_KERNEL,
Andy Hungfb8ede22018-09-12 19:03:24 -07003017 "%s(%d): location moved from kernel to server",
Eric Laurent973db022018-11-20 14:54:31 -08003018 __func__, mPortId);
Andy Hung07eee802016-06-21 16:47:16 -07003019 // check that the last kernel OK time info exists and the positions
3020 // are valid (if they predate the current track, the positions may
3021 // be zero or negative).
Andy Hungb01faa32016-04-27 12:51:32 -07003022 const int64_t frames =
Andy Hung6d7b1192016-05-07 22:59:48 -07003023 (ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] < 0 ||
Andy Hung07eee802016-06-21 16:47:16 -07003024 ets.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] < 0 ||
3025 ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] <= 0 ||
3026 ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] <= 0)
Andy Hung6d7b1192016-05-07 22:59:48 -07003027 ?
3028 int64_t((double)mAfLatency * mSampleRate * mPlaybackRate.mSpeed
3029 / 1000)
3030 :
3031 (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK]
3032 - ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK]);
Andy Hungfb8ede22018-09-12 19:03:24 -07003033 ALOGV("%s(%d): frame adjustment:%lld timestamp:%s",
Eric Laurent973db022018-11-20 14:54:31 -08003034 __func__, mPortId, (long long)frames, ets.toString().c_str());
Andy Hungb01faa32016-04-27 12:51:32 -07003035 if (frames >= ets.mPosition[location]) {
3036 timestamp.mPosition = 0;
3037 } else {
3038 timestamp.mPosition = (uint32_t)(ets.mPosition[location] - frames);
3039 }
Andy Hung69488c42016-05-16 18:43:33 -07003040 } else if (location == ExtendedTimestamp::LOCATION_KERNEL) {
3041 ALOGV_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_SERVER,
Andy Hungfb8ede22018-09-12 19:03:24 -07003042 "%s(%d): location moved from server to kernel",
Eric Laurent973db022018-11-20 14:54:31 -08003043 __func__, mPortId);
Andy Hung98731a22019-04-08 19:19:07 -07003044
3045 if (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER] ==
3046 ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL]) {
3047 // In Q, we don't return errors as an invalid time
3048 // but instead we leave the last kernel good timestamp alone.
3049 //
3050 // If server is identical to kernel, the device data pipeline is idle.
3051 // A better start time is now. The retrograde check ensures
3052 // timestamp monotonicity.
3053 const int64_t nowNs = systemTime();
Andy Hungcf3b7152019-04-19 18:29:21 -07003054 if (!mTimestampStallReported) {
3055 ALOGD("%s(%d): device stall time corrected using current time %lld",
3056 __func__, mPortId, (long long)nowNs);
3057 mTimestampStallReported = true;
3058 }
Andy Hung98731a22019-04-08 19:19:07 -07003059 timestamp.mTime = convertNsToTimespec(nowNs);
Andy Hungcf3b7152019-04-19 18:29:21 -07003060 } else {
3061 mTimestampStallReported = false;
Andy Hung98731a22019-04-08 19:19:07 -07003062 }
Andy Hungb01faa32016-04-27 12:51:32 -07003063 }
Andy Hung5d313802016-10-10 15:09:39 -07003064
3065 // We update the timestamp time even when paused.
3066 if (mState == STATE_PAUSED /* not needed: STATE_PAUSED_STOPPING */) {
3067 const int64_t now = systemTime();
Andy Hung2b01f002017-07-05 12:01:36 -07003068 const int64_t at = audio_utils_ns_from_timespec(&timestamp.mTime);
Andy Hung5d313802016-10-10 15:09:39 -07003069 const int64_t lag =
3070 (ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] < 0 ||
3071 ets.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] < 0)
3072 ? int64_t(mAfLatency * 1000000LL)
3073 : (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK]
3074 - ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK])
3075 * NANOS_PER_SECOND / mSampleRate;
3076 const int64_t limit = now - lag; // no earlier than this limit
3077 if (at < limit) {
3078 ALOGV("timestamp pause lag:%lld adjusting from %lld to %lld",
3079 (long long)lag, (long long)at, (long long)limit);
Andy Hungffa36952017-08-17 10:41:51 -07003080 timestamp.mTime = convertNsToTimespec(limit);
Andy Hung5d313802016-10-10 15:09:39 -07003081 }
3082 }
Andy Hungb01faa32016-04-27 12:51:32 -07003083 mPreviousLocation = location;
3084 } else {
3085 // right after AudioTrack is started, one may not find a timestamp
Eric Laurent973db022018-11-20 14:54:31 -08003086 ALOGV("%s(%d): getBestTimestamp did not find timestamp", __func__, mPortId);
Andy Hungb01faa32016-04-27 12:51:32 -07003087 }
Andy Hung6ae58432016-02-16 18:32:24 -08003088 }
3089 if (status == INVALID_OPERATION) {
Andy Hungf20a4e92016-08-15 19:10:34 -07003090 // INVALID_OPERATION occurs when no timestamp has been issued by the server;
3091 // other failures are signaled by a negative time.
3092 // If we come out of FLUSHED or STOPPED where the position is known
3093 // to be zero we convert this to WOULD_BLOCK (with the implicit meaning of
3094 // "zero" for NuPlayer). We don't convert for track restoration as position
3095 // does not reset.
Andy Hungfb8ede22018-09-12 19:03:24 -07003096 ALOGV("%s(%d): timestamp server offset:%lld restore frames:%lld",
Eric Laurent973db022018-11-20 14:54:31 -08003097 __func__, mPortId,
Andy Hungf20a4e92016-08-15 19:10:34 -07003098 (long long)mFramesWrittenServerOffset, (long long)mFramesWrittenAtRestore);
3099 if (mFramesWrittenServerOffset != mFramesWrittenAtRestore) {
3100 status = WOULD_BLOCK;
3101 }
Andy Hung6ae58432016-02-16 18:32:24 -08003102 }
3103 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003104 if (status != NO_ERROR) {
Eric Laurent973db022018-11-20 14:54:31 -08003105 ALOGV_IF(status != WOULD_BLOCK, "%s(%d): getTimestamp error:%#x", __func__, mPortId, status);
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003106 return status;
3107 }
3108 if (isOffloadedOrDirect_l()) {
3109 if (isOffloaded_l() && (mState == STATE_PAUSED || mState == STATE_PAUSED_STOPPING)) {
3110 // use cached paused position in case another offloaded track is running.
3111 timestamp.mPosition = mPausedPosition;
3112 clock_gettime(CLOCK_MONOTONIC, &timestamp.mTime);
Andy Hung5d313802016-10-10 15:09:39 -07003113 // TODO: adjust for delay
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003114 return NO_ERROR;
3115 }
3116
3117 // Check whether a pending flush or stop has completed, as those commands may
Andy Hungc8e09c62015-06-03 23:43:36 -07003118 // be asynchronous or return near finish or exhibit glitchy behavior.
3119 //
3120 // Originally this showed up as the first timestamp being a continuation of
3121 // the previous song under gapless playback.
3122 // However, we sometimes see zero timestamps, then a glitch of
3123 // the previous song's position, and then correct timestamps afterwards.
Andy Hungffa36952017-08-17 10:41:51 -07003124 if (mStartFromZeroUs != 0 && mSampleRate != 0) {
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003125 static const int kTimeJitterUs = 100000; // 100 ms
3126 static const int k1SecUs = 1000000;
3127
3128 const int64_t timeNow = getNowUs();
3129
Andy Hungffa36952017-08-17 10:41:51 -07003130 if (timeNow < mStartFromZeroUs + k1SecUs) { // within first second of starting
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003131 const int64_t timestampTimeUs = convertTimespecToUs(timestamp.mTime);
Andy Hungffa36952017-08-17 10:41:51 -07003132 if (timestampTimeUs < mStartFromZeroUs) {
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003133 return WOULD_BLOCK; // stale timestamp time, occurs before start.
3134 }
Andy Hungffa36952017-08-17 10:41:51 -07003135 const int64_t deltaTimeUs = timestampTimeUs - mStartFromZeroUs;
Andy Hung8edb8dc2015-03-26 19:13:55 -07003136 const int64_t deltaPositionByUs = (double)timestamp.mPosition * 1000000
Ricardo Garcia5a8a95d2015-04-18 14:47:04 -07003137 / ((double)mSampleRate * mPlaybackRate.mSpeed);
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003138
3139 if (deltaPositionByUs > deltaTimeUs + kTimeJitterUs) {
3140 // Verify that the counter can't count faster than the sample rate
Andy Hungc8e09c62015-06-03 23:43:36 -07003141 // since the start time. If greater, then that means we may have failed
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003142 // to completely flush or stop the previous playing track.
Andy Hungc8e09c62015-06-03 23:43:36 -07003143 ALOGW_IF(!mTimestampStartupGlitchReported,
Andy Hungfb8ede22018-09-12 19:03:24 -07003144 "%s(%d): startup glitch detected"
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003145 " deltaTimeUs(%lld) deltaPositionUs(%lld) tsmPosition(%u)",
Eric Laurent973db022018-11-20 14:54:31 -08003146 __func__, mPortId,
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003147 (long long)deltaTimeUs, (long long)deltaPositionByUs,
3148 timestamp.mPosition);
Andy Hungc8e09c62015-06-03 23:43:36 -07003149 mTimestampStartupGlitchReported = true;
3150 if (previousTimestampValid
3151 && mPreviousTimestamp.mPosition == 0 /* should be true if valid */) {
3152 timestamp = mPreviousTimestamp;
3153 mPreviousTimestampValid = true;
3154 return NO_ERROR;
3155 }
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003156 return WOULD_BLOCK;
3157 }
Andy Hungc8e09c62015-06-03 23:43:36 -07003158 if (deltaPositionByUs != 0) {
Andy Hungffa36952017-08-17 10:41:51 -07003159 mStartFromZeroUs = 0; // don't check again, we got valid nonzero position.
Andy Hungc8e09c62015-06-03 23:43:36 -07003160 }
3161 } else {
Andy Hungffa36952017-08-17 10:41:51 -07003162 mStartFromZeroUs = 0; // don't check again, start time expired.
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003163 }
Andy Hungc8e09c62015-06-03 23:43:36 -07003164 mTimestampStartupGlitchReported = false;
Andy Hung7f1bc8a2014-09-12 14:43:11 -07003165 }
3166 } else {
Glenn Kasten200092b2014-08-15 15:13:30 -07003167 // Update the mapping between local consumed (mPosition) and server consumed (mServer)
3168 (void) updateAndGetPosition_l();
3169 // Server consumed (mServer) and presented both use the same server time base,
3170 // and server consumed is always >= presented.
3171 // The delta between these represents the number of frames in the buffer pipeline.
3172 // If this delta between these is greater than the client position, it means that
3173 // actually presented is still stuck at the starting line (figuratively speaking),
3174 // waiting for the first frame to go by. So we can't report a valid timestamp yet.
Andy Hung90e8a972015-11-09 16:42:40 -08003175 // Note: We explicitly use non-Modulo comparison here - potential wrap issue when
3176 // mPosition exceeds 32 bits.
3177 // TODO Remove when timestamp is updated to contain pipeline status info.
3178 const int32_t pipelineDepthInFrames = (mServer - timestamp.mPosition).signedValue();
3179 if (pipelineDepthInFrames > 0 /* should be true, but we check anyways */
3180 && (uint32_t)pipelineDepthInFrames > mPosition.value()) {
Glenn Kasten200092b2014-08-15 15:13:30 -07003181 return INVALID_OPERATION;
3182 }
3183 // Convert timestamp position from server time base to client time base.
3184 // TODO The following code should work OK now because timestamp.mPosition is 32-bit.
3185 // But if we change it to 64-bit then this could fail.
Andy Hung90e8a972015-11-09 16:42:40 -08003186 // Use Modulo computation here.
3187 timestamp.mPosition = (mPosition - mServer + timestamp.mPosition).value();
Glenn Kasten200092b2014-08-15 15:13:30 -07003188 // Immediately after a call to getPosition_l(), mPosition and
3189 // mServer both represent the same frame position. mPosition is
3190 // in client's point of view, and mServer is in server's point of
3191 // view. So the difference between them is the "fudge factor"
3192 // between client and server views due to stop() and/or new
3193 // IAudioTrack. And timestamp.mPosition is initially in server's
3194 // point of view, so we need to apply the same fudge factor to it.
Glenn Kastenfe346c72013-08-30 13:28:22 -07003195 }
Phil Burk1b420972015-04-22 10:52:21 -07003196
3197 // Prevent retrograde motion in timestamp.
3198 // This is sometimes caused by erratic reports of the available space in the ALSA drivers.
3199 if (status == NO_ERROR) {
Andy Hung3b8c6332019-04-03 19:29:36 -07003200 // Fix stale time when checking timestamp right after start().
3201 // The position is at the last reported location but the time can be stale
3202 // due to pause or standby or cold start latency.
3203 //
3204 // We keep advancing the time (but not the position) to ensure that the
3205 // stale value does not confuse the application.
3206 //
3207 // For offload compatibility, use a default lag value here.
3208 // Any time discrepancy between this update and the pause timestamp is handled
3209 // by the retrograde check afterwards.
3210 int64_t currentTimeNanos = audio_utils_ns_from_timespec(&timestamp.mTime);
3211 const int64_t lagNs = int64_t(mAfLatency * 1000000LL);
3212 const int64_t limitNs = mStartNs - lagNs;
3213 if (currentTimeNanos < limitNs) {
Andy Hungcf3b7152019-04-19 18:29:21 -07003214 if (!mTimestampStaleTimeReported) {
3215 ALOGD("%s(%d): stale timestamp time corrected, "
3216 "currentTimeNanos: %lld < limitNs: %lld < mStartNs: %lld",
3217 __func__, mPortId,
3218 (long long)currentTimeNanos, (long long)limitNs, (long long)mStartNs);
3219 mTimestampStaleTimeReported = true;
3220 }
Andy Hung3b8c6332019-04-03 19:29:36 -07003221 timestamp.mTime = convertNsToTimespec(limitNs);
3222 currentTimeNanos = limitNs;
Andy Hungcf3b7152019-04-19 18:29:21 -07003223 } else {
3224 mTimestampStaleTimeReported = false;
Andy Hung3b8c6332019-04-03 19:29:36 -07003225 }
3226
Andy Hungffa36952017-08-17 10:41:51 -07003227 // previousTimestampValid is set to false when starting after a stop or flush.
Phil Burk1b420972015-04-22 10:52:21 -07003228 if (previousTimestampValid) {
Andy Hung2b01f002017-07-05 12:01:36 -07003229 const int64_t previousTimeNanos =
3230 audio_utils_ns_from_timespec(&mPreviousTimestamp.mTime);
Andy Hungffa36952017-08-17 10:41:51 -07003231
3232 // retrograde check
Phil Burk1b420972015-04-22 10:52:21 -07003233 if (currentTimeNanos < previousTimeNanos) {
Andy Hungcf3b7152019-04-19 18:29:21 -07003234 if (!mTimestampRetrogradeTimeReported) {
3235 ALOGW("%s(%d): retrograde timestamp time corrected, %lld < %lld",
3236 __func__, mPortId,
3237 (long long)currentTimeNanos, (long long)previousTimeNanos);
3238 mTimestampRetrogradeTimeReported = true;
3239 }
Andy Hung5d313802016-10-10 15:09:39 -07003240 timestamp.mTime = mPreviousTimestamp.mTime;
Andy Hungcf3b7152019-04-19 18:29:21 -07003241 } else {
3242 mTimestampRetrogradeTimeReported = false;
Phil Burk1b420972015-04-22 10:52:21 -07003243 }
3244
3245 // Looking at signed delta will work even when the timestamps
3246 // are wrapping around.
Andy Hung90e8a972015-11-09 16:42:40 -08003247 int32_t deltaPosition = (Modulo<uint32_t>(timestamp.mPosition)
3248 - mPreviousTimestamp.mPosition).signedValue();
Phil Burk4c5a3672015-04-30 16:18:53 -07003249 if (deltaPosition < 0) {
3250 // Only report once per position instead of spamming the log.
Andy Hungcf3b7152019-04-19 18:29:21 -07003251 if (!mTimestampRetrogradePositionReported) {
Andy Hungfb8ede22018-09-12 19:03:24 -07003252 ALOGW("%s(%d): retrograde timestamp position corrected, %d = %u - %u",
Eric Laurent973db022018-11-20 14:54:31 -08003253 __func__, mPortId,
Phil Burk4c5a3672015-04-30 16:18:53 -07003254 deltaPosition,
3255 timestamp.mPosition,
3256 mPreviousTimestamp.mPosition);
Andy Hungcf3b7152019-04-19 18:29:21 -07003257 mTimestampRetrogradePositionReported = true;
Phil Burk4c5a3672015-04-30 16:18:53 -07003258 }
3259 } else {
Andy Hungcf3b7152019-04-19 18:29:21 -07003260 mTimestampRetrogradePositionReported = false;
Phil Burk4c5a3672015-04-30 16:18:53 -07003261 }
Andy Hung5d313802016-10-10 15:09:39 -07003262 if (deltaPosition < 0) {
3263 timestamp.mPosition = mPreviousTimestamp.mPosition;
3264 deltaPosition = 0;
Phil Burk1b420972015-04-22 10:52:21 -07003265 }
Andy Hung5d313802016-10-10 15:09:39 -07003266#if 0
3267 // Uncomment this to verify audio timestamp rate.
3268 const int64_t deltaTime =
Andy Hung2b01f002017-07-05 12:01:36 -07003269 audio_utils_ns_from_timespec(&timestamp.mTime) - previousTimeNanos;
Andy Hung5d313802016-10-10 15:09:39 -07003270 if (deltaTime != 0) {
3271 const int64_t computedSampleRate =
3272 deltaPosition * (long long)NANOS_PER_SECOND / deltaTime;
Andy Hungfb8ede22018-09-12 19:03:24 -07003273 ALOGD("%s(%d): computedSampleRate:%u sampleRate:%u",
Eric Laurent973db022018-11-20 14:54:31 -08003274 __func__, mPortId,
Andy Hung5d313802016-10-10 15:09:39 -07003275 (unsigned)computedSampleRate, mSampleRate);
3276 }
3277#endif
Phil Burk1b420972015-04-22 10:52:21 -07003278 }
3279 mPreviousTimestamp = timestamp;
3280 mPreviousTimestampValid = true;
3281 }
3282
Glenn Kastenfe346c72013-08-30 13:28:22 -07003283 return status;
Glenn Kastence703742013-07-19 16:33:58 -07003284}
3285
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00003286String8 AudioTrack::getParameters(const String8& keys)
3287{
Glenn Kasten2c6c5292014-01-13 10:29:08 -08003288 audio_io_handle_t output = getOutput();
Glenn Kasten142f5192014-03-25 17:44:59 -07003289 if (output != AUDIO_IO_HANDLE_NONE) {
Glenn Kasten2c6c5292014-01-13 10:29:08 -08003290 return AudioSystem::getParameters(output, keys);
Richard Fitzgeraldb1a270d2013-05-14 12:12:21 +01003291 } else {
3292 return String8::empty();
3293 }
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00003294}
3295
Glenn Kasten23a75452014-01-13 10:37:17 -08003296bool AudioTrack::isOffloaded() const
3297{
3298 AutoMutex lock(mLock);
3299 return isOffloaded_l();
3300}
3301
Eric Laurentab5cdba2014-06-09 17:22:27 -07003302bool AudioTrack::isDirect() const
3303{
3304 AutoMutex lock(mLock);
3305 return isDirect_l();
3306}
3307
3308bool AudioTrack::isOffloadedOrDirect() const
3309{
3310 AutoMutex lock(mLock);
3311 return isOffloadedOrDirect_l();
3312}
3313
3314
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08003315status_t AudioTrack::dump(int fd, const Vector<String16>& args __unused) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08003316{
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08003317 String8 result;
3318
3319 result.append(" AudioTrack::dump\n");
Andy Hungfb8ede22018-09-12 19:03:24 -07003320 result.appendFormat(" id(%d) status(%d), state(%d), session Id(%d), flags(%#x)\n",
Eric Laurent973db022018-11-20 14:54:31 -08003321 mPortId, mStatus, mState, mSessionId, mFlags);
Eric Laurentd114b622017-11-27 18:37:04 -08003322 result.appendFormat(" stream type(%d), left - right volume(%f, %f)\n",
François Gaffie58d4be52018-11-06 15:30:12 +01003323 mStreamType,
Eric Laurentd114b622017-11-27 18:37:04 -08003324 mVolume[AUDIO_INTERLEAVE_LEFT], mVolume[AUDIO_INTERLEAVE_RIGHT]);
Glenn Kasten49f36ba2017-12-06 13:02:02 -08003325 result.appendFormat(" format(%#x), channel mask(%#x), channel count(%u)\n",
Eric Laurentd114b622017-11-27 18:37:04 -08003326 mFormat, mChannelMask, mChannelCount);
3327 result.appendFormat(" sample rate(%u), original sample rate(%u), speed(%f)\n",
3328 mSampleRate, mOriginalSampleRate, mPlaybackRate.mSpeed);
3329 result.appendFormat(" frame count(%zu), req. frame count(%zu)\n",
3330 mFrameCount, mReqFrameCount);
3331 result.appendFormat(" notif. frame count(%u), req. notif. frame count(%u),"
3332 " req. notif. per buff(%u)\n",
3333 mNotificationFramesAct, mNotificationFramesReq, mNotificationsPerBufferReq);
3334 result.appendFormat(" latency (%d), selected device Id(%d), routed device Id(%d)\n",
3335 mLatency, mSelectedDeviceId, mRoutedDeviceId);
3336 result.appendFormat(" output(%d) AF latency (%u) AF frame count(%zu) AF SampleRate(%u)\n",
3337 mOutput, mAfLatency, mAfFrameCount, mAfSampleRate);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08003338 ::write(fd, result.string(), result.size());
3339 return NO_ERROR;
3340}
3341
Phil Burk2812d9e2016-01-04 10:34:30 -08003342uint32_t AudioTrack::getUnderrunCount() const
3343{
3344 AutoMutex lock(mLock);
3345 return getUnderrunCount_l();
3346}
3347
3348uint32_t AudioTrack::getUnderrunCount_l() const
3349{
3350 return mProxy->getUnderrunCount() + mUnderrunCountOffset;
3351}
3352
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003353uint32_t AudioTrack::getUnderrunFrames() const
3354{
3355 AutoMutex lock(mLock);
3356 return mProxy->getUnderrunFrames();
3357}
3358
Andy Hung3a5c2f32021-02-17 15:06:42 -08003359void AudioTrack::setLogSessionId(const char *logSessionId)
3360{
3361 AutoMutex lock(mLock);
Andy Hung1a9c21b2021-02-25 20:43:18 -08003362 if (logSessionId == nullptr) logSessionId = ""; // an empty string is an unset session id.
Andy Hung3a5c2f32021-02-17 15:06:42 -08003363 if (mLogSessionId == logSessionId) return;
3364
3365 mLogSessionId = logSessionId;
3366 mediametrics::LogItem(mMetricsId)
3367 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETLOGSESSIONID)
3368 .set(AMEDIAMETRICS_PROP_LOGSESSIONID, logSessionId)
3369 .record();
3370}
3371
Andy Hung839a3062021-02-17 11:15:16 -08003372void AudioTrack::setPlayerIId(int playerIId)
3373{
3374 AutoMutex lock(mLock);
3375 if (mPlayerIId == playerIId) return;
3376
3377 mPlayerIId = playerIId;
3378 mediametrics::LogItem(mMetricsId)
3379 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_SETPLAYERIID)
3380 .set(AMEDIAMETRICS_PROP_PLAYERIID, playerIId)
3381 .record();
3382}
3383
Eric Laurent296fb132015-05-01 11:38:42 -07003384status_t AudioTrack::addAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback)
3385{
Eric Laurent09f1ed22019-04-24 17:45:17 -07003386
Eric Laurent296fb132015-05-01 11:38:42 -07003387 if (callback == 0) {
Eric Laurent973db022018-11-20 14:54:31 -08003388 ALOGW("%s(%d): adding NULL callback!", __func__, mPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07003389 return BAD_VALUE;
3390 }
3391 AutoMutex lock(mLock);
Eric Laurentad2e7b92017-09-14 20:06:42 -07003392 if (mDeviceCallback.unsafe_get() == callback.get()) {
Eric Laurent973db022018-11-20 14:54:31 -08003393 ALOGW("%s(%d): adding same callback!", __func__, mPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07003394 return INVALID_OPERATION;
3395 }
3396 status_t status = NO_ERROR;
3397 if (mOutput != AUDIO_IO_HANDLE_NONE) {
3398 if (mDeviceCallback != 0) {
Eric Laurent973db022018-11-20 14:54:31 -08003399 ALOGW("%s(%d): callback already present!", __func__, mPortId);
Eric Laurent09f1ed22019-04-24 17:45:17 -07003400 AudioSystem::removeAudioDeviceCallback(this, mOutput, mPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07003401 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07003402 status = AudioSystem::addAudioDeviceCallback(this, mOutput, mPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07003403 }
3404 mDeviceCallback = callback;
3405 return status;
3406}
3407
3408status_t AudioTrack::removeAudioDeviceCallback(
3409 const sp<AudioSystem::AudioDeviceCallback>& callback)
3410{
3411 if (callback == 0) {
Eric Laurent973db022018-11-20 14:54:31 -08003412 ALOGW("%s(%d): removing NULL callback!", __func__, mPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07003413 return BAD_VALUE;
3414 }
Eric Laurent4463ff52019-02-07 13:56:09 -08003415 AutoMutex lock(mLock);
3416 if (mDeviceCallback.unsafe_get() != callback.get()) {
3417 ALOGW("%s removing different callback!", __FUNCTION__);
3418 return INVALID_OPERATION;
Eric Laurent296fb132015-05-01 11:38:42 -07003419 }
Eric Laurent4463ff52019-02-07 13:56:09 -08003420 mDeviceCallback.clear();
Eric Laurent296fb132015-05-01 11:38:42 -07003421 if (mOutput != AUDIO_IO_HANDLE_NONE) {
Eric Laurent09f1ed22019-04-24 17:45:17 -07003422 AudioSystem::removeAudioDeviceCallback(this, mOutput, mPortId);
Eric Laurent296fb132015-05-01 11:38:42 -07003423 }
Eric Laurent296fb132015-05-01 11:38:42 -07003424 return NO_ERROR;
3425}
3426
Eric Laurentad2e7b92017-09-14 20:06:42 -07003427
3428void AudioTrack::onAudioDeviceUpdate(audio_io_handle_t audioIo,
3429 audio_port_handle_t deviceId)
3430{
3431 sp<AudioSystem::AudioDeviceCallback> callback;
3432 {
3433 AutoMutex lock(mLock);
3434 if (audioIo != mOutput) {
3435 return;
3436 }
3437 callback = mDeviceCallback.promote();
3438 // only update device if the track is active as route changes due to other use cases are
3439 // irrelevant for this client
3440 if (mState == STATE_ACTIVE) {
3441 mRoutedDeviceId = deviceId;
3442 }
3443 }
Eric Laurent09f1ed22019-04-24 17:45:17 -07003444
Eric Laurentad2e7b92017-09-14 20:06:42 -07003445 if (callback.get() != nullptr) {
3446 callback->onAudioDeviceUpdate(mOutput, mRoutedDeviceId);
3447 }
3448}
3449
Andy Hunge13f8a62016-03-30 14:20:42 -07003450status_t AudioTrack::pendingDuration(int32_t *msec, ExtendedTimestamp::Location location)
3451{
3452 if (msec == nullptr ||
3453 (location != ExtendedTimestamp::LOCATION_SERVER
3454 && location != ExtendedTimestamp::LOCATION_KERNEL)) {
3455 return BAD_VALUE;
3456 }
3457 AutoMutex lock(mLock);
3458 // inclusive of offloaded and direct tracks.
3459 //
3460 // It is possible, but not enabled, to allow duration computation for non-pcm
3461 // audio_has_proportional_frames() formats because currently they have
3462 // the drain rate equivalent to the pcm sample rate * framesize.
3463 if (!isPurePcmData_l()) {
3464 return INVALID_OPERATION;
3465 }
3466 ExtendedTimestamp ets;
3467 if (getTimestamp_l(&ets) == OK
3468 && ets.mTimeNs[location] > 0) {
3469 int64_t diff = ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT]
3470 - ets.mPosition[location];
3471 if (diff < 0) {
3472 *msec = 0;
3473 } else {
3474 // ms is the playback time by frames
3475 int64_t ms = (int64_t)((double)diff * 1000 /
3476 ((double)mSampleRate * mPlaybackRate.mSpeed));
3477 // clockdiff is the timestamp age (negative)
3478 int64_t clockdiff = (mState != STATE_ACTIVE) ? 0 :
3479 ets.mTimeNs[location]
3480 + ets.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_MONOTONIC]
3481 - systemTime(SYSTEM_TIME_MONOTONIC);
3482
3483 //ALOGV("ms: %lld clockdiff: %lld", (long long)ms, (long long)clockdiff);
3484 static const int NANOS_PER_MILLIS = 1000000;
3485 *msec = (int32_t)(ms + clockdiff / NANOS_PER_MILLIS);
3486 }
3487 return NO_ERROR;
3488 }
3489 if (location != ExtendedTimestamp::LOCATION_SERVER) {
3490 return INVALID_OPERATION; // LOCATION_KERNEL is not available
3491 }
3492 // use server position directly (offloaded and direct arrive here)
3493 updateAndGetPosition_l();
3494 int32_t diff = (Modulo<uint32_t>(mFramesWritten) - mPosition).signedValue();
3495 *msec = (diff <= 0) ? 0
3496 : (int32_t)((double)diff * 1000 / ((double)mSampleRate * mPlaybackRate.mSpeed));
3497 return NO_ERROR;
3498}
3499
Andy Hung65ffdfc2016-10-10 15:52:11 -07003500bool AudioTrack::hasStarted()
3501{
3502 AutoMutex lock(mLock);
3503 switch (mState) {
3504 case STATE_STOPPED:
3505 if (isOffloadedOrDirect_l()) {
3506 // check if we have started in the past to return true.
Andy Hungffa36952017-08-17 10:41:51 -07003507 return mStartFromZeroUs > 0;
Andy Hung65ffdfc2016-10-10 15:52:11 -07003508 }
3509 // A normal audio track may still be draining, so
3510 // check if stream has ended. This covers fasttrack position
3511 // instability and start/stop without any data written.
3512 if (mProxy->getStreamEndDone()) {
3513 return true;
3514 }
Chih-Hung Hsiehffe35582018-09-13 13:59:28 -07003515 FALLTHROUGH_INTENDED;
Andy Hung65ffdfc2016-10-10 15:52:11 -07003516 case STATE_ACTIVE:
3517 case STATE_STOPPING:
3518 break;
3519 case STATE_PAUSED:
3520 case STATE_PAUSED_STOPPING:
3521 case STATE_FLUSHED:
3522 return false; // we're not active
3523 default:
Eric Laurent973db022018-11-20 14:54:31 -08003524 LOG_ALWAYS_FATAL("%s(%d): Invalid mState in hasStarted(): %d", __func__, mPortId, mState);
Andy Hung65ffdfc2016-10-10 15:52:11 -07003525 break;
3526 }
3527
3528 // wait indicates whether we need to wait for a timestamp.
3529 // This is conservatively figured - if we encounter an unexpected error
3530 // then we will not wait.
3531 bool wait = false;
3532 if (isOffloadedOrDirect_l()) {
3533 AudioTimestamp ts;
3534 status_t status = getTimestamp_l(ts);
3535 if (status == WOULD_BLOCK) {
3536 wait = true;
3537 } else if (status == OK) {
3538 wait = (ts.mPosition == 0 || ts.mPosition == mStartTs.mPosition);
3539 }
Andy Hungfb8ede22018-09-12 19:03:24 -07003540 ALOGV("%s(%d): hasStarted wait:%d ts:%u start position:%lld",
Eric Laurent973db022018-11-20 14:54:31 -08003541 __func__, mPortId,
Andy Hung65ffdfc2016-10-10 15:52:11 -07003542 (int)wait,
3543 ts.mPosition,
3544 (long long)mStartTs.mPosition);
3545 } else {
3546 int location = ExtendedTimestamp::LOCATION_SERVER; // for ALOG
3547 ExtendedTimestamp ets;
3548 status_t status = getTimestamp_l(&ets);
3549 if (status == WOULD_BLOCK) { // no SERVER or KERNEL frame info in ets
3550 wait = true;
3551 } else if (status == OK) {
3552 for (location = ExtendedTimestamp::LOCATION_KERNEL;
3553 location >= ExtendedTimestamp::LOCATION_SERVER; --location) {
3554 if (ets.mTimeNs[location] < 0 || mStartEts.mTimeNs[location] < 0) {
3555 continue;
3556 }
3557 wait = ets.mPosition[location] == 0
3558 || ets.mPosition[location] == mStartEts.mPosition[location];
3559 break;
3560 }
3561 }
Andy Hungfb8ede22018-09-12 19:03:24 -07003562 ALOGV("%s(%d): hasStarted wait:%d ets:%lld start position:%lld",
Eric Laurent973db022018-11-20 14:54:31 -08003563 __func__, mPortId,
Andy Hung65ffdfc2016-10-10 15:52:11 -07003564 (int)wait,
3565 (long long)ets.mPosition[location],
3566 (long long)mStartEts.mPosition[location]);
3567 }
3568 return !wait;
3569}
3570
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003571// =========================================================================
3572
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08003573void AudioTrack::DeathNotifier::binderDied(const wp<IBinder>& who __unused)
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003574{
3575 sp<AudioTrack> audioTrack = mAudioTrack.promote();
3576 if (audioTrack != 0) {
3577 AutoMutex lock(audioTrack->mLock);
3578 audioTrack->mProxy->binderDied();
3579 }
3580}
3581
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08003582// =========================================================================
3583
Andy Hungca353672019-03-06 11:54:38 -08003584AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver)
Andy Hungeb46cf92019-03-06 10:13:38 -08003585 : Thread(true /* bCanCallJava */) // binder recursion on restoreTrack_l() may call Java.
3586 , mReceiver(receiver), mPaused(true), mPausedInt(false), mPausedNs(0LL),
Glenn Kasten598de6c2013-10-16 17:02:13 -07003587 mIgnoreNextPausedInt(false)
Glenn Kasten3acbd052012-02-28 10:39:56 -08003588{
3589}
3590
3591AudioTrack::AudioTrackThread::~AudioTrackThread()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08003592{
3593}
3594
3595bool AudioTrack::AudioTrackThread::threadLoop()
3596{
Glenn Kasten3acbd052012-02-28 10:39:56 -08003597 {
3598 AutoMutex _l(mMyLock);
3599 if (mPaused) {
Glenn Kasten75f79032017-05-23 11:22:44 -07003600 // TODO check return value and handle or log
Glenn Kasten3acbd052012-02-28 10:39:56 -08003601 mMyCond.wait(mMyLock);
3602 // caller will check for exitPending()
3603 return true;
3604 }
Glenn Kasten598de6c2013-10-16 17:02:13 -07003605 if (mIgnoreNextPausedInt) {
3606 mIgnoreNextPausedInt = false;
3607 mPausedInt = false;
3608 }
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003609 if (mPausedInt) {
Glenn Kasten47d55172017-05-23 11:19:30 -07003610 // TODO use futex instead of condition, for event flag "or"
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003611 if (mPausedNs > 0) {
Glenn Kasten75f79032017-05-23 11:22:44 -07003612 // TODO check return value and handle or log
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003613 (void) mMyCond.waitRelative(mMyLock, mPausedNs);
3614 } else {
Glenn Kasten75f79032017-05-23 11:22:44 -07003615 // TODO check return value and handle or log
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003616 mMyCond.wait(mMyLock);
3617 }
Eric Laurent9d2c78c2013-09-23 12:29:42 -07003618 mPausedInt = false;
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003619 return true;
3620 }
Glenn Kasten3acbd052012-02-28 10:39:56 -08003621 }
Eric Laurent7985dcb2014-10-07 15:45:14 -07003622 if (exitPending()) {
3623 return false;
3624 }
Glenn Kasten7c7be1e2013-12-19 16:34:04 -08003625 nsecs_t ns = mReceiver.processAudioBuffer();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003626 switch (ns) {
3627 case 0:
3628 return true;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003629 case NS_INACTIVE:
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003630 pauseInternal();
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003631 return true;
3632 case NS_NEVER:
3633 return false;
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003634 case NS_WHENEVER:
Andy Hung3c09c782014-12-29 18:39:32 -08003635 // Event driven: call wake() when callback notifications conditions change.
3636 ns = INT64_MAX;
Chih-Hung Hsiehffe35582018-09-13 13:59:28 -07003637 FALLTHROUGH_INTENDED;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003638 default:
Andy Hungfb8ede22018-09-12 19:03:24 -07003639 LOG_ALWAYS_FATAL_IF(ns < 0, "%s(%d): processAudioBuffer() returned %lld",
Eric Laurent973db022018-11-20 14:54:31 -08003640 __func__, mReceiver.mPortId, (long long)ns);
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003641 pauseInternal(ns);
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003642 return true;
Glenn Kastenca8b2802012-04-23 13:58:16 -07003643 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08003644}
3645
Glenn Kasten3acbd052012-02-28 10:39:56 -08003646void AudioTrack::AudioTrackThread::requestExit()
3647{
3648 // must be in this order to avoid a race condition
3649 Thread::requestExit();
Glenn Kasten598de6c2013-10-16 17:02:13 -07003650 resume();
Glenn Kasten3acbd052012-02-28 10:39:56 -08003651}
3652
3653void AudioTrack::AudioTrackThread::pause()
3654{
3655 AutoMutex _l(mMyLock);
3656 mPaused = true;
3657}
3658
3659void AudioTrack::AudioTrackThread::resume()
3660{
3661 AutoMutex _l(mMyLock);
Glenn Kasten598de6c2013-10-16 17:02:13 -07003662 mIgnoreNextPausedInt = true;
Eric Laurent9d2c78c2013-09-23 12:29:42 -07003663 if (mPaused || mPausedInt) {
Glenn Kasten3acbd052012-02-28 10:39:56 -08003664 mPaused = false;
Eric Laurent9d2c78c2013-09-23 12:29:42 -07003665 mPausedInt = false;
Glenn Kasten3acbd052012-02-28 10:39:56 -08003666 mMyCond.signal();
3667 }
3668}
3669
Andy Hung3c09c782014-12-29 18:39:32 -08003670void AudioTrack::AudioTrackThread::wake()
3671{
3672 AutoMutex _l(mMyLock);
Andy Hunga8d08902015-07-22 11:52:13 -07003673 if (!mPaused) {
3674 // wake() might be called while servicing a callback - ignore the next
3675 // pause time and call processAudioBuffer.
Andy Hung3c09c782014-12-29 18:39:32 -08003676 mIgnoreNextPausedInt = true;
Andy Hunga8d08902015-07-22 11:52:13 -07003677 if (mPausedInt && mPausedNs > 0) {
3678 // audio track is active and internally paused with timeout.
3679 mPausedInt = false;
3680 mMyCond.signal();
3681 }
Andy Hung3c09c782014-12-29 18:39:32 -08003682 }
3683}
3684
Glenn Kasten5a6cd222013-09-20 09:20:45 -07003685void AudioTrack::AudioTrackThread::pauseInternal(nsecs_t ns)
3686{
3687 AutoMutex _l(mMyLock);
3688 mPausedInt = true;
3689 mPausedNs = ns;
3690}
3691
jiabinf6eb4c32020-02-25 14:06:25 -08003692binder::Status AudioTrack::AudioTrackCallback::onCodecFormatChanged(
3693 const std::vector<uint8_t>& audioMetadata)
3694{
3695 AutoMutex _l(mAudioTrackCbLock);
3696 sp<media::IAudioTrackCallback> callback = mCallback.promote();
3697 if (callback.get() != nullptr) {
3698 callback->onCodecFormatChanged(audioMetadata);
3699 } else {
3700 mCallback.clear();
3701 }
3702 return binder::Status::ok();
3703}
3704
3705void AudioTrack::AudioTrackCallback::setAudioTrackCallback(
3706 const sp<media::IAudioTrackCallback> &callback) {
3707 AutoMutex lock(mAudioTrackCbLock);
3708 mCallback = callback;
3709}
3710
Glenn Kasten40bc9062015-03-20 09:09:33 -07003711} // namespace android