blob: 1bd839f8da725b4fdbd8682c2ab0e7fa9a789bf3 [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
18
19//#define LOG_NDEBUG 0
20#define LOG_TAG "AudioTrack"
21
22#include <stdint.h>
23#include <sys/types.h>
24#include <limits.h>
25
26#include <sched.h>
27#include <sys/resource.h>
28
29#include <private/media/AudioTrackShared.h>
30
31#include <media/AudioSystem.h>
32#include <media/AudioTrack.h>
33
34#include <utils/Log.h>
Mathias Agopian75624082009-05-19 19:08:10 -070035#include <binder/Parcel.h>
36#include <binder/IPCThreadState.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080037#include <utils/Timers.h>
Eric Laurent38ccae22011-03-28 18:37:07 -070038#include <utils/Atomic.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080039
Dima Zavinfce7a472011-04-19 22:30:36 -070040#include <cutils/bitops.h>
Glenn Kastenf6b16782011-12-15 09:51:17 -080041#include <cutils/compiler.h>
Dima Zavinfce7a472011-04-19 22:30:36 -070042
Dima Zavin64760242011-05-11 14:15:23 -070043#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070044#include <system/audio_policy.h>
Dima Zavinfce7a472011-04-19 22:30:36 -070045
Glenn Kasten511754b2012-01-11 09:52:19 -080046#include <audio_utils/primitives.h>
47
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080048namespace android {
Chia-chi Yeh33005a92010-06-16 06:33:13 +080049// ---------------------------------------------------------------------------
50
51// static
52status_t AudioTrack::getMinFrameCount(
Glenn Kastene33054e2012-11-14 12:54:39 -080053 size_t* frameCount,
Glenn Kastenfff6d712012-01-12 16:38:12 -080054 audio_stream_type_t streamType,
Chia-chi Yeh33005a92010-06-16 06:33:13 +080055 uint32_t sampleRate)
56{
Glenn Kastend65d73c2012-06-22 17:21:07 -070057 if (frameCount == NULL) {
58 return BAD_VALUE;
59 }
Glenn Kasten04cd0182012-06-25 11:49:27 -070060
61 // default to 0 in case of error
62 *frameCount = 0;
63
Glenn Kastene0fa4672012-04-24 14:35:14 -070064 // FIXME merge with similar code in createTrack_l(), except we're missing
65 // some information here that is available in createTrack_l():
66 // audio_io_handle_t output
67 // audio_format_t format
68 // audio_channel_mask_t channelMask
69 // audio_output_flags_t flags
Glenn Kasten3b16c762012-11-14 08:44:39 -080070 uint32_t afSampleRate;
Chia-chi Yeh33005a92010-06-16 06:33:13 +080071 if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) {
72 return NO_INIT;
73 }
Glenn Kastene33054e2012-11-14 12:54:39 -080074 size_t afFrameCount;
Chia-chi Yeh33005a92010-06-16 06:33:13 +080075 if (AudioSystem::getOutputFrameCount(&afFrameCount, streamType) != NO_ERROR) {
76 return NO_INIT;
77 }
78 uint32_t afLatency;
79 if (AudioSystem::getOutputLatency(&afLatency, streamType) != NO_ERROR) {
80 return NO_INIT;
81 }
82
83 // Ensure that buffer depth covers at least audio hardware latency
84 uint32_t minBufCount = afLatency / ((1000 * afFrameCount) / afSampleRate);
85 if (minBufCount < 2) minBufCount = 2;
86
87 *frameCount = (sampleRate == 0) ? afFrameCount * minBufCount :
Glenn Kastene53b9ea2012-03-12 16:29:55 -070088 afFrameCount * minBufCount * sampleRate / afSampleRate;
Glenn Kasten3acbd052012-02-28 10:39:56 -080089 ALOGV("getMinFrameCount=%d: afFrameCount=%d, minBufCount=%d, afSampleRate=%d, afLatency=%d",
90 *frameCount, afFrameCount, minBufCount, afSampleRate, afLatency);
Chia-chi Yeh33005a92010-06-16 06:33:13 +080091 return NO_ERROR;
92}
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080093
94// ---------------------------------------------------------------------------
95
96AudioTrack::AudioTrack()
Glenn Kasten87913512011-06-22 16:15:25 -070097 : mStatus(NO_INIT),
John Grossman4ff14ba2012-02-08 16:37:41 -080098 mIsTimed(false),
99 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Glenn Kastene3aa6592012-12-04 12:22:46 -0800100 mPreviousSchedulingGroup(SP_DEFAULT),
101 mProxy(NULL)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800102{
103}
104
105AudioTrack::AudioTrack(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800106 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800107 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800108 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700109 audio_channel_mask_t channelMask,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800110 int frameCount,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700111 audio_output_flags_t flags,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800112 callback_t cbf,
113 void* user,
Eric Laurentbe916aa2010-06-01 23:49:17 -0700114 int notificationFrames,
115 int sessionId)
Glenn Kasten87913512011-06-22 16:15:25 -0700116 : mStatus(NO_INIT),
John Grossman4ff14ba2012-02-08 16:37:41 -0800117 mIsTimed(false),
118 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Glenn Kastene3aa6592012-12-04 12:22:46 -0800119 mPreviousSchedulingGroup(SP_DEFAULT),
120 mProxy(NULL)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800121{
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700122 mStatus = set(streamType, sampleRate, format, channelMask,
Eric Laurenta514bdb2010-06-21 09:27:30 -0700123 frameCount, flags, cbf, user, notificationFrames,
Glenn Kasten17a736c2012-02-14 08:52:15 -0800124 0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800125}
126
Andreas Huberc8139852012-01-18 10:51:55 -0800127AudioTrack::AudioTrack(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800128 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800129 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800130 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700131 audio_channel_mask_t channelMask,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800132 const sp<IMemory>& sharedBuffer,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700133 audio_output_flags_t flags,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800134 callback_t cbf,
135 void* user,
Eric Laurentbe916aa2010-06-01 23:49:17 -0700136 int notificationFrames,
137 int sessionId)
Glenn Kasten87913512011-06-22 16:15:25 -0700138 : mStatus(NO_INIT),
John Grossman4ff14ba2012-02-08 16:37:41 -0800139 mIsTimed(false),
140 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
Glenn Kastene3aa6592012-12-04 12:22:46 -0800141 mPreviousSchedulingGroup(SP_DEFAULT),
142 mProxy(NULL)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800143{
Glenn Kasten083d1c12012-11-30 15:00:36 -0800144 if (sharedBuffer == 0) {
145 ALOGE("sharedBuffer must be non-0");
146 mStatus = BAD_VALUE;
147 return;
148 }
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700149 mStatus = set(streamType, sampleRate, format, channelMask,
Glenn Kasten17a736c2012-02-14 08:52:15 -0800150 0 /*frameCount*/, flags, cbf, user, notificationFrames,
151 sharedBuffer, false /*threadCanCallJava*/, sessionId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800152}
153
154AudioTrack::~AudioTrack()
155{
Steve Block3856b092011-10-20 11:56:00 +0100156 ALOGV_IF(mSharedBuffer != 0, "Destructor sharedBuffer: %p", mSharedBuffer->pointer());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800157
158 if (mStatus == NO_ERROR) {
159 // Make sure that callback function exits in the case where
160 // it is looping on buffer full condition in obtainBuffer().
161 // Otherwise the callback thread will never exit.
162 stop();
163 if (mAudioTrackThread != 0) {
Glenn Kasten3acbd052012-02-28 10:39:56 -0800164 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800165 mAudioTrackThread->requestExitAndWait();
166 mAudioTrackThread.clear();
167 }
168 mAudioTrack.clear();
169 IPCThreadState::self()->flushCommands();
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700170 AudioSystem::releaseAudioSessionId(mSessionId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800171 }
Glenn Kastene3aa6592012-12-04 12:22:46 -0800172 delete mProxy;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800173}
174
175status_t AudioTrack::set(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800176 audio_stream_type_t streamType,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800177 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800178 audio_format_t format,
Glenn Kasten28b76b32012-07-03 17:24:41 -0700179 audio_channel_mask_t channelMask,
Glenn Kastene33054e2012-11-14 12:54:39 -0800180 int frameCountInt,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700181 audio_output_flags_t flags,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800182 callback_t cbf,
183 void* user,
184 int notificationFrames,
185 const sp<IMemory>& sharedBuffer,
Eric Laurentbe916aa2010-06-01 23:49:17 -0700186 bool threadCanCallJava,
187 int sessionId)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800188{
Glenn Kastene33054e2012-11-14 12:54:39 -0800189 // FIXME "int" here is legacy and will be replaced by size_t later
190 if (frameCountInt < 0) {
191 ALOGE("Invalid frame count %d", frameCountInt);
192 return BAD_VALUE;
193 }
194 size_t frameCount = frameCountInt;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800195
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700196 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(),
197 sharedBuffer->size());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800198
Glenn Kastene33054e2012-11-14 12:54:39 -0800199 ALOGV("set() streamType %d frameCount %u flags %04x", streamType, frameCount, flags);
Eric Laurent1a9ed112012-03-20 18:36:01 -0700200
Eric Laurent1703cdf2011-03-07 14:52:59 -0800201 AutoMutex lock(mLock);
Eric Laurent1dd70b92009-04-21 07:56:33 -0700202 if (mAudioTrack != 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000203 ALOGE("Track already in use");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800204 return INVALID_OPERATION;
205 }
206
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800207 // handle default values first.
Dima Zavinfce7a472011-04-19 22:30:36 -0700208 if (streamType == AUDIO_STREAM_DEFAULT) {
209 streamType = AUDIO_STREAM_MUSIC;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800210 }
Glenn Kastenea7939a2012-03-14 12:56:26 -0700211
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800212 if (sampleRate == 0) {
Glenn Kasten3b16c762012-11-14 08:44:39 -0800213 uint32_t afSampleRate;
Glenn Kastene0fa4672012-04-24 14:35:14 -0700214 if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) {
215 return NO_INIT;
216 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800217 sampleRate = afSampleRate;
218 }
Glenn Kastene3aa6592012-12-04 12:22:46 -0800219 mSampleRate = sampleRate;
Glenn Kastenea7939a2012-03-14 12:56:26 -0700220
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800221 // these below should probably come from the audioFlinger too...
Glenn Kastene1c39622012-01-04 09:36:37 -0800222 if (format == AUDIO_FORMAT_DEFAULT) {
Dima Zavinfce7a472011-04-19 22:30:36 -0700223 format = AUDIO_FORMAT_PCM_16_BIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800224 }
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700225 if (channelMask == 0) {
226 channelMask = AUDIO_CHANNEL_OUT_STEREO;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800227 }
228
229 // validate parameters
Dima Zavinfce7a472011-04-19 22:30:36 -0700230 if (!audio_is_valid_format(format)) {
Steve Block29357bc2012-01-06 19:20:56 +0000231 ALOGE("Invalid format");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800232 return BAD_VALUE;
233 }
Eric Laurentc2f1f072009-07-17 12:17:14 -0700234
Glenn Kastene0fa4672012-04-24 14:35:14 -0700235 // AudioFlinger does not currently support 8-bit data in shared memory
236 if (format == AUDIO_FORMAT_PCM_8_BIT && sharedBuffer != 0) {
237 ALOGE("8-bit data in shared memory is not supported");
238 return BAD_VALUE;
239 }
240
Eric Laurentc2f1f072009-07-17 12:17:14 -0700241 // force direct flag if format is not linear PCM
Dima Zavinfce7a472011-04-19 22:30:36 -0700242 if (!audio_is_linear_pcm(format)) {
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700243 flags = (audio_output_flags_t)
Glenn Kasten3acbd052012-02-28 10:39:56 -0800244 // FIXME why can't we allow direct AND fast?
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700245 ((flags | AUDIO_OUTPUT_FLAG_DIRECT) & ~AUDIO_OUTPUT_FLAG_FAST);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700246 }
Eric Laurent1948eb32012-04-13 16:50:19 -0700247 // only allow deep buffering for music stream type
248 if (streamType != AUDIO_STREAM_MUSIC) {
249 flags = (audio_output_flags_t)(flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
250 }
Eric Laurentc2f1f072009-07-17 12:17:14 -0700251
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700252 if (!audio_is_output_channel(channelMask)) {
Glenn Kasten28b76b32012-07-03 17:24:41 -0700253 ALOGE("Invalid channel mask %#x", channelMask);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700254 return BAD_VALUE;
255 }
Glenn Kastena42ff002012-11-14 12:47:55 -0800256 mChannelMask = channelMask;
Jean-Michel Trivi0d255b22011-05-24 15:53:33 -0700257 uint32_t channelCount = popcount(channelMask);
Glenn Kastena42ff002012-11-14 12:47:55 -0800258 mChannelCount = channelCount;
Eric Laurentc2f1f072009-07-17 12:17:14 -0700259
Glenn Kastene3aa6592012-12-04 12:22:46 -0800260 if (audio_is_linear_pcm(format)) {
261 mFrameSize = channelCount * audio_bytes_per_sample(format);
262 mFrameSizeAF = channelCount * sizeof(int16_t);
263 } else {
264 mFrameSize = sizeof(uint8_t);
265 mFrameSizeAF = sizeof(uint8_t);
266 }
267
Dima Zavinfce7a472011-04-19 22:30:36 -0700268 audio_io_handle_t output = AudioSystem::getOutput(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800269 streamType,
Glenn Kastene1c39622012-01-04 09:36:37 -0800270 sampleRate, format, channelMask,
Glenn Kasten18868c52012-03-07 09:15:37 -0800271 flags);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700272
273 if (output == 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000274 ALOGE("Could not get audio output for stream type %d", streamType);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800275 return BAD_VALUE;
276 }
277
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800278 mVolume[LEFT] = 1.0f;
279 mVolume[RIGHT] = 1.0f;
Glenn Kasten05632a52012-01-03 14:22:33 -0800280 mSendLevel = 0.0f;
Eric Laurentd1b449a2010-05-14 03:26:45 -0700281 mFrameCount = frameCount;
Glenn Kastenb6037442012-11-14 13:42:25 -0800282 mReqFrameCount = frameCount;
Eric Laurentd1b449a2010-05-14 03:26:45 -0700283 mNotificationFramesReq = notificationFrames;
Eric Laurentbe916aa2010-06-01 23:49:17 -0700284 mSessionId = sessionId;
Eric Laurent2beeb502010-07-16 07:43:46 -0700285 mAuxEffectId = 0;
Glenn Kasten093000f2012-05-03 09:35:36 -0700286 mFlags = flags;
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700287 mCbf = cbf;
Eric Laurentbe916aa2010-06-01 23:49:17 -0700288
Glenn Kastena997e7a2012-08-07 09:44:19 -0700289 if (cbf != NULL) {
Eric Laurent896adcd2012-09-13 11:18:23 -0700290 mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
Glenn Kastena997e7a2012-08-07 09:44:19 -0700291 mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/);
292 }
293
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800294 // create the IAudioTrack
Eric Laurent1703cdf2011-03-07 14:52:59 -0800295 status_t status = createTrack_l(streamType,
296 sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800297 format,
Eric Laurent1703cdf2011-03-07 14:52:59 -0800298 frameCount,
299 flags,
300 sharedBuffer,
Glenn Kasten291f4d52012-03-19 12:16:56 -0700301 output);
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800302
Glenn Kastena997e7a2012-08-07 09:44:19 -0700303 if (status != NO_ERROR) {
304 if (mAudioTrackThread != 0) {
305 mAudioTrackThread->requestExit();
306 mAudioTrackThread.clear();
307 }
308 return status;
Glenn Kasten5d464eb2012-06-22 17:19:53 -0700309 }
310
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800311 mStatus = NO_ERROR;
312
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800313 mStreamType = streamType;
Glenn Kastene1c39622012-01-04 09:36:37 -0800314 mFormat = format;
Glenn Kasten83a03822012-11-12 07:58:20 -0800315
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800316 mSharedBuffer = sharedBuffer;
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800317 mActive = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800318 mUserData = user;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800319 mLoopCount = 0;
320 mMarkerPosition = 0;
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700321 mMarkerReached = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800322 mNewPosition = 0;
323 mUpdatePeriod = 0;
Jean-Michel Trivicd075942011-08-25 16:47:23 -0700324 mFlushed = false;
Marco Nelissen3a34bef2011-08-02 13:33:41 -0700325 AudioSystem::acquireAudioSessionId(mSessionId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800326 return NO_ERROR;
327}
328
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800329// -------------------------------------------------------------------------
330
331void AudioTrack::start()
332{
333 sp<AudioTrackThread> t = mAudioTrackThread;
334
Steve Block3856b092011-10-20 11:56:00 +0100335 ALOGV("start %p", this);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800336
Eric Laurentf5aafb22010-11-18 08:40:16 -0800337 AutoMutex lock(mLock);
Eric Laurent1703cdf2011-03-07 14:52:59 -0800338 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
339 // while we are accessing the cblk
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700340 sp<IAudioTrack> audioTrack = mAudioTrack;
341 sp<IMemory> iMem = mCblkMemory;
Eric Laurent1703cdf2011-03-07 14:52:59 -0800342 audio_track_cblk_t* cblk = mCblk;
343
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800344 if (!mActive) {
Jean-Michel Trivicd075942011-08-25 16:47:23 -0700345 mFlushed = false;
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800346 mActive = true;
Eric Laurent1703cdf2011-03-07 14:52:59 -0800347 mNewPosition = cblk->server + mUpdatePeriod;
Eric Laurent33797ea2011-03-17 09:36:51 -0700348 cblk->lock.lock();
Eric Laurent1703cdf2011-03-07 14:52:59 -0800349 cblk->bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS;
350 cblk->waitTimeMs = 0;
Glenn Kasten9c5fdd82012-11-05 13:38:15 -0800351 android_atomic_and(~CBLK_DISABLED, &cblk->flags);
Eric Laurent2b584242009-11-09 23:32:22 -0800352 if (t != 0) {
Glenn Kasten3acbd052012-02-28 10:39:56 -0800353 t->resume();
Eric Laurent2b584242009-11-09 23:32:22 -0800354 } else {
Glenn Kasten87913512011-06-22 16:15:25 -0700355 mPreviousPriority = getpriority(PRIO_PROCESS, 0);
Glenn Kastena6364332012-04-19 09:35:04 -0700356 get_sched_policy(0, &mPreviousSchedulingGroup);
Glenn Kasten87913512011-06-22 16:15:25 -0700357 androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
Eric Laurent2b584242009-11-09 23:32:22 -0800358 }
359
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700360 ALOGV("start %p before lock cblk %p", this, cblk);
Glenn Kastend3a9ff42012-06-21 12:11:38 -0700361 status_t status = NO_ERROR;
Glenn Kasten9c5fdd82012-11-05 13:38:15 -0800362 if (!(cblk->flags & CBLK_INVALID)) {
Eric Laurent1703cdf2011-03-07 14:52:59 -0800363 cblk->lock.unlock();
Glenn Kasten3acbd052012-02-28 10:39:56 -0800364 ALOGV("mAudioTrack->start()");
365 status = mAudioTrack->start();
Eric Laurent1703cdf2011-03-07 14:52:59 -0800366 cblk->lock.lock();
367 if (status == DEAD_OBJECT) {
Glenn Kasten9c5fdd82012-11-05 13:38:15 -0800368 android_atomic_or(CBLK_INVALID, &cblk->flags);
Eric Laurent6100d2d2009-11-19 09:00:56 -0800369 }
Eric Laurent2b584242009-11-09 23:32:22 -0800370 }
Glenn Kasten9c5fdd82012-11-05 13:38:15 -0800371 if (cblk->flags & CBLK_INVALID) {
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700372 audio_track_cblk_t* temp = cblk;
Glenn Kasten22eb4e22012-11-07 14:03:00 -0800373 status = restoreTrack_l(temp, true /*fromStart*/);
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700374 cblk = temp;
Eric Laurent1703cdf2011-03-07 14:52:59 -0800375 }
376 cblk->lock.unlock();
Eric Laurent2b584242009-11-09 23:32:22 -0800377 if (status != NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +0100378 ALOGV("start() failed");
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800379 mActive = false;
Eric Laurent2b584242009-11-09 23:32:22 -0800380 if (t != 0) {
Glenn Kasten3acbd052012-02-28 10:39:56 -0800381 t->pause();
Eric Laurent2b584242009-11-09 23:32:22 -0800382 } else {
Glenn Kasten87913512011-06-22 16:15:25 -0700383 setpriority(PRIO_PROCESS, 0, mPreviousPriority);
Glenn Kastena6364332012-04-19 09:35:04 -0700384 set_sched_policy(0, mPreviousSchedulingGroup);
Eric Laurent2b584242009-11-09 23:32:22 -0800385 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800386 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800387 }
388
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800389}
390
391void AudioTrack::stop()
392{
393 sp<AudioTrackThread> t = mAudioTrackThread;
394
Steve Block3856b092011-10-20 11:56:00 +0100395 ALOGV("stop %p", this);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800396
Eric Laurentf5aafb22010-11-18 08:40:16 -0800397 AutoMutex lock(mLock);
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800398 if (mActive) {
399 mActive = false;
Eric Laurent1dd70b92009-04-21 07:56:33 -0700400 mCblk->cv.signal();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800401 mAudioTrack->stop();
402 // Cancel loops (If we are in the middle of a loop, playback
403 // would not stop until loopCount reaches 0).
Eric Laurent1703cdf2011-03-07 14:52:59 -0800404 setLoop_l(0, 0, 0);
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700405 // the playback head position will reset to 0, so if a marker is set, we need
406 // to activate it again
407 mMarkerReached = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800408 // Force flush if a shared buffer is used otherwise audioflinger
409 // will not stop before end of buffer is reached.
Glenn Kasten4bae3642012-11-30 13:41:12 -0800410 // It may be needed to make sure that we stop playback, likely in case looping is on.
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800411 if (mSharedBuffer != 0) {
Eric Laurent1703cdf2011-03-07 14:52:59 -0800412 flush_l();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800413 }
414 if (t != 0) {
Glenn Kasten3acbd052012-02-28 10:39:56 -0800415 t->pause();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800416 } else {
Glenn Kasten87913512011-06-22 16:15:25 -0700417 setpriority(PRIO_PROCESS, 0, mPreviousPriority);
Glenn Kastena6364332012-04-19 09:35:04 -0700418 set_sched_policy(0, mPreviousSchedulingGroup);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800419 }
420 }
421
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800422}
423
424bool AudioTrack::stopped() const
425{
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800426 AutoMutex lock(mLock);
427 return stopped_l();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800428}
429
430void AudioTrack::flush()
431{
Eric Laurent1703cdf2011-03-07 14:52:59 -0800432 AutoMutex lock(mLock);
Glenn Kasten4bae3642012-11-30 13:41:12 -0800433 if (!mActive && mSharedBuffer == 0) {
434 flush_l();
435 }
Eric Laurent1703cdf2011-03-07 14:52:59 -0800436}
437
Eric Laurent1703cdf2011-03-07 14:52:59 -0800438void AudioTrack::flush_l()
439{
Steve Block3856b092011-10-20 11:56:00 +0100440 ALOGV("flush");
Glenn Kasten4bae3642012-11-30 13:41:12 -0800441 ALOG_ASSERT(!mActive);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700442
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700443 // clear playback marker and periodic update counter
444 mMarkerPosition = 0;
445 mMarkerReached = false;
446 mUpdatePeriod = 0;
Eric Laurentc2f1f072009-07-17 12:17:14 -0700447
Glenn Kasten4bae3642012-11-30 13:41:12 -0800448 mFlushed = true;
449 mAudioTrack->flush();
450 // Release AudioTrack callback thread in case it was waiting for new buffers
451 // in AudioTrack::obtainBuffer()
452 mCblk->cv.signal();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800453}
454
455void AudioTrack::pause()
456{
Steve Block3856b092011-10-20 11:56:00 +0100457 ALOGV("pause");
Eric Laurentf5aafb22010-11-18 08:40:16 -0800458 AutoMutex lock(mLock);
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800459 if (mActive) {
460 mActive = false;
Eric Laurent192cbba2012-06-13 08:38:36 -0700461 mCblk->cv.signal();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800462 mAudioTrack->pause();
463 }
464}
465
Eric Laurentbe916aa2010-06-01 23:49:17 -0700466status_t AudioTrack::setVolume(float left, float right)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800467{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800468 if (mStatus != NO_ERROR) {
469 return mStatus;
470 }
471 ALOG_ASSERT(mProxy != NULL);
472
Glenn Kastenf0c49502011-11-30 09:46:04 -0800473 if (left < 0.0f || left > 1.0f || right < 0.0f || right > 1.0f) {
Eric Laurentbe916aa2010-06-01 23:49:17 -0700474 return BAD_VALUE;
475 }
476
Eric Laurent1703cdf2011-03-07 14:52:59 -0800477 AutoMutex lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800478 mVolume[LEFT] = left;
479 mVolume[RIGHT] = right;
480
Glenn Kastene3aa6592012-12-04 12:22:46 -0800481 mProxy->setVolumeLR((uint32_t(uint16_t(right * 0x1000)) << 16) | uint16_t(left * 0x1000));
Eric Laurentbe916aa2010-06-01 23:49:17 -0700482
483 return NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800484}
485
Glenn Kastenb1c09932012-02-27 16:21:04 -0800486status_t AudioTrack::setVolume(float volume)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800487{
Glenn Kastenb1c09932012-02-27 16:21:04 -0800488 return setVolume(volume, volume);
Eric Laurentbe916aa2010-06-01 23:49:17 -0700489}
490
Eric Laurent2beeb502010-07-16 07:43:46 -0700491status_t AudioTrack::setAuxEffectSendLevel(float level)
Eric Laurentbe916aa2010-06-01 23:49:17 -0700492{
Steve Block3856b092011-10-20 11:56:00 +0100493 ALOGV("setAuxEffectSendLevel(%f)", level);
Glenn Kastene3aa6592012-12-04 12:22:46 -0800494
495 if (mStatus != NO_ERROR) {
496 return mStatus;
497 }
498 ALOG_ASSERT(mProxy != NULL);
499
Glenn Kasten05632a52012-01-03 14:22:33 -0800500 if (level < 0.0f || level > 1.0f) {
Eric Laurentbe916aa2010-06-01 23:49:17 -0700501 return BAD_VALUE;
502 }
Eric Laurent1703cdf2011-03-07 14:52:59 -0800503 AutoMutex lock(mLock);
Eric Laurentbe916aa2010-06-01 23:49:17 -0700504
505 mSendLevel = level;
Glenn Kastene3aa6592012-12-04 12:22:46 -0800506 mProxy->setSendLevel(level);
Eric Laurentbe916aa2010-06-01 23:49:17 -0700507
508 return NO_ERROR;
509}
510
Glenn Kastena5224f32012-01-04 12:41:44 -0800511void AudioTrack::getAuxEffectSendLevel(float* level) const
Eric Laurentbe916aa2010-06-01 23:49:17 -0700512{
513 if (level != NULL) {
514 *level = mSendLevel;
515 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800516}
517
Glenn Kasten3b16c762012-11-14 08:44:39 -0800518status_t AudioTrack::setSampleRate(uint32_t rate)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800519{
Glenn Kasten3b16c762012-11-14 08:44:39 -0800520 uint32_t afSamplingRate;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800521
John Grossman4ff14ba2012-02-08 16:37:41 -0800522 if (mIsTimed) {
523 return INVALID_OPERATION;
524 }
525
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800526 if (AudioSystem::getOutputSamplingRate(&afSamplingRate, mStreamType) != NO_ERROR) {
Eric Laurent57326622009-07-07 07:10:45 -0700527 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800528 }
529 // Resampler implementation limits input sampling rate to 2 x output sampling rate.
Glenn Kastend65d73c2012-06-22 17:21:07 -0700530 if (rate == 0 || rate > afSamplingRate*2 ) {
531 return BAD_VALUE;
532 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800533
Eric Laurent1703cdf2011-03-07 14:52:59 -0800534 AutoMutex lock(mLock);
Glenn Kastene3aa6592012-12-04 12:22:46 -0800535 mSampleRate = rate;
536 mProxy->setSampleRate(rate);
537
Eric Laurent57326622009-07-07 07:10:45 -0700538 return NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800539}
540
Glenn Kastena5224f32012-01-04 12:41:44 -0800541uint32_t AudioTrack::getSampleRate() const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800542{
John Grossman4ff14ba2012-02-08 16:37:41 -0800543 if (mIsTimed) {
Glenn Kasten3b16c762012-11-14 08:44:39 -0800544 return 0;
John Grossman4ff14ba2012-02-08 16:37:41 -0800545 }
546
Eric Laurent1703cdf2011-03-07 14:52:59 -0800547 AutoMutex lock(mLock);
Glenn Kastene3aa6592012-12-04 12:22:46 -0800548 return mSampleRate;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800549}
550
551status_t AudioTrack::setLoop(uint32_t loopStart, uint32_t loopEnd, int loopCount)
552{
Eric Laurent1703cdf2011-03-07 14:52:59 -0800553 AutoMutex lock(mLock);
554 return setLoop_l(loopStart, loopEnd, loopCount);
555}
556
557// must be called with mLock held
558status_t AudioTrack::setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount)
559{
Glenn Kasten083d1c12012-11-30 15:00:36 -0800560 if (mSharedBuffer == 0 || mIsTimed) {
561 return INVALID_OPERATION;
562 }
563
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800564 audio_track_cblk_t* cblk = mCblk;
565
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800566 Mutex::Autolock _l(cblk->lock);
567
568 if (loopCount == 0) {
569 cblk->loopStart = UINT_MAX;
570 cblk->loopEnd = UINT_MAX;
571 cblk->loopCount = 0;
572 mLoopCount = 0;
573 return NO_ERROR;
574 }
575
576 if (loopStart >= loopEnd ||
Glenn Kastenb6037442012-11-14 13:42:25 -0800577 loopEnd - loopStart > mFrameCount ||
Eric Laurent9b7d9502011-03-21 11:49:00 -0700578 cblk->server > loopStart) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700579 ALOGE("setLoop invalid value: loopStart %d, loopEnd %d, loopCount %d, framecount %d, "
Glenn Kastenb6037442012-11-14 13:42:25 -0800580 "user %d", loopStart, loopEnd, loopCount, mFrameCount, cblk->user);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800581 return BAD_VALUE;
582 }
583
Glenn Kastenb6037442012-11-14 13:42:25 -0800584 if ((mSharedBuffer != 0) && (loopEnd > mFrameCount)) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700585 ALOGE("setLoop invalid value: loop markers beyond data: loopStart %d, loopEnd %d, "
586 "framecount %d",
Glenn Kastenb6037442012-11-14 13:42:25 -0800587 loopStart, loopEnd, mFrameCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800588 return BAD_VALUE;
Eric Laurentc2f1f072009-07-17 12:17:14 -0700589 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800590
591 cblk->loopStart = loopStart;
592 cblk->loopEnd = loopEnd;
593 cblk->loopCount = loopCount;
594 mLoopCount = loopCount;
595
596 return NO_ERROR;
597}
598
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800599status_t AudioTrack::setMarkerPosition(uint32_t marker)
600{
Glenn Kastend65d73c2012-06-22 17:21:07 -0700601 if (mCbf == NULL) {
602 return INVALID_OPERATION;
603 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800604
605 mMarkerPosition = marker;
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -0700606 mMarkerReached = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800607
608 return NO_ERROR;
609}
610
Glenn Kastena5224f32012-01-04 12:41:44 -0800611status_t AudioTrack::getMarkerPosition(uint32_t *marker) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800612{
Glenn Kastend65d73c2012-06-22 17:21:07 -0700613 if (marker == NULL) {
614 return BAD_VALUE;
615 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800616
617 *marker = mMarkerPosition;
618
619 return NO_ERROR;
620}
621
622status_t AudioTrack::setPositionUpdatePeriod(uint32_t updatePeriod)
623{
Glenn Kastend65d73c2012-06-22 17:21:07 -0700624 if (mCbf == NULL) {
625 return INVALID_OPERATION;
626 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800627
628 uint32_t curPosition;
629 getPosition(&curPosition);
630 mNewPosition = curPosition + updatePeriod;
631 mUpdatePeriod = updatePeriod;
632
633 return NO_ERROR;
634}
635
Glenn Kastena5224f32012-01-04 12:41:44 -0800636status_t AudioTrack::getPositionUpdatePeriod(uint32_t *updatePeriod) const
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800637{
Glenn Kastend65d73c2012-06-22 17:21:07 -0700638 if (updatePeriod == NULL) {
639 return BAD_VALUE;
640 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800641
642 *updatePeriod = mUpdatePeriod;
643
644 return NO_ERROR;
645}
646
647status_t AudioTrack::setPosition(uint32_t position)
648{
Glenn Kasten083d1c12012-11-30 15:00:36 -0800649 if (mSharedBuffer == 0 || mIsTimed) {
Glenn Kastend65d73c2012-06-22 17:21:07 -0700650 return INVALID_OPERATION;
651 }
John Grossman4ff14ba2012-02-08 16:37:41 -0800652
Eric Laurent1703cdf2011-03-07 14:52:59 -0800653 AutoMutex lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800654
Glenn Kastend65d73c2012-06-22 17:21:07 -0700655 if (!stopped_l()) {
656 return INVALID_OPERATION;
657 }
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800658
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700659 audio_track_cblk_t* cblk = mCblk;
660 Mutex::Autolock _l(cblk->lock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800661
Glenn Kastend65d73c2012-06-22 17:21:07 -0700662 if (position > cblk->user) {
663 return BAD_VALUE;
664 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800665
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700666 cblk->server = position;
667 android_atomic_or(CBLK_FORCEREADY, &cblk->flags);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700668
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800669 return NO_ERROR;
670}
671
672status_t AudioTrack::getPosition(uint32_t *position)
673{
Glenn Kastend65d73c2012-06-22 17:21:07 -0700674 if (position == NULL) {
675 return BAD_VALUE;
676 }
Eric Laurent1703cdf2011-03-07 14:52:59 -0800677 AutoMutex lock(mLock);
Jean-Michel Trivicd075942011-08-25 16:47:23 -0700678 *position = mFlushed ? 0 : mCblk->server;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800679
680 return NO_ERROR;
681}
682
683status_t AudioTrack::reload()
684{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800685 if (mStatus != NO_ERROR) {
686 return mStatus;
687 }
688 ALOG_ASSERT(mProxy != NULL);
689
Glenn Kasten083d1c12012-11-30 15:00:36 -0800690 if (mSharedBuffer == 0 || mIsTimed) {
691 return INVALID_OPERATION;
692 }
693
Eric Laurent1703cdf2011-03-07 14:52:59 -0800694 AutoMutex lock(mLock);
695
Glenn Kastend65d73c2012-06-22 17:21:07 -0700696 if (!stopped_l()) {
697 return INVALID_OPERATION;
698 }
Eric Laurentc2f1f072009-07-17 12:17:14 -0700699
Eric Laurent1703cdf2011-03-07 14:52:59 -0800700 flush_l();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800701
Glenn Kastene3aa6592012-12-04 12:22:46 -0800702 (void) mProxy->stepUser(mFrameCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800703
704 return NO_ERROR;
705}
706
Eric Laurentc2f1f072009-07-17 12:17:14 -0700707audio_io_handle_t AudioTrack::getOutput()
708{
Eric Laurent1703cdf2011-03-07 14:52:59 -0800709 AutoMutex lock(mLock);
710 return getOutput_l();
711}
712
713// must be called with mLock held
714audio_io_handle_t AudioTrack::getOutput_l()
715{
Glenn Kastenfff6d712012-01-12 16:38:12 -0800716 return AudioSystem::getOutput(mStreamType,
Glenn Kastene3aa6592012-12-04 12:22:46 -0800717 mSampleRate, mFormat, mChannelMask, mFlags);
Eric Laurentc2f1f072009-07-17 12:17:14 -0700718}
719
Eric Laurentbe916aa2010-06-01 23:49:17 -0700720status_t AudioTrack::attachAuxEffect(int effectId)
721{
Steve Block3856b092011-10-20 11:56:00 +0100722 ALOGV("attachAuxEffect(%d)", effectId);
Eric Laurent2beeb502010-07-16 07:43:46 -0700723 status_t status = mAudioTrack->attachAuxEffect(effectId);
724 if (status == NO_ERROR) {
725 mAuxEffectId = effectId;
726 }
727 return status;
Eric Laurentbe916aa2010-06-01 23:49:17 -0700728}
729
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800730// -------------------------------------------------------------------------
731
Eric Laurent1703cdf2011-03-07 14:52:59 -0800732// must be called with mLock held
733status_t AudioTrack::createTrack_l(
Glenn Kastenfff6d712012-01-12 16:38:12 -0800734 audio_stream_type_t streamType,
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800735 uint32_t sampleRate,
Glenn Kastene1c39622012-01-04 09:36:37 -0800736 audio_format_t format,
Glenn Kastene33054e2012-11-14 12:54:39 -0800737 size_t frameCount,
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700738 audio_output_flags_t flags,
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800739 const sp<IMemory>& sharedBuffer,
Glenn Kasten291f4d52012-03-19 12:16:56 -0700740 audio_io_handle_t output)
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800741{
742 status_t status;
743 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
744 if (audioFlinger == 0) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700745 ALOGE("Could not get audioflinger");
746 return NO_INIT;
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800747 }
748
Eric Laurentd1b449a2010-05-14 03:26:45 -0700749 uint32_t afLatency;
Eric Laurent1a9ed112012-03-20 18:36:01 -0700750 if (AudioSystem::getLatency(output, streamType, &afLatency) != NO_ERROR) {
Eric Laurentd1b449a2010-05-14 03:26:45 -0700751 return NO_INIT;
752 }
753
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700754 // Client decides whether the track is TIMED (see below), but can only express a preference
755 // for FAST. Server will perform additional tests.
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700756 if ((flags & AUDIO_OUTPUT_FLAG_FAST) && !(
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700757 // either of these use cases:
758 // use case 1: shared buffer
759 (sharedBuffer != 0) ||
760 // use case 2: callback handler
761 (mCbf != NULL))) {
Glenn Kasten3acbd052012-02-28 10:39:56 -0800762 ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by client");
Glenn Kasten093000f2012-05-03 09:35:36 -0700763 // once denied, do not request again if IAudioTrack is re-created
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700764 flags = (audio_output_flags_t) (flags & ~AUDIO_OUTPUT_FLAG_FAST);
Glenn Kasten093000f2012-05-03 09:35:36 -0700765 mFlags = flags;
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700766 }
Glenn Kastene0fa4672012-04-24 14:35:14 -0700767 ALOGV("createTrack_l() output %d afLatency %d", output, afLatency);
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700768
Eric Laurentd1b449a2010-05-14 03:26:45 -0700769 mNotificationFramesAct = mNotificationFramesReq;
Glenn Kastene0fa4672012-04-24 14:35:14 -0700770
Dima Zavinfce7a472011-04-19 22:30:36 -0700771 if (!audio_is_linear_pcm(format)) {
Glenn Kastene0fa4672012-04-24 14:35:14 -0700772
Eric Laurentd1b449a2010-05-14 03:26:45 -0700773 if (sharedBuffer != 0) {
Glenn Kastene0fa4672012-04-24 14:35:14 -0700774 // Same comment as below about ignoring frameCount parameter for set()
Eric Laurentd1b449a2010-05-14 03:26:45 -0700775 frameCount = sharedBuffer->size();
Glenn Kastene0fa4672012-04-24 14:35:14 -0700776 } else if (frameCount == 0) {
Glenn Kastene33054e2012-11-14 12:54:39 -0800777 size_t afFrameCount;
Glenn Kastene0fa4672012-04-24 14:35:14 -0700778 if (AudioSystem::getFrameCount(output, streamType, &afFrameCount) != NO_ERROR) {
779 return NO_INIT;
780 }
781 frameCount = afFrameCount;
Eric Laurentd1b449a2010-05-14 03:26:45 -0700782 }
Glenn Kastene0fa4672012-04-24 14:35:14 -0700783
784 } else if (sharedBuffer != 0) {
785
Glenn Kastena42ff002012-11-14 12:47:55 -0800786 // Ensure that buffer alignment matches channel count
Glenn Kastene0fa4672012-04-24 14:35:14 -0700787 // 8-bit data in shared memory is not currently supported by AudioFlinger
788 size_t alignment = /* format == AUDIO_FORMAT_PCM_8_BIT ? 1 : */ 2;
Glenn Kastena42ff002012-11-14 12:47:55 -0800789 if (mChannelCount > 1) {
Glenn Kastene0fa4672012-04-24 14:35:14 -0700790 // More than 2 channels does not require stronger alignment than stereo
791 alignment <<= 1;
792 }
Glenn Kastena42ff002012-11-14 12:47:55 -0800793 if (((size_t)sharedBuffer->pointer() & (alignment - 1)) != 0) {
794 ALOGE("Invalid buffer alignment: address %p, channel count %u",
795 sharedBuffer->pointer(), mChannelCount);
Glenn Kastene0fa4672012-04-24 14:35:14 -0700796 return BAD_VALUE;
797 }
798
799 // When initializing a shared buffer AudioTrack via constructors,
800 // there's no frameCount parameter.
801 // But when initializing a shared buffer AudioTrack via set(),
802 // there _is_ a frameCount parameter. We silently ignore it.
Glenn Kastena42ff002012-11-14 12:47:55 -0800803 frameCount = sharedBuffer->size()/mChannelCount/sizeof(int16_t);
Glenn Kastene0fa4672012-04-24 14:35:14 -0700804
805 } else if (!(flags & AUDIO_OUTPUT_FLAG_FAST)) {
806
807 // FIXME move these calculations and associated checks to server
Glenn Kasten3b16c762012-11-14 08:44:39 -0800808 uint32_t afSampleRate;
Glenn Kastene0fa4672012-04-24 14:35:14 -0700809 if (AudioSystem::getSamplingRate(output, streamType, &afSampleRate) != NO_ERROR) {
810 return NO_INIT;
811 }
Glenn Kastene33054e2012-11-14 12:54:39 -0800812 size_t afFrameCount;
Glenn Kastene0fa4672012-04-24 14:35:14 -0700813 if (AudioSystem::getFrameCount(output, streamType, &afFrameCount) != NO_ERROR) {
814 return NO_INIT;
815 }
816
Eric Laurentd1b449a2010-05-14 03:26:45 -0700817 // Ensure that buffer depth covers at least audio hardware latency
818 uint32_t minBufCount = afLatency / ((1000 * afFrameCount)/afSampleRate);
819 if (minBufCount < 2) minBufCount = 2;
820
Glenn Kastene33054e2012-11-14 12:54:39 -0800821 size_t minFrameCount = (afFrameCount*sampleRate*minBufCount)/afSampleRate;
822 ALOGV("minFrameCount: %u, afFrameCount=%d, minBufCount=%d, sampleRate=%u, afSampleRate=%u"
Glenn Kasten3acbd052012-02-28 10:39:56 -0800823 ", afLatency=%d",
824 minFrameCount, afFrameCount, minBufCount, sampleRate, afSampleRate, afLatency);
Glenn Kastene0fa4672012-04-24 14:35:14 -0700825
826 if (frameCount == 0) {
827 frameCount = minFrameCount;
828 }
829 if (mNotificationFramesAct == 0) {
830 mNotificationFramesAct = frameCount/2;
831 }
832 // Make sure that application is notified with sufficient margin
833 // before underrun
Glenn Kastene33054e2012-11-14 12:54:39 -0800834 if (mNotificationFramesAct > frameCount/2) {
Glenn Kastene0fa4672012-04-24 14:35:14 -0700835 mNotificationFramesAct = frameCount/2;
836 }
837 if (frameCount < minFrameCount) {
838 // not ALOGW because it happens all the time when playing key clicks over A2DP
839 ALOGV("Minimum buffer size corrected from %d to %d",
840 frameCount, minFrameCount);
841 frameCount = minFrameCount;
Glenn Kasten3acbd052012-02-28 10:39:56 -0800842 }
Eric Laurentd1b449a2010-05-14 03:26:45 -0700843
Glenn Kastene0fa4672012-04-24 14:35:14 -0700844 } else {
845 // For fast tracks, the frame count calculations and checks are done by server
Eric Laurentd1b449a2010-05-14 03:26:45 -0700846 }
847
Glenn Kastena075db42012-03-06 11:22:44 -0800848 IAudioFlinger::track_flags_t trackFlags = IAudioFlinger::TRACK_DEFAULT;
849 if (mIsTimed) {
850 trackFlags |= IAudioFlinger::TRACK_TIMED;
851 }
Glenn Kasten3acbd052012-02-28 10:39:56 -0800852
853 pid_t tid = -1;
Eric Laurent0ca3cf92012-04-18 09:24:29 -0700854 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700855 trackFlags |= IAudioFlinger::TRACK_FAST;
Glenn Kasten3acbd052012-02-28 10:39:56 -0800856 if (mAudioTrackThread != 0) {
857 tid = mAudioTrackThread->getTid();
858 }
Glenn Kasten4a4a0952012-03-19 11:38:14 -0700859 }
860
Glenn Kasten8d6cc842012-02-03 11:06:53 -0800861 sp<IAudioTrack> track = audioFlinger->createTrack(streamType,
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800862 sampleRate,
Glenn Kasten60a83922012-06-21 12:56:37 -0700863 // AudioFlinger only sees 16-bit PCM
864 format == AUDIO_FORMAT_PCM_8_BIT ?
865 AUDIO_FORMAT_PCM_16_BIT : format,
Glenn Kastena42ff002012-11-14 12:47:55 -0800866 mChannelMask,
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800867 frameCount,
Glenn Kastene0b07172012-11-06 15:03:34 -0800868 &trackFlags,
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800869 sharedBuffer,
870 output,
Glenn Kasten3acbd052012-02-28 10:39:56 -0800871 tid,
Eric Laurentbe916aa2010-06-01 23:49:17 -0700872 &mSessionId,
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800873 &status);
874
875 if (track == 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000876 ALOGE("AudioFlinger could not create track, status: %d", status);
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800877 return status;
878 }
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700879 sp<IMemory> iMem = track->getCblk();
880 if (iMem == 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000881 ALOGE("Could not get control block");
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800882 return NO_INIT;
883 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800884 mAudioTrack = track;
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700885 mCblkMemory = iMem;
886 audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMem->pointer());
887 mCblk = cblk;
Glenn Kastenb6037442012-11-14 13:42:25 -0800888 size_t temp = cblk->frameCount_;
889 if (temp < frameCount || (frameCount == 0 && temp == 0)) {
890 // In current design, AudioTrack client checks and ensures frame count validity before
891 // passing it to AudioFlinger so AudioFlinger should not return a different value except
892 // for fast track as it uses a special method of assigning frame count.
893 ALOGW("Requested frameCount %u but received frameCount %u", frameCount, temp);
894 }
895 frameCount = temp;
Glenn Kasten3acbd052012-02-28 10:39:56 -0800896 if (flags & AUDIO_OUTPUT_FLAG_FAST) {
Glenn Kastene0b07172012-11-06 15:03:34 -0800897 if (trackFlags & IAudioFlinger::TRACK_FAST) {
Glenn Kastenb6037442012-11-14 13:42:25 -0800898 ALOGV("AUDIO_OUTPUT_FLAG_FAST successful; frameCount %u", frameCount);
Glenn Kasten3acbd052012-02-28 10:39:56 -0800899 } else {
Glenn Kastenb6037442012-11-14 13:42:25 -0800900 ALOGV("AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %u", frameCount);
Glenn Kasten093000f2012-05-03 09:35:36 -0700901 // once denied, do not request again if IAudioTrack is re-created
902 flags = (audio_output_flags_t) (flags & ~AUDIO_OUTPUT_FLAG_FAST);
903 mFlags = flags;
Glenn Kasten3acbd052012-02-28 10:39:56 -0800904 }
Glenn Kastene0fa4672012-04-24 14:35:14 -0700905 if (sharedBuffer == 0) {
Glenn Kastenb6037442012-11-14 13:42:25 -0800906 mNotificationFramesAct = frameCount/2;
Glenn Kastene0fa4672012-04-24 14:35:14 -0700907 }
Glenn Kasten3acbd052012-02-28 10:39:56 -0800908 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800909 if (sharedBuffer == 0) {
Glenn Kastenb929e412012-11-08 12:13:58 -0800910 mBuffers = (char*)cblk + sizeof(audio_track_cblk_t);
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800911 } else {
Glenn Kastenb929e412012-11-08 12:13:58 -0800912 mBuffers = sharedBuffer->pointer();
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800913 }
914
Eric Laurent2beeb502010-07-16 07:43:46 -0700915 mAudioTrack->attachAuxEffect(mAuxEffectId);
Glenn Kastend2c38fc2012-11-01 14:58:02 -0700916 cblk->bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS;
917 cblk->waitTimeMs = 0;
Eric Laurentd1b449a2010-05-14 03:26:45 -0700918 mRemainingFrames = mNotificationFramesAct;
Glenn Kastene0fa4672012-04-24 14:35:14 -0700919 // FIXME don't believe this lie
Glenn Kastenb6037442012-11-14 13:42:25 -0800920 mLatency = afLatency + (1000*frameCount) / sampleRate;
921 mFrameCount = frameCount;
Glenn Kasten093000f2012-05-03 09:35:36 -0700922 // If IAudioTrack is re-created, don't let the requested frameCount
923 // decrease. This can confuse clients that cache frameCount().
Glenn Kastenb6037442012-11-14 13:42:25 -0800924 if (frameCount > mReqFrameCount) {
925 mReqFrameCount = frameCount;
Glenn Kasten093000f2012-05-03 09:35:36 -0700926 }
Glenn Kastene3aa6592012-12-04 12:22:46 -0800927
928 // update proxy
929 delete mProxy;
930 mProxy = new AudioTrackClientProxy(cblk, mBuffers, frameCount, mFrameSizeAF);
931 mProxy->setVolumeLR((uint32_t(uint16_t(mVolume[RIGHT] * 0x1000)) << 16) |
932 uint16_t(mVolume[LEFT] * 0x1000));
933 mProxy->setSendLevel(mSendLevel);
934 mProxy->setSampleRate(mSampleRate);
935 if (sharedBuffer != 0) {
936 // Force buffer full condition as data is already present in shared memory
937 mProxy->stepUser(frameCount);
938 }
939
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800940 return NO_ERROR;
941}
942
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800943status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount)
944{
Glenn Kastene3aa6592012-12-04 12:22:46 -0800945 ALOG_ASSERT(mStatus == NO_ERROR && mProxy != NULL);
946
Eric Laurent1703cdf2011-03-07 14:52:59 -0800947 AutoMutex lock(mLock);
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800948 bool active;
Glenn Kastend0965dd2011-06-22 16:18:04 -0700949 status_t result = NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800950 audio_track_cblk_t* cblk = mCblk;
951 uint32_t framesReq = audioBuffer->frameCount;
Eric Laurent1dd70b92009-04-21 07:56:33 -0700952 uint32_t waitTimeMs = (waitCount < 0) ? cblk->bufferTimeoutMs : WAIT_PERIOD_MS;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800953
954 audioBuffer->frameCount = 0;
955 audioBuffer->size = 0;
956
Glenn Kastene3aa6592012-12-04 12:22:46 -0800957 size_t framesAvail = mProxy->framesAvailable();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800958
Eric Laurent9b7d9502011-03-21 11:49:00 -0700959 cblk->lock.lock();
Glenn Kasten9c5fdd82012-11-05 13:38:15 -0800960 if (cblk->flags & CBLK_INVALID) {
Eric Laurent9b7d9502011-03-21 11:49:00 -0700961 goto create_new_track;
962 }
963 cblk->lock.unlock();
964
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800965 if (framesAvail == 0) {
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800966 cblk->lock.lock();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800967 goto start_loop_here;
968 while (framesAvail == 0) {
969 active = mActive;
Glenn Kastenf6b16782011-12-15 09:51:17 -0800970 if (CC_UNLIKELY(!active)) {
Steve Block3856b092011-10-20 11:56:00 +0100971 ALOGV("Not active and NO_MORE_BUFFERS");
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800972 cblk->lock.unlock();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800973 return NO_MORE_BUFFERS;
974 }
Glenn Kastenf6b16782011-12-15 09:51:17 -0800975 if (CC_UNLIKELY(!waitCount)) {
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800976 cblk->lock.unlock();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800977 return WOULD_BLOCK;
Eric Laurent34f1d8e2009-11-04 08:27:26 -0800978 }
Glenn Kasten9c5fdd82012-11-05 13:38:15 -0800979 if (!(cblk->flags & CBLK_INVALID)) {
Eric Laurent1703cdf2011-03-07 14:52:59 -0800980 mLock.unlock();
Glenn Kastena47f3162012-11-07 10:13:08 -0800981 // this condition is in shared memory, so if IAudioTrack and control block
982 // are replaced due to mediaserver death or IAudioTrack invalidation then
983 // cv won't be signalled, but fortunately the timeout will limit the wait
Eric Laurentd1b449a2010-05-14 03:26:45 -0700984 result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs));
Eric Laurentd1b449a2010-05-14 03:26:45 -0700985 cblk->lock.unlock();
Eric Laurent1703cdf2011-03-07 14:52:59 -0800986 mLock.lock();
Glenn Kasten9a2aaf92012-01-03 09:42:47 -0800987 if (!mActive) {
Eric Laurent1703cdf2011-03-07 14:52:59 -0800988 return status_t(STOPPED);
989 }
Glenn Kastena47f3162012-11-07 10:13:08 -0800990 // IAudioTrack may have been re-created while mLock was unlocked
991 cblk = mCblk;
Eric Laurent1703cdf2011-03-07 14:52:59 -0800992 cblk->lock.lock();
993 }
994
Glenn Kasten9c5fdd82012-11-05 13:38:15 -0800995 if (cblk->flags & CBLK_INVALID) {
Eric Laurentd1b449a2010-05-14 03:26:45 -0700996 goto create_new_track;
997 }
Glenn Kastenf6b16782011-12-15 09:51:17 -0800998 if (CC_UNLIKELY(result != NO_ERROR)) {
Eric Laurent1dd70b92009-04-21 07:56:33 -0700999 cblk->waitTimeMs += waitTimeMs;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001000 if (cblk->waitTimeMs >= cblk->bufferTimeoutMs) {
1001 // timing out when a loop has been set and we have already written upto loop end
1002 // is a normal condition: no need to wake AudioFlinger up.
1003 if (cblk->user < cblk->loopEnd) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07001004 ALOGW("obtainBuffer timed out (is the CPU pegged?) %p name=%#x user=%08x, "
1005 "server=%08x", this, cblk->mName, cblk->user, cblk->server);
Eric Laurentc2f1f072009-07-17 12:17:14 -07001006 //unlock cblk mutex before calling mAudioTrack->start() (see issue #1617140)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001007 cblk->lock.unlock();
Glenn Kasten3acbd052012-02-28 10:39:56 -08001008 result = mAudioTrack->start();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001009 cblk->lock.lock();
Eric Laurent1703cdf2011-03-07 14:52:59 -08001010 if (result == DEAD_OBJECT) {
Glenn Kasten9c5fdd82012-11-05 13:38:15 -08001011 android_atomic_or(CBLK_INVALID, &cblk->flags);
Eric Laurent1703cdf2011-03-07 14:52:59 -08001012create_new_track:
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001013 audio_track_cblk_t* temp = cblk;
Glenn Kasten22eb4e22012-11-07 14:03:00 -08001014 result = restoreTrack_l(temp, false /*fromStart*/);
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001015 cblk = temp;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001016 }
1017 if (result != NO_ERROR) {
Steve Block5ff1dd52012-01-05 23:22:43 +00001018 ALOGW("obtainBuffer create Track error %d", result);
Eric Laurent1703cdf2011-03-07 14:52:59 -08001019 cblk->lock.unlock();
1020 return result;
1021 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001022 }
1023 cblk->waitTimeMs = 0;
1024 }
Eric Laurentc2f1f072009-07-17 12:17:14 -07001025
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001026 if (--waitCount == 0) {
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001027 cblk->lock.unlock();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001028 return TIMED_OUT;
1029 }
1030 }
1031 // read the server count again
1032 start_loop_here:
Glenn Kastene3aa6592012-12-04 12:22:46 -08001033 framesAvail = mProxy->framesAvailable_l();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001034 }
Eric Laurent34f1d8e2009-11-04 08:27:26 -08001035 cblk->lock.unlock();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001036 }
1037
1038 cblk->waitTimeMs = 0;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001039
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001040 if (framesReq > framesAvail) {
1041 framesReq = framesAvail;
1042 }
1043
1044 uint32_t u = cblk->user;
Glenn Kastenb6037442012-11-14 13:42:25 -08001045 uint32_t bufferEnd = cblk->userBase + mFrameCount;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001046
Marco Nelissena1472d92012-03-30 14:36:54 -07001047 if (framesReq > bufferEnd - u) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001048 framesReq = bufferEnd - u;
1049 }
1050
Eric Laurentc2f1f072009-07-17 12:17:14 -07001051 audioBuffer->frameCount = framesReq;
Glenn Kasten83a03822012-11-12 07:58:20 -08001052 audioBuffer->size = framesReq * mFrameSizeAF;
Glenn Kastene3aa6592012-12-04 12:22:46 -08001053 audioBuffer->raw = mProxy->buffer(u);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001054 active = mActive;
1055 return active ? status_t(NO_ERROR) : status_t(STOPPED);
1056}
1057
1058void AudioTrack::releaseBuffer(Buffer* audioBuffer)
1059{
Glenn Kastene3aa6592012-12-04 12:22:46 -08001060 ALOG_ASSERT(mStatus == NO_ERROR && mProxy != NULL);
1061
Eric Laurent1703cdf2011-03-07 14:52:59 -08001062 AutoMutex lock(mLock);
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001063 audio_track_cblk_t* cblk = mCblk;
Glenn Kastene3aa6592012-12-04 12:22:46 -08001064 (void) mProxy->stepUser(audioBuffer->frameCount);
Eric Laurentdf839842012-05-31 14:27:14 -07001065 if (audioBuffer->frameCount > 0) {
1066 // restart track if it was disabled by audioflinger due to previous underrun
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001067 if (mActive && (cblk->flags & CBLK_DISABLED)) {
1068 android_atomic_and(~CBLK_DISABLED, &cblk->flags);
1069 ALOGW("releaseBuffer() track %p name=%#x disabled, restarting", this, cblk->mName);
Eric Laurentdf839842012-05-31 14:27:14 -07001070 mAudioTrack->start();
1071 }
1072 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001073}
1074
1075// -------------------------------------------------------------------------
1076
1077ssize_t AudioTrack::write(const void* buffer, size_t userSize)
1078{
1079
Glenn Kasten083d1c12012-11-30 15:00:36 -08001080 if (mSharedBuffer != 0 || mIsTimed) {
Glenn Kastend65d73c2012-06-22 17:21:07 -07001081 return INVALID_OPERATION;
1082 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001083
1084 if (ssize_t(userSize) < 0) {
Glenn Kasten99e53b82012-01-19 08:59:58 -08001085 // Sanity-check: user is most-likely passing an error code, and it would
1086 // make the return value ambiguous (actualSize vs error).
Steve Block29357bc2012-01-06 19:20:56 +00001087 ALOGE("AudioTrack::write(buffer=%p, size=%u (%d)",
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001088 buffer, userSize, userSize);
1089 return BAD_VALUE;
1090 }
1091
Steve Block3856b092011-10-20 11:56:00 +01001092 ALOGV("write %p: %d bytes, mActive=%d", this, userSize, mActive);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001093
Eric Laurentdf839842012-05-31 14:27:14 -07001094 if (userSize == 0) {
1095 return 0;
1096 }
1097
Eric Laurent1703cdf2011-03-07 14:52:59 -08001098 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
1099 // while we are accessing the cblk
1100 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001101 sp<IAudioTrack> audioTrack = mAudioTrack;
1102 sp<IMemory> iMem = mCblkMemory;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001103 mLock.unlock();
1104
Glenn Kastena47f3162012-11-07 10:13:08 -08001105 // since mLock is unlocked the IAudioTrack and shared memory may be re-created,
1106 // so all cblk references might still refer to old shared memory, but that should be benign
1107
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001108 ssize_t written = 0;
1109 const int8_t *src = (const int8_t *)buffer;
1110 Buffer audioBuffer;
Glenn Kastenb9980652012-01-11 09:48:27 -08001111 size_t frameSz = frameSize();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001112
1113 do {
Eric Laurent33797ea2011-03-17 09:36:51 -07001114 audioBuffer.frameCount = userSize/frameSz;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001115
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001116 status_t err = obtainBuffer(&audioBuffer, -1);
1117 if (err < 0) {
1118 // out of buffers, return #bytes written
Glenn Kastend65d73c2012-06-22 17:21:07 -07001119 if (err == status_t(NO_MORE_BUFFERS)) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001120 break;
Glenn Kastend65d73c2012-06-22 17:21:07 -07001121 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001122 return ssize_t(err);
1123 }
1124
1125 size_t toWrite;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001126
Eric Laurent0ca3cf92012-04-18 09:24:29 -07001127 if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001128 // Divide capacity by 2 to take expansion into account
1129 toWrite = audioBuffer.size>>1;
Glenn Kasten511754b2012-01-11 09:52:19 -08001130 memcpy_to_i16_from_u8(audioBuffer.i16, (const uint8_t *) src, toWrite);
Eric Laurent33025262009-08-04 10:42:26 -07001131 } else {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001132 toWrite = audioBuffer.size;
1133 memcpy(audioBuffer.i8, src, toWrite);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001134 }
Glenn Kastenbc0f6b92012-11-12 14:32:06 -08001135 src += toWrite;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001136 userSize -= toWrite;
1137 written += toWrite;
1138
1139 releaseBuffer(&audioBuffer);
Eric Laurent33797ea2011-03-17 09:36:51 -07001140 } while (userSize >= frameSz);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001141
1142 return written;
1143}
1144
1145// -------------------------------------------------------------------------
1146
John Grossman4ff14ba2012-02-08 16:37:41 -08001147TimedAudioTrack::TimedAudioTrack() {
1148 mIsTimed = true;
1149}
1150
1151status_t TimedAudioTrack::allocateTimedBuffer(size_t size, sp<IMemory>* buffer)
1152{
Glenn Kastend5ed6e82012-11-02 13:05:14 -07001153 AutoMutex lock(mLock);
John Grossman4ff14ba2012-02-08 16:37:41 -08001154 status_t result = UNKNOWN_ERROR;
1155
Glenn Kastend5ed6e82012-11-02 13:05:14 -07001156 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
1157 // while we are accessing the cblk
1158 sp<IAudioTrack> audioTrack = mAudioTrack;
1159 sp<IMemory> iMem = mCblkMemory;
1160
John Grossman4ff14ba2012-02-08 16:37:41 -08001161 // If the track is not invalid already, try to allocate a buffer. alloc
1162 // fails indicating that the server is dead, flag the track as invalid so
Glenn Kastenc3ae93f2012-07-30 10:59:30 -07001163 // we can attempt to restore in just a bit.
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001164 audio_track_cblk_t* cblk = mCblk;
1165 if (!(cblk->flags & CBLK_INVALID)) {
John Grossman4ff14ba2012-02-08 16:37:41 -08001166 result = mAudioTrack->allocateTimedBuffer(size, buffer);
1167 if (result == DEAD_OBJECT) {
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001168 android_atomic_or(CBLK_INVALID, &cblk->flags);
John Grossman4ff14ba2012-02-08 16:37:41 -08001169 }
1170 }
1171
1172 // If the track is invalid at this point, attempt to restore it. and try the
1173 // allocation one more time.
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001174 if (cblk->flags & CBLK_INVALID) {
1175 cblk->lock.lock();
1176 audio_track_cblk_t* temp = cblk;
Glenn Kasten22eb4e22012-11-07 14:03:00 -08001177 result = restoreTrack_l(temp, false /*fromStart*/);
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001178 cblk = temp;
1179 cblk->lock.unlock();
John Grossman4ff14ba2012-02-08 16:37:41 -08001180
Glenn Kastend65d73c2012-06-22 17:21:07 -07001181 if (result == OK) {
John Grossman4ff14ba2012-02-08 16:37:41 -08001182 result = mAudioTrack->allocateTimedBuffer(size, buffer);
Glenn Kastend65d73c2012-06-22 17:21:07 -07001183 }
John Grossman4ff14ba2012-02-08 16:37:41 -08001184 }
1185
1186 return result;
1187}
1188
1189status_t TimedAudioTrack::queueTimedBuffer(const sp<IMemory>& buffer,
1190 int64_t pts)
1191{
Eric Laurentdf839842012-05-31 14:27:14 -07001192 status_t status = mAudioTrack->queueTimedBuffer(buffer, pts);
1193 {
1194 AutoMutex lock(mLock);
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001195 audio_track_cblk_t* cblk = mCblk;
Eric Laurentdf839842012-05-31 14:27:14 -07001196 // restart track if it was disabled by audioflinger due to previous underrun
1197 if (buffer->size() != 0 && status == NO_ERROR &&
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001198 mActive && (cblk->flags & CBLK_DISABLED)) {
1199 android_atomic_and(~CBLK_DISABLED, &cblk->flags);
Eric Laurentdf839842012-05-31 14:27:14 -07001200 ALOGW("queueTimedBuffer() track %p disabled, restarting", this);
1201 mAudioTrack->start();
1202 }
John Grossman4ff14ba2012-02-08 16:37:41 -08001203 }
Eric Laurentdf839842012-05-31 14:27:14 -07001204 return status;
John Grossman4ff14ba2012-02-08 16:37:41 -08001205}
1206
1207status_t TimedAudioTrack::setMediaTimeTransform(const LinearTransform& xform,
1208 TargetTimeline target)
1209{
1210 return mAudioTrack->setMediaTimeTransform(xform, target);
1211}
1212
1213// -------------------------------------------------------------------------
1214
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001215bool AudioTrack::processAudioBuffer(const sp<AudioTrackThread>& thread)
1216{
1217 Buffer audioBuffer;
1218 uint32_t frames;
1219 size_t writtenSize;
1220
Eric Laurent1703cdf2011-03-07 14:52:59 -08001221 mLock.lock();
1222 // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
1223 // while we are accessing the cblk
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001224 sp<IAudioTrack> audioTrack = mAudioTrack;
1225 sp<IMemory> iMem = mCblkMemory;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001226 audio_track_cblk_t* cblk = mCblk;
Glenn Kasten9a2aaf92012-01-03 09:42:47 -08001227 bool active = mActive;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001228 mLock.unlock();
1229
Glenn Kastena47f3162012-11-07 10:13:08 -08001230 // since mLock is unlocked the IAudioTrack and shared memory may be re-created,
1231 // so all cblk references might still refer to old shared memory, but that should be benign
1232
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001233 // Manage underrun callback
Glenn Kastene3aa6592012-12-04 12:22:46 -08001234 if (active && (mProxy->framesAvailable() == mFrameCount)) {
Steve Block3856b092011-10-20 11:56:00 +01001235 ALOGV("Underrun user: %x, server: %x, flags %04x", cblk->user, cblk->server, cblk->flags);
Glenn Kasten9c5fdd82012-11-05 13:38:15 -08001236 if (!(android_atomic_or(CBLK_UNDERRUN, &cblk->flags) & CBLK_UNDERRUN)) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001237 mCbf(EVENT_UNDERRUN, mUserData, 0);
Glenn Kastenb6037442012-11-14 13:42:25 -08001238 if (cblk->server == mFrameCount) {
Eric Laurentc2f1f072009-07-17 12:17:14 -07001239 mCbf(EVENT_BUFFER_END, mUserData, 0);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001240 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07001241 if (mSharedBuffer != 0) {
1242 return false;
1243 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001244 }
1245 }
Eric Laurentc2f1f072009-07-17 12:17:14 -07001246
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001247 // Manage loop end callback
Eric Laurent1703cdf2011-03-07 14:52:59 -08001248 while (mLoopCount > cblk->loopCount) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001249 int loopCount = -1;
1250 mLoopCount--;
1251 if (mLoopCount >= 0) loopCount = mLoopCount;
1252
1253 mCbf(EVENT_LOOP_END, mUserData, (void *)&loopCount);
1254 }
1255
1256 // Manage marker callback
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -07001257 if (!mMarkerReached && (mMarkerPosition > 0)) {
Eric Laurent1703cdf2011-03-07 14:52:59 -08001258 if (cblk->server >= mMarkerPosition) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001259 mCbf(EVENT_MARKER, mUserData, (void *)&mMarkerPosition);
Jean-Michel Trivi2c22aeb2009-03-24 18:11:07 -07001260 mMarkerReached = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001261 }
1262 }
1263
1264 // Manage new position callback
Eric Laurentc2f1f072009-07-17 12:17:14 -07001265 if (mUpdatePeriod > 0) {
Eric Laurent1703cdf2011-03-07 14:52:59 -08001266 while (cblk->server >= mNewPosition) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001267 mCbf(EVENT_NEW_POS, mUserData, (void *)&mNewPosition);
1268 mNewPosition += mUpdatePeriod;
1269 }
1270 }
1271
1272 // If Shared buffer is used, no data is requested from client.
1273 if (mSharedBuffer != 0) {
1274 frames = 0;
1275 } else {
1276 frames = mRemainingFrames;
1277 }
1278
Glenn Kasten99e53b82012-01-19 08:59:58 -08001279 // See description of waitCount parameter at declaration of obtainBuffer().
1280 // The logic below prevents us from being stuck below at obtainBuffer()
1281 // not being able to handle timed events (position, markers, loops).
Eric Laurent2267ba12011-09-07 11:13:23 -07001282 int32_t waitCount = -1;
1283 if (mUpdatePeriod || (!mMarkerReached && mMarkerPosition) || mLoopCount) {
1284 waitCount = 1;
1285 }
1286
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001287 do {
1288
1289 audioBuffer.frameCount = frames;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001290
Eric Laurent2267ba12011-09-07 11:13:23 -07001291 status_t err = obtainBuffer(&audioBuffer, waitCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001292 if (err < NO_ERROR) {
1293 if (err != TIMED_OUT) {
Glenn Kasten85ab62c2012-11-01 11:11:38 -07001294 ALOGE_IF(err != status_t(NO_MORE_BUFFERS),
1295 "Error obtaining an audio buffer, giving up.");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001296 return false;
1297 }
1298 break;
1299 }
Glenn Kastend65d73c2012-06-22 17:21:07 -07001300 if (err == status_t(STOPPED)) {
1301 return false;
1302 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001303
1304 // Divide buffer size by 2 to take into account the expansion
1305 // due to 8 to 16 bit conversion: the callback must fill only half
1306 // of the destination buffer
Eric Laurent0ca3cf92012-04-18 09:24:29 -07001307 if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001308 audioBuffer.size >>= 1;
1309 }
1310
1311 size_t reqSize = audioBuffer.size;
1312 mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);
1313 writtenSize = audioBuffer.size;
1314
1315 // Sanity check on returned size
The Android Open Source Project8555d082009-03-05 14:34:35 -08001316 if (ssize_t(writtenSize) <= 0) {
1317 // The callback is done filling buffers
1318 // Keep this thread going to handle timed events and
1319 // still try to get more data in intervals of WAIT_PERIOD_MS
1320 // but don't just loop and block the CPU, so wait
1321 usleep(WAIT_PERIOD_MS*1000);
1322 break;
1323 }
Eric Laurentdf839842012-05-31 14:27:14 -07001324
Glenn Kastend65d73c2012-06-22 17:21:07 -07001325 if (writtenSize > reqSize) {
1326 writtenSize = reqSize;
1327 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001328
Eric Laurent0ca3cf92012-04-18 09:24:29 -07001329 if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) {
Glenn Kasten511754b2012-01-11 09:52:19 -08001330 // 8 to 16 bit conversion, note that source and destination are the same address
1331 memcpy_to_i16_from_u8(audioBuffer.i16, (const uint8_t *) audioBuffer.i8, writtenSize);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001332 writtenSize <<= 1;
1333 }
1334
1335 audioBuffer.size = writtenSize;
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001336 // NOTE: cblk->frameSize is not equal to AudioTrack::frameSize() for
1337 // 8 bit PCM data: in this case, cblk->frameSize is based on a sample size of
Eric Laurentc2f1f072009-07-17 12:17:14 -07001338 // 16 bit.
Glenn Kasten83a03822012-11-12 07:58:20 -08001339 audioBuffer.frameCount = writtenSize / mFrameSizeAF;
Eric Laurentc2f1f072009-07-17 12:17:14 -07001340
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001341 frames -= audioBuffer.frameCount;
1342
1343 releaseBuffer(&audioBuffer);
1344 }
1345 while (frames);
1346
1347 if (frames == 0) {
Eric Laurentd1b449a2010-05-14 03:26:45 -07001348 mRemainingFrames = mNotificationFramesAct;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001349 } else {
1350 mRemainingFrames = frames;
1351 }
1352 return true;
1353}
1354
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001355// must be called with mLock and refCblk.lock held. Callers must also hold strong references on
Eric Laurent1703cdf2011-03-07 14:52:59 -08001356// the IAudioTrack and IMemory in case they are recreated here.
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001357// If the IAudioTrack is successfully restored, the refCblk pointer is updated
1358// FIXME Don't depend on caller to hold strong references.
1359status_t AudioTrack::restoreTrack_l(audio_track_cblk_t*& refCblk, bool fromStart)
Eric Laurent1703cdf2011-03-07 14:52:59 -08001360{
1361 status_t result;
1362
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001363 audio_track_cblk_t* cblk = refCblk;
1364 audio_track_cblk_t* newCblk = cblk;
Glenn Kasten827e5f12012-11-02 10:00:06 -07001365 ALOGW("dead IAudioTrack, creating a new one from %s",
1366 fromStart ? "start()" : "obtainBuffer()");
Eric Laurent1703cdf2011-03-07 14:52:59 -08001367
Glenn Kastena47f3162012-11-07 10:13:08 -08001368 // signal old cblk condition so that other threads waiting for available buffers stop
1369 // waiting now
1370 cblk->cv.broadcast();
1371 cblk->lock.unlock();
Eric Laurent1703cdf2011-03-07 14:52:59 -08001372
Glenn Kastena47f3162012-11-07 10:13:08 -08001373 // refresh the audio configuration cache in this process to make sure we get new
1374 // output parameters in getOutput_l() and createTrack_l()
1375 AudioSystem::clearAudioConfigCache();
Eric Laurent9f6530f2011-08-30 10:18:54 -07001376
Glenn Kastena47f3162012-11-07 10:13:08 -08001377 // if the new IAudioTrack is created, createTrack_l() will modify the
1378 // following member variables: mAudioTrack, mCblkMemory and mCblk.
1379 // It will also delete the strong references on previous IAudioTrack and IMemory
1380 result = createTrack_l(mStreamType,
Glenn Kastene3aa6592012-12-04 12:22:46 -08001381 mSampleRate,
Glenn Kastena47f3162012-11-07 10:13:08 -08001382 mFormat,
Glenn Kastenb6037442012-11-14 13:42:25 -08001383 mReqFrameCount, // so that frame count never goes down
Glenn Kastena47f3162012-11-07 10:13:08 -08001384 mFlags,
1385 mSharedBuffer,
1386 getOutput_l());
Eric Laurent1703cdf2011-03-07 14:52:59 -08001387
Glenn Kastena47f3162012-11-07 10:13:08 -08001388 if (result == NO_ERROR) {
1389 uint32_t user = cblk->user;
1390 uint32_t server = cblk->server;
1391 // restore write index and set other indexes to reflect empty buffer status
1392 newCblk = mCblk;
1393 newCblk->user = user;
1394 newCblk->server = user;
1395 newCblk->userBase = user;
1396 newCblk->serverBase = user;
1397 // restore loop: this is not guaranteed to succeed if new frame count is not
1398 // compatible with loop length
1399 setLoop_l(cblk->loopStart, cblk->loopEnd, cblk->loopCount);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001400 size_t frames = 0;
Glenn Kastena47f3162012-11-07 10:13:08 -08001401 if (!fromStart) {
1402 newCblk->bufferTimeoutMs = MAX_RUN_TIMEOUT_MS;
1403 // Make sure that a client relying on callback events indicating underrun or
1404 // the actual amount of audio frames played (e.g SoundPool) receives them.
1405 if (mSharedBuffer == 0) {
Glenn Kastena47f3162012-11-07 10:13:08 -08001406 if (user > server) {
Glenn Kastenb6037442012-11-14 13:42:25 -08001407 frames = ((user - server) > mFrameCount) ?
1408 mFrameCount : (user - server);
Glenn Kasten83a03822012-11-12 07:58:20 -08001409 memset(mBuffers, 0, frames * mFrameSizeAF);
Eric Laurent408b8dc2011-09-06 12:36:15 -07001410 }
Glenn Kastena47f3162012-11-07 10:13:08 -08001411 // restart playback even if buffer is not completely filled.
1412 android_atomic_or(CBLK_FORCEREADY, &newCblk->flags);
Eric Laurent1703cdf2011-03-07 14:52:59 -08001413 }
1414 }
Glenn Kastena47f3162012-11-07 10:13:08 -08001415 if (mSharedBuffer != 0) {
Glenn Kastene3aa6592012-12-04 12:22:46 -08001416 frames = mFrameCount;
1417 }
1418 if (frames > 0) {
1419 // stepUser() clears CBLK_UNDERRUN flag enabling underrun callbacks to
1420 // the client
1421 mProxy->stepUser(frames);
Eric Laurent1703cdf2011-03-07 14:52:59 -08001422 }
Glenn Kastena47f3162012-11-07 10:13:08 -08001423 if (mActive) {
1424 result = mAudioTrack->start();
1425 ALOGW_IF(result != NO_ERROR, "restoreTrack_l() start() failed status %d", result);
1426 }
1427 if (fromStart && result == NO_ERROR) {
1428 mNewPosition = newCblk->server + mUpdatePeriod;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001429 }
Eric Laurent1703cdf2011-03-07 14:52:59 -08001430 }
Glenn Kastena47f3162012-11-07 10:13:08 -08001431 ALOGW_IF(result != NO_ERROR, "restoreTrack_l() failed status %d", result);
Steve Block3856b092011-10-20 11:56:00 +01001432 ALOGV("restoreTrack_l() status %d mActive %d cblk %p, old cblk %p flags %08x old flags %08x",
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001433 result, mActive, newCblk, cblk, newCblk->flags, cblk->flags);
Eric Laurent1703cdf2011-03-07 14:52:59 -08001434
1435 if (result == NO_ERROR) {
1436 // from now on we switch to the newly created cblk
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001437 refCblk = newCblk;
Eric Laurent1703cdf2011-03-07 14:52:59 -08001438 }
Glenn Kastend2c38fc2012-11-01 14:58:02 -07001439 newCblk->lock.lock();
Eric Laurent1703cdf2011-03-07 14:52:59 -08001440
Glenn Kasten827e5f12012-11-02 10:00:06 -07001441 ALOGW_IF(result != NO_ERROR, "restoreTrack_l() error %d", result);
Eric Laurent1703cdf2011-03-07 14:52:59 -08001442
1443 return result;
1444}
1445
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001446status_t AudioTrack::dump(int fd, const Vector<String16>& args) const
1447{
1448
1449 const size_t SIZE = 256;
1450 char buffer[SIZE];
1451 String8 result;
1452
1453 result.append(" AudioTrack::dump\n");
Glenn Kasten85ab62c2012-11-01 11:11:38 -07001454 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n", mStreamType,
1455 mVolume[0], mVolume[1]);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001456 result.append(buffer);
Glenn Kasten85ab62c2012-11-01 11:11:38 -07001457 snprintf(buffer, 255, " format(%d), channel count(%d), frame count(%d)\n", mFormat,
Glenn Kastenb6037442012-11-14 13:42:25 -08001458 mChannelCount, mFrameCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001459 result.append(buffer);
Glenn Kastene3aa6592012-12-04 12:22:46 -08001460 snprintf(buffer, 255, " sample rate(%u), status(%d)\n", mSampleRate, mStatus);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001461 result.append(buffer);
1462 snprintf(buffer, 255, " active(%d), latency (%d)\n", mActive, mLatency);
1463 result.append(buffer);
1464 ::write(fd, result.string(), result.size());
1465 return NO_ERROR;
1466}
1467
1468// =========================================================================
1469
1470AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver, bool bCanCallJava)
Glenn Kasten3acbd052012-02-28 10:39:56 -08001471 : Thread(bCanCallJava), mReceiver(receiver), mPaused(true)
1472{
1473}
1474
1475AudioTrack::AudioTrackThread::~AudioTrackThread()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001476{
1477}
1478
1479bool AudioTrack::AudioTrackThread::threadLoop()
1480{
Glenn Kasten3acbd052012-02-28 10:39:56 -08001481 {
1482 AutoMutex _l(mMyLock);
1483 if (mPaused) {
1484 mMyCond.wait(mMyLock);
1485 // caller will check for exitPending()
1486 return true;
1487 }
1488 }
Glenn Kastenca8b2802012-04-23 13:58:16 -07001489 if (!mReceiver.processAudioBuffer(this)) {
1490 pause();
1491 }
1492 return true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001493}
1494
Glenn Kasten3acbd052012-02-28 10:39:56 -08001495void AudioTrack::AudioTrackThread::requestExit()
1496{
1497 // must be in this order to avoid a race condition
1498 Thread::requestExit();
Glenn Kastenf4022f92012-05-02 10:34:59 -07001499 resume();
Glenn Kasten3acbd052012-02-28 10:39:56 -08001500}
1501
1502void AudioTrack::AudioTrackThread::pause()
1503{
1504 AutoMutex _l(mMyLock);
1505 mPaused = true;
1506}
1507
1508void AudioTrack::AudioTrackThread::resume()
1509{
1510 AutoMutex _l(mMyLock);
1511 if (mPaused) {
1512 mPaused = false;
1513 mMyCond.signal();
1514 }
1515}
1516
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001517}; // namespace android