• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
2  **
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  //#define LOG_NDEBUG 0
19  #define LOG_TAG "AudioTrack"
20  
21  #include <inttypes.h>
22  #include <math.h>
23  #include <sys/resource.h>
24  
25  #include <audio_utils/primitives.h>
26  #include <binder/IPCThreadState.h>
27  #include <media/AudioTrack.h>
28  #include <utils/Log.h>
29  #include <private/media/AudioTrackShared.h>
30  #include <media/IAudioFlinger.h>
31  #include <media/AudioPolicyHelper.h>
32  #include <media/AudioResamplerPublic.h>
33  
34  #define WAIT_PERIOD_MS                  10
35  #define WAIT_STREAM_END_TIMEOUT_SEC     120
36  static const int kMaxLoopCountNotifications = 32;
37  
38  namespace android {
39  // ---------------------------------------------------------------------------
40  
41  // TODO: Move to a separate .h
42  
43  template <typename T>
min(const T & x,const T & y)44  static inline const T &min(const T &x, const T &y) {
45      return x < y ? x : y;
46  }
47  
48  template <typename T>
max(const T & x,const T & y)49  static inline const T &max(const T &x, const T &y) {
50      return x > y ? x : y;
51  }
52  
framesToNanoseconds(ssize_t frames,uint32_t sampleRate,float speed)53  static inline nsecs_t framesToNanoseconds(ssize_t frames, uint32_t sampleRate, float speed)
54  {
55      return ((double)frames * 1000000000) / ((double)sampleRate * speed);
56  }
57  
convertTimespecToUs(const struct timespec & tv)58  static int64_t convertTimespecToUs(const struct timespec &tv)
59  {
60      return tv.tv_sec * 1000000ll + tv.tv_nsec / 1000;
61  }
62  
63  // current monotonic time in microseconds.
getNowUs()64  static int64_t getNowUs()
65  {
66      struct timespec tv;
67      (void) clock_gettime(CLOCK_MONOTONIC, &tv);
68      return convertTimespecToUs(tv);
69  }
70  
71  // FIXME: we don't use the pitch setting in the time stretcher (not working);
72  // instead we emulate it using our sample rate converter.
73  static const bool kFixPitch = true; // enable pitch fix
adjustSampleRate(uint32_t sampleRate,float pitch)74  static inline uint32_t adjustSampleRate(uint32_t sampleRate, float pitch)
75  {
76      return kFixPitch ? (sampleRate * pitch + 0.5) : sampleRate;
77  }
78  
adjustSpeed(float speed,float pitch)79  static inline float adjustSpeed(float speed, float pitch)
80  {
81      return kFixPitch ? speed / max(pitch, AUDIO_TIMESTRETCH_PITCH_MIN_DELTA) : speed;
82  }
83  
adjustPitch(float pitch)84  static inline float adjustPitch(float pitch)
85  {
86      return kFixPitch ? AUDIO_TIMESTRETCH_PITCH_NORMAL : pitch;
87  }
88  
89  // Must match similar computation in createTrack_l in Threads.cpp.
90  // TODO: Move to a common library
calculateMinFrameCount(uint32_t afLatencyMs,uint32_t afFrameCount,uint32_t afSampleRate,uint32_t sampleRate,float speed)91  static size_t calculateMinFrameCount(
92          uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate,
93          uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/)
94  {
95      // Ensure that buffer depth covers at least audio hardware latency
96      uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate);
97      if (minBufCount < 2) {
98          minBufCount = 2;
99      }
100  #if 0
101      // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
102      // but keeping the code here to make it easier to add later.
103      if (minBufCount < notificationsPerBufferReq) {
104          minBufCount = notificationsPerBufferReq;
105      }
106  #endif
107      ALOGV("calculateMinFrameCount afLatency %u  afFrameCount %u  afSampleRate %u  "
108              "sampleRate %u  speed %f  minBufCount: %u" /*"  notificationsPerBufferReq %u"*/,
109              afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
110              /*, notificationsPerBufferReq*/);
111      return minBufCount * sourceFramesNeededWithTimestretch(
112              sampleRate, afFrameCount, afSampleRate, speed);
113  }
114  
115  // static
getMinFrameCount(size_t * frameCount,audio_stream_type_t streamType,uint32_t sampleRate)116  status_t AudioTrack::getMinFrameCount(
117          size_t* frameCount,
118          audio_stream_type_t streamType,
119          uint32_t sampleRate)
120  {
121      if (frameCount == NULL) {
122          return BAD_VALUE;
123      }
124  
125      // FIXME handle in server, like createTrack_l(), possible missing info:
126      //          audio_io_handle_t output
127      //          audio_format_t format
128      //          audio_channel_mask_t channelMask
129      //          audio_output_flags_t flags (FAST)
130      uint32_t afSampleRate;
131      status_t status;
132      status = AudioSystem::getOutputSamplingRate(&afSampleRate, streamType);
133      if (status != NO_ERROR) {
134          ALOGE("Unable to query output sample rate for stream type %d; status %d",
135                  streamType, status);
136          return status;
137      }
138      size_t afFrameCount;
139      status = AudioSystem::getOutputFrameCount(&afFrameCount, streamType);
140      if (status != NO_ERROR) {
141          ALOGE("Unable to query output frame count for stream type %d; status %d",
142                  streamType, status);
143          return status;
144      }
145      uint32_t afLatency;
146      status = AudioSystem::getOutputLatency(&afLatency, streamType);
147      if (status != NO_ERROR) {
148          ALOGE("Unable to query output latency for stream type %d; status %d",
149                  streamType, status);
150          return status;
151      }
152  
153      // When called from createTrack, speed is 1.0f (normal speed).
154      // This is rechecked again on setting playback rate (TODO: on setting sample rate, too).
155      *frameCount = calculateMinFrameCount(afLatency, afFrameCount, afSampleRate, sampleRate, 1.0f
156              /*, 0 notificationsPerBufferReq*/);
157  
158      // The formula above should always produce a non-zero value under normal circumstances:
159      // AudioTrack.SAMPLE_RATE_HZ_MIN <= sampleRate <= AudioTrack.SAMPLE_RATE_HZ_MAX.
160      // Return error in the unlikely event that it does not, as that's part of the API contract.
161      if (*frameCount == 0) {
162          ALOGE("AudioTrack::getMinFrameCount failed for streamType %d, sampleRate %u",
163                  streamType, sampleRate);
164          return BAD_VALUE;
165      }
166      ALOGV("getMinFrameCount=%zu: afFrameCount=%zu, afSampleRate=%u, afLatency=%u",
167              *frameCount, afFrameCount, afSampleRate, afLatency);
168      return NO_ERROR;
169  }
170  
171  // ---------------------------------------------------------------------------
172  
AudioTrack()173  AudioTrack::AudioTrack()
174      : mStatus(NO_INIT),
175        mState(STATE_STOPPED),
176        mPreviousPriority(ANDROID_PRIORITY_NORMAL),
177        mPreviousSchedulingGroup(SP_DEFAULT),
178        mPausedPosition(0),
179        mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE)
180  {
181      mAttributes.content_type = AUDIO_CONTENT_TYPE_UNKNOWN;
182      mAttributes.usage = AUDIO_USAGE_UNKNOWN;
183      mAttributes.flags = 0x0;
184      strcpy(mAttributes.tags, "");
185  }
186  
AudioTrack(audio_stream_type_t streamType,uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t frameCount,audio_output_flags_t flags,callback_t cbf,void * user,int32_t notificationFrames,audio_session_t sessionId,transfer_type transferType,const audio_offload_info_t * offloadInfo,int uid,pid_t pid,const audio_attributes_t * pAttributes,bool doNotReconnect,float maxRequiredSpeed)187  AudioTrack::AudioTrack(
188          audio_stream_type_t streamType,
189          uint32_t sampleRate,
190          audio_format_t format,
191          audio_channel_mask_t channelMask,
192          size_t frameCount,
193          audio_output_flags_t flags,
194          callback_t cbf,
195          void* user,
196          int32_t notificationFrames,
197          audio_session_t sessionId,
198          transfer_type transferType,
199          const audio_offload_info_t *offloadInfo,
200          int uid,
201          pid_t pid,
202          const audio_attributes_t* pAttributes,
203          bool doNotReconnect,
204          float maxRequiredSpeed)
205      : mStatus(NO_INIT),
206        mState(STATE_STOPPED),
207        mPreviousPriority(ANDROID_PRIORITY_NORMAL),
208        mPreviousSchedulingGroup(SP_DEFAULT),
209        mPausedPosition(0),
210        mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE)
211  {
212      mStatus = set(streamType, sampleRate, format, channelMask,
213              frameCount, flags, cbf, user, notificationFrames,
214              0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId, transferType,
215              offloadInfo, uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed);
216  }
217  
AudioTrack(audio_stream_type_t streamType,uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,const sp<IMemory> & sharedBuffer,audio_output_flags_t flags,callback_t cbf,void * user,int32_t notificationFrames,audio_session_t sessionId,transfer_type transferType,const audio_offload_info_t * offloadInfo,int uid,pid_t pid,const audio_attributes_t * pAttributes,bool doNotReconnect,float maxRequiredSpeed)218  AudioTrack::AudioTrack(
219          audio_stream_type_t streamType,
220          uint32_t sampleRate,
221          audio_format_t format,
222          audio_channel_mask_t channelMask,
223          const sp<IMemory>& sharedBuffer,
224          audio_output_flags_t flags,
225          callback_t cbf,
226          void* user,
227          int32_t notificationFrames,
228          audio_session_t sessionId,
229          transfer_type transferType,
230          const audio_offload_info_t *offloadInfo,
231          int uid,
232          pid_t pid,
233          const audio_attributes_t* pAttributes,
234          bool doNotReconnect,
235          float maxRequiredSpeed)
236      : mStatus(NO_INIT),
237        mState(STATE_STOPPED),
238        mPreviousPriority(ANDROID_PRIORITY_NORMAL),
239        mPreviousSchedulingGroup(SP_DEFAULT),
240        mPausedPosition(0),
241        mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE)
242  {
243      mStatus = set(streamType, sampleRate, format, channelMask,
244              0 /*frameCount*/, flags, cbf, user, notificationFrames,
245              sharedBuffer, false /*threadCanCallJava*/, sessionId, transferType, offloadInfo,
246              uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed);
247  }
248  
~AudioTrack()249  AudioTrack::~AudioTrack()
250  {
251      if (mStatus == NO_ERROR) {
252          // Make sure that callback function exits in the case where
253          // it is looping on buffer full condition in obtainBuffer().
254          // Otherwise the callback thread will never exit.
255          stop();
256          if (mAudioTrackThread != 0) {
257              mProxy->interrupt();
258              mAudioTrackThread->requestExit();   // see comment in AudioTrack.h
259              mAudioTrackThread->requestExitAndWait();
260              mAudioTrackThread.clear();
261          }
262          // No lock here: worst case we remove a NULL callback which will be a nop
263          if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) {
264              AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
265          }
266          IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this);
267          mAudioTrack.clear();
268          mCblkMemory.clear();
269          mSharedBuffer.clear();
270          IPCThreadState::self()->flushCommands();
271          ALOGV("~AudioTrack, releasing session id %d from %d on behalf of %d",
272                  mSessionId, IPCThreadState::self()->getCallingPid(), mClientPid);
273          AudioSystem::releaseAudioSessionId(mSessionId, mClientPid);
274      }
275  }
276  
set(audio_stream_type_t streamType,uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t frameCount,audio_output_flags_t flags,callback_t cbf,void * user,int32_t notificationFrames,const sp<IMemory> & sharedBuffer,bool threadCanCallJava,audio_session_t sessionId,transfer_type transferType,const audio_offload_info_t * offloadInfo,int uid,pid_t pid,const audio_attributes_t * pAttributes,bool doNotReconnect,float maxRequiredSpeed)277  status_t AudioTrack::set(
278          audio_stream_type_t streamType,
279          uint32_t sampleRate,
280          audio_format_t format,
281          audio_channel_mask_t channelMask,
282          size_t frameCount,
283          audio_output_flags_t flags,
284          callback_t cbf,
285          void* user,
286          int32_t notificationFrames,
287          const sp<IMemory>& sharedBuffer,
288          bool threadCanCallJava,
289          audio_session_t sessionId,
290          transfer_type transferType,
291          const audio_offload_info_t *offloadInfo,
292          int uid,
293          pid_t pid,
294          const audio_attributes_t* pAttributes,
295          bool doNotReconnect,
296          float maxRequiredSpeed)
297  {
298      ALOGV("set(): streamType %d, sampleRate %u, format %#x, channelMask %#x, frameCount %zu, "
299            "flags #%x, notificationFrames %d, sessionId %d, transferType %d, uid %d, pid %d",
300            streamType, sampleRate, format, channelMask, frameCount, flags, notificationFrames,
301            sessionId, transferType, uid, pid);
302  
303      mThreadCanCallJava = threadCanCallJava;
304  
305      switch (transferType) {
306      case TRANSFER_DEFAULT:
307          if (sharedBuffer != 0) {
308              transferType = TRANSFER_SHARED;
309          } else if (cbf == NULL || threadCanCallJava) {
310              transferType = TRANSFER_SYNC;
311          } else {
312              transferType = TRANSFER_CALLBACK;
313          }
314          break;
315      case TRANSFER_CALLBACK:
316          if (cbf == NULL || sharedBuffer != 0) {
317              ALOGE("Transfer type TRANSFER_CALLBACK but cbf == NULL || sharedBuffer != 0");
318              return BAD_VALUE;
319          }
320          break;
321      case TRANSFER_OBTAIN:
322      case TRANSFER_SYNC:
323          if (sharedBuffer != 0) {
324              ALOGE("Transfer type TRANSFER_OBTAIN but sharedBuffer != 0");
325              return BAD_VALUE;
326          }
327          break;
328      case TRANSFER_SHARED:
329          if (sharedBuffer == 0) {
330              ALOGE("Transfer type TRANSFER_SHARED but sharedBuffer == 0");
331              return BAD_VALUE;
332          }
333          break;
334      default:
335          ALOGE("Invalid transfer type %d", transferType);
336          return BAD_VALUE;
337      }
338      mSharedBuffer = sharedBuffer;
339      mTransfer = transferType;
340      mDoNotReconnect = doNotReconnect;
341  
342      ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %zu", sharedBuffer->pointer(),
343              sharedBuffer->size());
344  
345      ALOGV("set() streamType %d frameCount %zu flags %04x", streamType, frameCount, flags);
346  
347      // invariant that mAudioTrack != 0 is true only after set() returns successfully
348      if (mAudioTrack != 0) {
349          ALOGE("Track already in use");
350          return INVALID_OPERATION;
351      }
352  
353      // handle default values first.
354      if (streamType == AUDIO_STREAM_DEFAULT) {
355          streamType = AUDIO_STREAM_MUSIC;
356      }
357      if (pAttributes == NULL) {
358          if (uint32_t(streamType) >= AUDIO_STREAM_PUBLIC_CNT) {
359              ALOGE("Invalid stream type %d", streamType);
360              return BAD_VALUE;
361          }
362          mStreamType = streamType;
363  
364      } else {
365          // stream type shouldn't be looked at, this track has audio attributes
366          memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));
367          ALOGV("Building AudioTrack with attributes: usage=%d content=%d flags=0x%x tags=[%s]",
368                  mAttributes.usage, mAttributes.content_type, mAttributes.flags, mAttributes.tags);
369          mStreamType = AUDIO_STREAM_DEFAULT;
370          if ((mAttributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
371              flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
372          }
373          if ((mAttributes.flags & AUDIO_FLAG_LOW_LATENCY) != 0) {
374              flags = (audio_output_flags_t) (flags | AUDIO_OUTPUT_FLAG_FAST);
375          }
376      }
377  
378      // these below should probably come from the audioFlinger too...
379      if (format == AUDIO_FORMAT_DEFAULT) {
380          format = AUDIO_FORMAT_PCM_16_BIT;
381      } else if (format == AUDIO_FORMAT_IEC61937) { // HDMI pass-through?
382          mAttributes.flags |= AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
383      }
384  
385      // validate parameters
386      if (!audio_is_valid_format(format)) {
387          ALOGE("Invalid format %#x", format);
388          return BAD_VALUE;
389      }
390      mFormat = format;
391  
392      if (!audio_is_output_channel(channelMask)) {
393          ALOGE("Invalid channel mask %#x", channelMask);
394          return BAD_VALUE;
395      }
396      mChannelMask = channelMask;
397      uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
398      mChannelCount = channelCount;
399  
400      // force direct flag if format is not linear PCM
401      // or offload was requested
402      if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
403              || !audio_is_linear_pcm(format)) {
404          ALOGV( (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
405                      ? "Offload request, forcing to Direct Output"
406                      : "Not linear PCM, forcing to Direct Output");
407          flags = (audio_output_flags_t)
408                  // FIXME why can't we allow direct AND fast?
409                  ((flags | AUDIO_OUTPUT_FLAG_DIRECT) & ~AUDIO_OUTPUT_FLAG_FAST);
410      }
411  
412      // force direct flag if HW A/V sync requested
413      if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
414          flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
415      }
416  
417      if (flags & AUDIO_OUTPUT_FLAG_DIRECT) {
418          if (audio_has_proportional_frames(format)) {
419              mFrameSize = channelCount * audio_bytes_per_sample(format);
420          } else {
421              mFrameSize = sizeof(uint8_t);
422          }
423      } else {
424          ALOG_ASSERT(audio_has_proportional_frames(format));
425          mFrameSize = channelCount * audio_bytes_per_sample(format);
426          // createTrack will return an error if PCM format is not supported by server,
427          // so no need to check for specific PCM formats here
428      }
429  
430      // sampling rate must be specified for direct outputs
431      if (sampleRate == 0 && (flags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
432          return BAD_VALUE;
433      }
434      mSampleRate = sampleRate;
435      mOriginalSampleRate = sampleRate;
436      mPlaybackRate = AUDIO_PLAYBACK_RATE_DEFAULT;
437      // 1.0 <= mMaxRequiredSpeed <= AUDIO_TIMESTRETCH_SPEED_MAX
438      mMaxRequiredSpeed = min(max(maxRequiredSpeed, 1.0f), AUDIO_TIMESTRETCH_SPEED_MAX);
439  
440      // Make copy of input parameter offloadInfo so that in the future:
441      //  (a) createTrack_l doesn't need it as an input parameter
442      //  (b) we can support re-creation of offloaded tracks
443      if (offloadInfo != NULL) {
444          mOffloadInfoCopy = *offloadInfo;
445          mOffloadInfo = &mOffloadInfoCopy;
446      } else {
447          mOffloadInfo = NULL;
448      }
449  
450      mVolume[AUDIO_INTERLEAVE_LEFT] = 1.0f;
451      mVolume[AUDIO_INTERLEAVE_RIGHT] = 1.0f;
452      mSendLevel = 0.0f;
453      // mFrameCount is initialized in createTrack_l
454      mReqFrameCount = frameCount;
455      if (notificationFrames >= 0) {
456          mNotificationFramesReq = notificationFrames;
457          mNotificationsPerBufferReq = 0;
458      } else {
459          if (!(flags & AUDIO_OUTPUT_FLAG_FAST)) {
460              ALOGE("notificationFrames=%d not permitted for non-fast track",
461                      notificationFrames);
462              return BAD_VALUE;
463          }
464          if (frameCount > 0) {
465              ALOGE("notificationFrames=%d not permitted with non-zero frameCount=%zu",
466                      notificationFrames, frameCount);
467              return BAD_VALUE;
468          }
469          mNotificationFramesReq = 0;
470          const uint32_t minNotificationsPerBuffer = 1;
471          const uint32_t maxNotificationsPerBuffer = 8;
472          mNotificationsPerBufferReq = min(maxNotificationsPerBuffer,
473                  max((uint32_t) -notificationFrames, minNotificationsPerBuffer));
474          ALOGW_IF(mNotificationsPerBufferReq != (uint32_t) -notificationFrames,
475                  "notificationFrames=%d clamped to the range -%u to -%u",
476                  notificationFrames, minNotificationsPerBuffer, maxNotificationsPerBuffer);
477      }
478      mNotificationFramesAct = 0;
479      if (sessionId == AUDIO_SESSION_ALLOCATE) {
480          mSessionId = (audio_session_t) AudioSystem::newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
481      } else {
482          mSessionId = sessionId;
483      }
484      int callingpid = IPCThreadState::self()->getCallingPid();
485      int mypid = getpid();
486      if (uid == -1 || (callingpid != mypid)) {
487          mClientUid = IPCThreadState::self()->getCallingUid();
488      } else {
489          mClientUid = uid;
490      }
491      if (pid == -1 || (callingpid != mypid)) {
492          mClientPid = callingpid;
493      } else {
494          mClientPid = pid;
495      }
496      mAuxEffectId = 0;
497      mOrigFlags = mFlags = flags;
498      mCbf = cbf;
499  
500      if (cbf != NULL) {
501          mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
502          mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/);
503          // thread begins in paused state, and will not reference us until start()
504      }
505  
506      // create the IAudioTrack
507      status_t status = createTrack_l();
508  
509      if (status != NO_ERROR) {
510          if (mAudioTrackThread != 0) {
511              mAudioTrackThread->requestExit();   // see comment in AudioTrack.h
512              mAudioTrackThread->requestExitAndWait();
513              mAudioTrackThread.clear();
514          }
515          return status;
516      }
517  
518      mStatus = NO_ERROR;
519      mUserData = user;
520      mLoopCount = 0;
521      mLoopStart = 0;
522      mLoopEnd = 0;
523      mLoopCountNotified = 0;
524      mMarkerPosition = 0;
525      mMarkerReached = false;
526      mNewPosition = 0;
527      mUpdatePeriod = 0;
528      mPosition = 0;
529      mReleased = 0;
530      mStartUs = 0;
531      AudioSystem::acquireAudioSessionId(mSessionId, mClientPid);
532      mSequence = 1;
533      mObservedSequence = mSequence;
534      mInUnderrun = false;
535      mPreviousTimestampValid = false;
536      mTimestampStartupGlitchReported = false;
537      mRetrogradeMotionReported = false;
538      mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;
539      mUnderrunCountOffset = 0;
540      mFramesWritten = 0;
541      mFramesWrittenServerOffset = 0;
542  
543      return NO_ERROR;
544  }
545  
546  // -------------------------------------------------------------------------
547  
start()548  status_t AudioTrack::start()
549  {
550      AutoMutex lock(mLock);
551  
552      if (mState == STATE_ACTIVE) {
553          return INVALID_OPERATION;
554      }
555  
556      mInUnderrun = true;
557  
558      State previousState = mState;
559      if (previousState == STATE_PAUSED_STOPPING) {
560          mState = STATE_STOPPING;
561      } else {
562          mState = STATE_ACTIVE;
563      }
564      (void) updateAndGetPosition_l();
565      if (previousState == STATE_STOPPED || previousState == STATE_FLUSHED) {
566          // reset current position as seen by client to 0
567          mPosition = 0;
568          mPreviousTimestampValid = false;
569          mTimestampStartupGlitchReported = false;
570          mRetrogradeMotionReported = false;
571          mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;
572  
573          // read last server side position change via timestamp.
574          ExtendedTimestamp ets;
575          if (mProxy->getTimestamp(&ets) == OK &&
576                  ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] > 0) {
577              // Server side has consumed something, but is it finished consuming?
578              // It is possible since flush and stop are asynchronous that the server
579              // is still active at this point.
580              ALOGV("start: server read:%lld  cumulative flushed:%lld  client written:%lld",
581                      (long long)(mFramesWrittenServerOffset
582                              + ets.mPosition[ExtendedTimestamp::LOCATION_SERVER]),
583                      (long long)ets.mFlushed,
584                      (long long)mFramesWritten);
585              mFramesWrittenServerOffset = -ets.mPosition[ExtendedTimestamp::LOCATION_SERVER];
586          }
587          mFramesWritten = 0;
588          mProxy->clearTimestamp(); // need new server push for valid timestamp
589          mMarkerReached = false;
590  
591          // For offloaded tracks, we don't know if the hardware counters are really zero here,
592          // since the flush is asynchronous and stop may not fully drain.
593          // We save the time when the track is started to later verify whether
594          // the counters are realistic (i.e. start from zero after this time).
595          mStartUs = getNowUs();
596  
597          // force refresh of remaining frames by processAudioBuffer() as last
598          // write before stop could be partial.
599          mRefreshRemaining = true;
600      }
601      mNewPosition = mPosition + mUpdatePeriod;
602      int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
603  
604      status_t status = NO_ERROR;
605      if (!(flags & CBLK_INVALID)) {
606          status = mAudioTrack->start();
607          if (status == DEAD_OBJECT) {
608              flags |= CBLK_INVALID;
609          }
610      }
611      if (flags & CBLK_INVALID) {
612          status = restoreTrack_l("start");
613      }
614  
615      // resume or pause the callback thread as needed.
616      sp<AudioTrackThread> t = mAudioTrackThread;
617      if (status == NO_ERROR) {
618          if (t != 0) {
619              if (previousState == STATE_STOPPING) {
620                  mProxy->interrupt();
621              } else {
622                  t->resume();
623              }
624          } else {
625              mPreviousPriority = getpriority(PRIO_PROCESS, 0);
626              get_sched_policy(0, &mPreviousSchedulingGroup);
627              androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
628          }
629      } else {
630          ALOGE("start() status %d", status);
631          mState = previousState;
632          if (t != 0) {
633              if (previousState != STATE_STOPPING) {
634                  t->pause();
635              }
636          } else {
637              setpriority(PRIO_PROCESS, 0, mPreviousPriority);
638              set_sched_policy(0, mPreviousSchedulingGroup);
639          }
640      }
641  
642      return status;
643  }
644  
stop()645  void AudioTrack::stop()
646  {
647      AutoMutex lock(mLock);
648      if (mState != STATE_ACTIVE && mState != STATE_PAUSED) {
649          return;
650      }
651  
652      if (isOffloaded_l()) {
653          mState = STATE_STOPPING;
654      } else {
655          mState = STATE_STOPPED;
656          mReleased = 0;
657      }
658  
659      mProxy->interrupt();
660      mAudioTrack->stop();
661  
662      // Note: legacy handling - stop does not clear playback marker
663      // and periodic update counter, but flush does for streaming tracks.
664  
665      if (mSharedBuffer != 0) {
666          // clear buffer position and loop count.
667          mStaticProxy->setBufferPositionAndLoop(0 /* position */,
668                  0 /* loopStart */, 0 /* loopEnd */, 0 /* loopCount */);
669      }
670  
671      sp<AudioTrackThread> t = mAudioTrackThread;
672      if (t != 0) {
673          if (!isOffloaded_l()) {
674              t->pause();
675          }
676      } else {
677          setpriority(PRIO_PROCESS, 0, mPreviousPriority);
678          set_sched_policy(0, mPreviousSchedulingGroup);
679      }
680  }
681  
stopped() const682  bool AudioTrack::stopped() const
683  {
684      AutoMutex lock(mLock);
685      return mState != STATE_ACTIVE;
686  }
687  
flush()688  void AudioTrack::flush()
689  {
690      if (mSharedBuffer != 0) {
691          return;
692      }
693      AutoMutex lock(mLock);
694      if (mState == STATE_ACTIVE || mState == STATE_FLUSHED) {
695          return;
696      }
697      flush_l();
698  }
699  
flush_l()700  void AudioTrack::flush_l()
701  {
702      ALOG_ASSERT(mState != STATE_ACTIVE);
703  
704      // clear playback marker and periodic update counter
705      mMarkerPosition = 0;
706      mMarkerReached = false;
707      mUpdatePeriod = 0;
708      mRefreshRemaining = true;
709  
710      mState = STATE_FLUSHED;
711      mReleased = 0;
712      if (isOffloaded_l()) {
713          mProxy->interrupt();
714      }
715      mProxy->flush();
716      mAudioTrack->flush();
717  }
718  
pause()719  void AudioTrack::pause()
720  {
721      AutoMutex lock(mLock);
722      if (mState == STATE_ACTIVE) {
723          mState = STATE_PAUSED;
724      } else if (mState == STATE_STOPPING) {
725          mState = STATE_PAUSED_STOPPING;
726      } else {
727          return;
728      }
729      mProxy->interrupt();
730      mAudioTrack->pause();
731  
732      if (isOffloaded_l()) {
733          if (mOutput != AUDIO_IO_HANDLE_NONE) {
734              // An offload output can be re-used between two audio tracks having
735              // the same configuration. A timestamp query for a paused track
736              // while the other is running would return an incorrect time.
737              // To fix this, cache the playback position on a pause() and return
738              // this time when requested until the track is resumed.
739  
740              // OffloadThread sends HAL pause in its threadLoop. Time saved
741              // here can be slightly off.
742  
743              // TODO: check return code for getRenderPosition.
744  
745              uint32_t halFrames;
746              AudioSystem::getRenderPosition(mOutput, &halFrames, &mPausedPosition);
747              ALOGV("AudioTrack::pause for offload, cache current position %u", mPausedPosition);
748          }
749      }
750  }
751  
setVolume(float left,float right)752  status_t AudioTrack::setVolume(float left, float right)
753  {
754      // This duplicates a test by AudioTrack JNI, but that is not the only caller
755      if (isnanf(left) || left < GAIN_FLOAT_ZERO || left > GAIN_FLOAT_UNITY ||
756              isnanf(right) || right < GAIN_FLOAT_ZERO || right > GAIN_FLOAT_UNITY) {
757          return BAD_VALUE;
758      }
759  
760      AutoMutex lock(mLock);
761      mVolume[AUDIO_INTERLEAVE_LEFT] = left;
762      mVolume[AUDIO_INTERLEAVE_RIGHT] = right;
763  
764      mProxy->setVolumeLR(gain_minifloat_pack(gain_from_float(left), gain_from_float(right)));
765  
766      if (isOffloaded_l()) {
767          mAudioTrack->signal();
768      }
769      return NO_ERROR;
770  }
771  
setVolume(float volume)772  status_t AudioTrack::setVolume(float volume)
773  {
774      return setVolume(volume, volume);
775  }
776  
setAuxEffectSendLevel(float level)777  status_t AudioTrack::setAuxEffectSendLevel(float level)
778  {
779      // This duplicates a test by AudioTrack JNI, but that is not the only caller
780      if (isnanf(level) || level < GAIN_FLOAT_ZERO || level > GAIN_FLOAT_UNITY) {
781          return BAD_VALUE;
782      }
783  
784      AutoMutex lock(mLock);
785      mSendLevel = level;
786      mProxy->setSendLevel(level);
787  
788      return NO_ERROR;
789  }
790  
getAuxEffectSendLevel(float * level) const791  void AudioTrack::getAuxEffectSendLevel(float* level) const
792  {
793      if (level != NULL) {
794          *level = mSendLevel;
795      }
796  }
797  
setSampleRate(uint32_t rate)798  status_t AudioTrack::setSampleRate(uint32_t rate)
799  {
800      AutoMutex lock(mLock);
801      if (rate == mSampleRate) {
802          return NO_ERROR;
803      }
804      if (isOffloadedOrDirect_l() || (mFlags & AUDIO_OUTPUT_FLAG_FAST)) {
805          return INVALID_OPERATION;
806      }
807      if (mOutput == AUDIO_IO_HANDLE_NONE) {
808          return NO_INIT;
809      }
810      // NOTE: it is theoretically possible, but highly unlikely, that a device change
811      // could mean a previously allowed sampling rate is no longer allowed.
812      uint32_t afSamplingRate;
813      if (AudioSystem::getSamplingRate(mOutput, &afSamplingRate) != NO_ERROR) {
814          return NO_INIT;
815      }
816      // pitch is emulated by adjusting speed and sampleRate
817      const uint32_t effectiveSampleRate = adjustSampleRate(rate, mPlaybackRate.mPitch);
818      if (rate == 0 || effectiveSampleRate > afSamplingRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
819          return BAD_VALUE;
820      }
821      // TODO: Should we also check if the buffer size is compatible?
822  
823      mSampleRate = rate;
824      mProxy->setSampleRate(effectiveSampleRate);
825  
826      return NO_ERROR;
827  }
828  
getSampleRate() const829  uint32_t AudioTrack::getSampleRate() const
830  {
831      AutoMutex lock(mLock);
832  
833      // sample rate can be updated during playback by the offloaded decoder so we need to
834      // query the HAL and update if needed.
835  // FIXME use Proxy return channel to update the rate from server and avoid polling here
836      if (isOffloadedOrDirect_l()) {
837          if (mOutput != AUDIO_IO_HANDLE_NONE) {
838              uint32_t sampleRate = 0;
839              status_t status = AudioSystem::getSamplingRate(mOutput, &sampleRate);
840              if (status == NO_ERROR) {
841                  mSampleRate = sampleRate;
842              }
843          }
844      }
845      return mSampleRate;
846  }
847  
getOriginalSampleRate() const848  uint32_t AudioTrack::getOriginalSampleRate() const
849  {
850      return mOriginalSampleRate;
851  }
852  
setPlaybackRate(const AudioPlaybackRate & playbackRate)853  status_t AudioTrack::setPlaybackRate(const AudioPlaybackRate &playbackRate)
854  {
855      AutoMutex lock(mLock);
856      if (isAudioPlaybackRateEqual(playbackRate, mPlaybackRate)) {
857          return NO_ERROR;
858      }
859      if (isOffloadedOrDirect_l()) {
860          return INVALID_OPERATION;
861      }
862      if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
863          return INVALID_OPERATION;
864      }
865  
866      ALOGV("setPlaybackRate (input): mSampleRate:%u  mSpeed:%f  mPitch:%f",
867              mSampleRate, playbackRate.mSpeed, playbackRate.mPitch);
868      // pitch is emulated by adjusting speed and sampleRate
869      const uint32_t effectiveRate = adjustSampleRate(mSampleRate, playbackRate.mPitch);
870      const float effectiveSpeed = adjustSpeed(playbackRate.mSpeed, playbackRate.mPitch);
871      const float effectivePitch = adjustPitch(playbackRate.mPitch);
872      AudioPlaybackRate playbackRateTemp = playbackRate;
873      playbackRateTemp.mSpeed = effectiveSpeed;
874      playbackRateTemp.mPitch = effectivePitch;
875  
876      ALOGV("setPlaybackRate (effective): mSampleRate:%u  mSpeed:%f  mPitch:%f",
877              effectiveRate, effectiveSpeed, effectivePitch);
878  
879      if (!isAudioPlaybackRateValid(playbackRateTemp)) {
880          ALOGV("setPlaybackRate(%f, %f) failed (effective rate out of bounds)",
881                  playbackRate.mSpeed, playbackRate.mPitch);
882          return BAD_VALUE;
883      }
884      // Check if the buffer size is compatible.
885      if (!isSampleRateSpeedAllowed_l(effectiveRate, effectiveSpeed)) {
886          ALOGV("setPlaybackRate(%f, %f) failed (buffer size)",
887                  playbackRate.mSpeed, playbackRate.mPitch);
888          return BAD_VALUE;
889      }
890  
891      // Check resampler ratios are within bounds
892      if ((uint64_t)effectiveRate > (uint64_t)mSampleRate * (uint64_t)AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
893          ALOGV("setPlaybackRate(%f, %f) failed. Resample rate exceeds max accepted value",
894                  playbackRate.mSpeed, playbackRate.mPitch);
895          return BAD_VALUE;
896      }
897  
898      if ((uint64_t)effectiveRate * (uint64_t)AUDIO_RESAMPLER_UP_RATIO_MAX < (uint64_t)mSampleRate) {
899          ALOGV("setPlaybackRate(%f, %f) failed. Resample rate below min accepted value",
900                          playbackRate.mSpeed, playbackRate.mPitch);
901          return BAD_VALUE;
902      }
903      mPlaybackRate = playbackRate;
904      //set effective rates
905      mProxy->setPlaybackRate(playbackRateTemp);
906      mProxy->setSampleRate(effectiveRate); // FIXME: not quite "atomic" with setPlaybackRate
907      return NO_ERROR;
908  }
909  
getPlaybackRate() const910  const AudioPlaybackRate& AudioTrack::getPlaybackRate() const
911  {
912      AutoMutex lock(mLock);
913      return mPlaybackRate;
914  }
915  
getBufferSizeInFrames()916  ssize_t AudioTrack::getBufferSizeInFrames()
917  {
918      AutoMutex lock(mLock);
919      if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
920          return NO_INIT;
921      }
922      return (ssize_t) mProxy->getBufferSizeInFrames();
923  }
924  
getBufferDurationInUs(int64_t * duration)925  status_t AudioTrack::getBufferDurationInUs(int64_t *duration)
926  {
927      if (duration == nullptr) {
928          return BAD_VALUE;
929      }
930      AutoMutex lock(mLock);
931      if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
932          return NO_INIT;
933      }
934      ssize_t bufferSizeInFrames = (ssize_t) mProxy->getBufferSizeInFrames();
935      if (bufferSizeInFrames < 0) {
936          return (status_t)bufferSizeInFrames;
937      }
938      *duration = (int64_t)((double)bufferSizeInFrames * 1000000
939              / ((double)mSampleRate * mPlaybackRate.mSpeed));
940      return NO_ERROR;
941  }
942  
setBufferSizeInFrames(size_t bufferSizeInFrames)943  ssize_t AudioTrack::setBufferSizeInFrames(size_t bufferSizeInFrames)
944  {
945      AutoMutex lock(mLock);
946      if (mOutput == AUDIO_IO_HANDLE_NONE || mProxy.get() == 0) {
947          return NO_INIT;
948      }
949      // Reject if timed track or compressed audio.
950      if (!audio_is_linear_pcm(mFormat)) {
951          return INVALID_OPERATION;
952      }
953      return (ssize_t) mProxy->setBufferSizeInFrames((uint32_t) bufferSizeInFrames);
954  }
955  
setLoop(uint32_t loopStart,uint32_t loopEnd,int loopCount)956  status_t AudioTrack::setLoop(uint32_t loopStart, uint32_t loopEnd, int loopCount)
957  {
958      if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
959          return INVALID_OPERATION;
960      }
961  
962      if (loopCount == 0) {
963          ;
964      } else if (loopCount >= -1 && loopStart < loopEnd && loopEnd <= mFrameCount &&
965              loopEnd - loopStart >= MIN_LOOP) {
966          ;
967      } else {
968          return BAD_VALUE;
969      }
970  
971      AutoMutex lock(mLock);
972      // See setPosition() regarding setting parameters such as loop points or position while active
973      if (mState == STATE_ACTIVE) {
974          return INVALID_OPERATION;
975      }
976      setLoop_l(loopStart, loopEnd, loopCount);
977      return NO_ERROR;
978  }
979  
setLoop_l(uint32_t loopStart,uint32_t loopEnd,int loopCount)980  void AudioTrack::setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount)
981  {
982      // We do not update the periodic notification point.
983      // mNewPosition = updateAndGetPosition_l() + mUpdatePeriod;
984      mLoopCount = loopCount;
985      mLoopEnd = loopEnd;
986      mLoopStart = loopStart;
987      mLoopCountNotified = loopCount;
988      mStaticProxy->setLoop(loopStart, loopEnd, loopCount);
989  
990      // Waking the AudioTrackThread is not needed as this cannot be called when active.
991  }
992  
setMarkerPosition(uint32_t marker)993  status_t AudioTrack::setMarkerPosition(uint32_t marker)
994  {
995      // The only purpose of setting marker position is to get a callback
996      if (mCbf == NULL || isOffloadedOrDirect()) {
997          return INVALID_OPERATION;
998      }
999  
1000      AutoMutex lock(mLock);
1001      mMarkerPosition = marker;
1002      mMarkerReached = false;
1003  
1004      sp<AudioTrackThread> t = mAudioTrackThread;
1005      if (t != 0) {
1006          t->wake();
1007      }
1008      return NO_ERROR;
1009  }
1010  
getMarkerPosition(uint32_t * marker) const1011  status_t AudioTrack::getMarkerPosition(uint32_t *marker) const
1012  {
1013      if (isOffloadedOrDirect()) {
1014          return INVALID_OPERATION;
1015      }
1016      if (marker == NULL) {
1017          return BAD_VALUE;
1018      }
1019  
1020      AutoMutex lock(mLock);
1021      mMarkerPosition.getValue(marker);
1022  
1023      return NO_ERROR;
1024  }
1025  
setPositionUpdatePeriod(uint32_t updatePeriod)1026  status_t AudioTrack::setPositionUpdatePeriod(uint32_t updatePeriod)
1027  {
1028      // The only purpose of setting position update period is to get a callback
1029      if (mCbf == NULL || isOffloadedOrDirect()) {
1030          return INVALID_OPERATION;
1031      }
1032  
1033      AutoMutex lock(mLock);
1034      mNewPosition = updateAndGetPosition_l() + updatePeriod;
1035      mUpdatePeriod = updatePeriod;
1036  
1037      sp<AudioTrackThread> t = mAudioTrackThread;
1038      if (t != 0) {
1039          t->wake();
1040      }
1041      return NO_ERROR;
1042  }
1043  
getPositionUpdatePeriod(uint32_t * updatePeriod) const1044  status_t AudioTrack::getPositionUpdatePeriod(uint32_t *updatePeriod) const
1045  {
1046      if (isOffloadedOrDirect()) {
1047          return INVALID_OPERATION;
1048      }
1049      if (updatePeriod == NULL) {
1050          return BAD_VALUE;
1051      }
1052  
1053      AutoMutex lock(mLock);
1054      *updatePeriod = mUpdatePeriod;
1055  
1056      return NO_ERROR;
1057  }
1058  
setPosition(uint32_t position)1059  status_t AudioTrack::setPosition(uint32_t position)
1060  {
1061      if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
1062          return INVALID_OPERATION;
1063      }
1064      if (position > mFrameCount) {
1065          return BAD_VALUE;
1066      }
1067  
1068      AutoMutex lock(mLock);
1069      // Currently we require that the player is inactive before setting parameters such as position
1070      // or loop points.  Otherwise, there could be a race condition: the application could read the
1071      // current position, compute a new position or loop parameters, and then set that position or
1072      // loop parameters but it would do the "wrong" thing since the position has continued to advance
1073      // in the mean time.  If we ever provide a sequencer in server, we could allow a way for the app
1074      // to specify how it wants to handle such scenarios.
1075      if (mState == STATE_ACTIVE) {
1076          return INVALID_OPERATION;
1077      }
1078      // After setting the position, use full update period before notification.
1079      mNewPosition = updateAndGetPosition_l() + mUpdatePeriod;
1080      mStaticProxy->setBufferPosition(position);
1081  
1082      // Waking the AudioTrackThread is not needed as this cannot be called when active.
1083      return NO_ERROR;
1084  }
1085  
getPosition(uint32_t * position)1086  status_t AudioTrack::getPosition(uint32_t *position)
1087  {
1088      if (position == NULL) {
1089          return BAD_VALUE;
1090      }
1091  
1092      AutoMutex lock(mLock);
1093      // FIXME: offloaded and direct tracks call into the HAL for render positions
1094      // for compressed/synced data; however, we use proxy position for pure linear pcm data
1095      // as we do not know the capability of the HAL for pcm position support and standby.
1096      // There may be some latency differences between the HAL position and the proxy position.
1097      if (isOffloadedOrDirect_l() && !isPurePcmData_l()) {
1098          uint32_t dspFrames = 0;
1099  
1100          if (isOffloaded_l() && ((mState == STATE_PAUSED) || (mState == STATE_PAUSED_STOPPING))) {
1101              ALOGV("getPosition called in paused state, return cached position %u", mPausedPosition);
1102              *position = mPausedPosition;
1103              return NO_ERROR;
1104          }
1105  
1106          if (mOutput != AUDIO_IO_HANDLE_NONE) {
1107              uint32_t halFrames; // actually unused
1108              (void) AudioSystem::getRenderPosition(mOutput, &halFrames, &dspFrames);
1109              // FIXME: on getRenderPosition() error, we return OK with frame position 0.
1110          }
1111          // FIXME: dspFrames may not be zero in (mState == STATE_STOPPED || mState == STATE_FLUSHED)
1112          // due to hardware latency. We leave this behavior for now.
1113          *position = dspFrames;
1114      } else {
1115          if (mCblk->mFlags & CBLK_INVALID) {
1116              (void) restoreTrack_l("getPosition");
1117              // FIXME: for compatibility with the Java API we ignore the restoreTrack_l()
1118              // error here (e.g. DEAD_OBJECT) and return OK with the last recorded server position.
1119          }
1120  
1121          // IAudioTrack::stop() isn't synchronous; we don't know when presentation completes
1122          *position = (mState == STATE_STOPPED || mState == STATE_FLUSHED) ?
1123                  0 : updateAndGetPosition_l().value();
1124      }
1125      return NO_ERROR;
1126  }
1127  
getBufferPosition(uint32_t * position)1128  status_t AudioTrack::getBufferPosition(uint32_t *position)
1129  {
1130      if (mSharedBuffer == 0) {
1131          return INVALID_OPERATION;
1132      }
1133      if (position == NULL) {
1134          return BAD_VALUE;
1135      }
1136  
1137      AutoMutex lock(mLock);
1138      *position = mStaticProxy->getBufferPosition();
1139      return NO_ERROR;
1140  }
1141  
reload()1142  status_t AudioTrack::reload()
1143  {
1144      if (mSharedBuffer == 0 || isOffloadedOrDirect()) {
1145          return INVALID_OPERATION;
1146      }
1147  
1148      AutoMutex lock(mLock);
1149      // See setPosition() regarding setting parameters such as loop points or position while active
1150      if (mState == STATE_ACTIVE) {
1151          return INVALID_OPERATION;
1152      }
1153      mNewPosition = mUpdatePeriod;
1154      (void) updateAndGetPosition_l();
1155      mPosition = 0;
1156      mPreviousTimestampValid = false;
1157  #if 0
1158      // The documentation is not clear on the behavior of reload() and the restoration
1159      // of loop count. Historically we have not restored loop count, start, end,
1160      // but it makes sense if one desires to repeat playing a particular sound.
1161      if (mLoopCount != 0) {
1162          mLoopCountNotified = mLoopCount;
1163          mStaticProxy->setLoop(mLoopStart, mLoopEnd, mLoopCount);
1164      }
1165  #endif
1166      mStaticProxy->setBufferPosition(0);
1167      return NO_ERROR;
1168  }
1169  
getOutput() const1170  audio_io_handle_t AudioTrack::getOutput() const
1171  {
1172      AutoMutex lock(mLock);
1173      return mOutput;
1174  }
1175  
setOutputDevice(audio_port_handle_t deviceId)1176  status_t AudioTrack::setOutputDevice(audio_port_handle_t deviceId) {
1177      AutoMutex lock(mLock);
1178      if (mSelectedDeviceId != deviceId) {
1179          mSelectedDeviceId = deviceId;
1180          android_atomic_or(CBLK_INVALID, &mCblk->mFlags);
1181      }
1182      return NO_ERROR;
1183  }
1184  
getOutputDevice()1185  audio_port_handle_t AudioTrack::getOutputDevice() {
1186      AutoMutex lock(mLock);
1187      return mSelectedDeviceId;
1188  }
1189  
getRoutedDeviceId()1190  audio_port_handle_t AudioTrack::getRoutedDeviceId() {
1191      AutoMutex lock(mLock);
1192      if (mOutput == AUDIO_IO_HANDLE_NONE) {
1193          return AUDIO_PORT_HANDLE_NONE;
1194      }
1195      return AudioSystem::getDeviceIdForIo(mOutput);
1196  }
1197  
attachAuxEffect(int effectId)1198  status_t AudioTrack::attachAuxEffect(int effectId)
1199  {
1200      AutoMutex lock(mLock);
1201      status_t status = mAudioTrack->attachAuxEffect(effectId);
1202      if (status == NO_ERROR) {
1203          mAuxEffectId = effectId;
1204      }
1205      return status;
1206  }
1207  
streamType() const1208  audio_stream_type_t AudioTrack::streamType() const
1209  {
1210      if (mStreamType == AUDIO_STREAM_DEFAULT) {
1211          return audio_attributes_to_stream_type(&mAttributes);
1212      }
1213      return mStreamType;
1214  }
1215  
1216  // -------------------------------------------------------------------------
1217  
1218  // must be called with mLock held
createTrack_l()1219  status_t AudioTrack::createTrack_l()
1220  {
1221      const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
1222      if (audioFlinger == 0) {
1223          ALOGE("Could not get audioflinger");
1224          return NO_INIT;
1225      }
1226  
1227      if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) {
1228          AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
1229      }
1230      audio_io_handle_t output;
1231      audio_stream_type_t streamType = mStreamType;
1232      audio_attributes_t *attr = (mStreamType == AUDIO_STREAM_DEFAULT) ? &mAttributes : NULL;
1233  
1234      // mFlags (not mOrigFlags) is modified depending on whether fast request is accepted.
1235      // After fast request is denied, we will request again if IAudioTrack is re-created.
1236  
1237      status_t status;
1238      status = AudioSystem::getOutputForAttr(attr, &output,
1239                                             mSessionId, &streamType, mClientUid,
1240                                             mSampleRate, mFormat, mChannelMask,
1241                                             mFlags, mSelectedDeviceId, mOffloadInfo);
1242  
1243      if (status != NO_ERROR || output == AUDIO_IO_HANDLE_NONE) {
1244          ALOGE("Could not get audio output for session %d, stream type %d, usage %d, sample rate %u, format %#x,"
1245                " channel mask %#x, flags %#x",
1246                mSessionId, streamType, mAttributes.usage, mSampleRate, mFormat, mChannelMask, mFlags);
1247          return BAD_VALUE;
1248      }
1249      {
1250      // Now that we have a reference to an I/O handle and have not yet handed it off to AudioFlinger,
1251      // we must release it ourselves if anything goes wrong.
1252  
1253      // Not all of these values are needed under all conditions, but it is easier to get them all
1254      status = AudioSystem::getLatency(output, &mAfLatency);
1255      if (status != NO_ERROR) {
1256          ALOGE("getLatency(%d) failed status %d", output, status);
1257          goto release;
1258      }
1259      ALOGV("createTrack_l() output %d afLatency %u", output, mAfLatency);
1260  
1261      status = AudioSystem::getFrameCount(output, &mAfFrameCount);
1262      if (status != NO_ERROR) {
1263          ALOGE("getFrameCount(output=%d) status %d", output, status);
1264          goto release;
1265      }
1266  
1267      // TODO consider making this a member variable if there are other uses for it later
1268      size_t afFrameCountHAL;
1269      status = AudioSystem::getFrameCountHAL(output, &afFrameCountHAL);
1270      if (status != NO_ERROR) {
1271          ALOGE("getFrameCountHAL(output=%d) status %d", output, status);
1272          goto release;
1273      }
1274      ALOG_ASSERT(afFrameCountHAL > 0);
1275  
1276      status = AudioSystem::getSamplingRate(output, &mAfSampleRate);
1277      if (status != NO_ERROR) {
1278          ALOGE("getSamplingRate(output=%d) status %d", output, status);
1279          goto release;
1280      }
1281      if (mSampleRate == 0) {
1282          mSampleRate = mAfSampleRate;
1283          mOriginalSampleRate = mAfSampleRate;
1284      }
1285  
1286      // Client can only express a preference for FAST.  Server will perform additional tests.
1287      if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
1288          bool useCaseAllowed =
1289              // either of these use cases:
1290              // use case 1: shared buffer
1291              (mSharedBuffer != 0) ||
1292              // use case 2: callback transfer mode
1293              (mTransfer == TRANSFER_CALLBACK) ||
1294              // use case 3: obtain/release mode
1295              (mTransfer == TRANSFER_OBTAIN) ||
1296              // use case 4: synchronous write
1297              ((mTransfer == TRANSFER_SYNC) && mThreadCanCallJava);
1298          // sample rates must also match
1299          bool fastAllowed = useCaseAllowed && (mSampleRate == mAfSampleRate);
1300          if (!fastAllowed) {
1301              ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by client; transfer %d, "
1302                  "track %u Hz, output %u Hz",
1303                  mTransfer, mSampleRate, mAfSampleRate);
1304              mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_FAST);
1305          }
1306      }
1307  
1308      mNotificationFramesAct = mNotificationFramesReq;
1309  
1310      size_t frameCount = mReqFrameCount;
1311      if (!audio_has_proportional_frames(mFormat)) {
1312  
1313          if (mSharedBuffer != 0) {
1314              // Same comment as below about ignoring frameCount parameter for set()
1315              frameCount = mSharedBuffer->size();
1316          } else if (frameCount == 0) {
1317              frameCount = mAfFrameCount;
1318          }
1319          if (mNotificationFramesAct != frameCount) {
1320              mNotificationFramesAct = frameCount;
1321          }
1322      } else if (mSharedBuffer != 0) {
1323          // FIXME: Ensure client side memory buffers need
1324          // not have additional alignment beyond sample
1325          // (e.g. 16 bit stereo accessed as 32 bit frame).
1326          size_t alignment = audio_bytes_per_sample(mFormat);
1327          if (alignment & 1) {
1328              // for AUDIO_FORMAT_PCM_24_BIT_PACKED (not exposed through Java).
1329              alignment = 1;
1330          }
1331          if (mChannelCount > 1) {
1332              // More than 2 channels does not require stronger alignment than stereo
1333              alignment <<= 1;
1334          }
1335          if (((uintptr_t)mSharedBuffer->pointer() & (alignment - 1)) != 0) {
1336              ALOGE("Invalid buffer alignment: address %p, channel count %u",
1337                      mSharedBuffer->pointer(), mChannelCount);
1338              status = BAD_VALUE;
1339              goto release;
1340          }
1341  
1342          // When initializing a shared buffer AudioTrack via constructors,
1343          // there's no frameCount parameter.
1344          // But when initializing a shared buffer AudioTrack via set(),
1345          // there _is_ a frameCount parameter.  We silently ignore it.
1346          frameCount = mSharedBuffer->size() / mFrameSize;
1347      } else {
1348          size_t minFrameCount = 0;
1349          // For fast tracks the frame count calculations and checks are mostly done by server,
1350          // but we try to respect the application's request for notifications per buffer.
1351          if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
1352              if (mNotificationsPerBufferReq > 0) {
1353                  // Avoid possible arithmetic overflow during multiplication.
1354                  // mNotificationsPerBuffer is clamped to a small integer earlier, so it is unlikely.
1355                  if (mNotificationsPerBufferReq > SIZE_MAX / afFrameCountHAL) {
1356                      ALOGE("Requested notificationPerBuffer=%u ignored for HAL frameCount=%zu",
1357                              mNotificationsPerBufferReq, afFrameCountHAL);
1358                  } else {
1359                      minFrameCount = afFrameCountHAL * mNotificationsPerBufferReq;
1360                  }
1361              }
1362          } else {
1363              // for normal tracks precompute the frame count based on speed.
1364              const float speed = !isPurePcmData_l() || isOffloadedOrDirect_l() ? 1.0f :
1365                              max(mMaxRequiredSpeed, mPlaybackRate.mSpeed);
1366              minFrameCount = calculateMinFrameCount(
1367                      mAfLatency, mAfFrameCount, mAfSampleRate, mSampleRate,
1368                      speed /*, 0 mNotificationsPerBufferReq*/);
1369          }
1370          if (frameCount < minFrameCount) {
1371              frameCount = minFrameCount;
1372          }
1373      }
1374  
1375      IAudioFlinger::track_flags_t trackFlags = IAudioFlinger::TRACK_DEFAULT;
1376  
1377      pid_t tid = -1;
1378      if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
1379          trackFlags |= IAudioFlinger::TRACK_FAST;
1380          if (mAudioTrackThread != 0 && !mThreadCanCallJava) {
1381              tid = mAudioTrackThread->getTid();
1382          }
1383      }
1384  
1385      if (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
1386          trackFlags |= IAudioFlinger::TRACK_OFFLOAD;
1387      }
1388  
1389      if (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
1390          trackFlags |= IAudioFlinger::TRACK_DIRECT;
1391      }
1392  
1393      size_t temp = frameCount;   // temp may be replaced by a revised value of frameCount,
1394                                  // but we will still need the original value also
1395      audio_session_t originalSessionId = mSessionId;
1396      sp<IAudioTrack> track = audioFlinger->createTrack(streamType,
1397                                                        mSampleRate,
1398                                                        mFormat,
1399                                                        mChannelMask,
1400                                                        &temp,
1401                                                        &trackFlags,
1402                                                        mSharedBuffer,
1403                                                        output,
1404                                                        mClientPid,
1405                                                        tid,
1406                                                        &mSessionId,
1407                                                        mClientUid,
1408                                                        &status);
1409      ALOGE_IF(originalSessionId != AUDIO_SESSION_ALLOCATE && mSessionId != originalSessionId,
1410              "session ID changed from %d to %d", originalSessionId, mSessionId);
1411  
1412      if (status != NO_ERROR) {
1413          ALOGE("AudioFlinger could not create track, status: %d", status);
1414          goto release;
1415      }
1416      ALOG_ASSERT(track != 0);
1417  
1418      // AudioFlinger now owns the reference to the I/O handle,
1419      // so we are no longer responsible for releasing it.
1420  
1421      // FIXME compare to AudioRecord
1422      sp<IMemory> iMem = track->getCblk();
1423      if (iMem == 0) {
1424          ALOGE("Could not get control block");
1425          return NO_INIT;
1426      }
1427      void *iMemPointer = iMem->pointer();
1428      if (iMemPointer == NULL) {
1429          ALOGE("Could not get control block pointer");
1430          return NO_INIT;
1431      }
1432      // invariant that mAudioTrack != 0 is true only after set() returns successfully
1433      if (mAudioTrack != 0) {
1434          IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this);
1435          mDeathNotifier.clear();
1436      }
1437      mAudioTrack = track;
1438      mCblkMemory = iMem;
1439      IPCThreadState::self()->flushCommands();
1440  
1441      audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMemPointer);
1442      mCblk = cblk;
1443      // note that temp is the (possibly revised) value of frameCount
1444      if (temp < frameCount || (frameCount == 0 && temp == 0)) {
1445          // In current design, AudioTrack client checks and ensures frame count validity before
1446          // passing it to AudioFlinger so AudioFlinger should not return a different value except
1447          // for fast track as it uses a special method of assigning frame count.
1448          ALOGW("Requested frameCount %zu but received frameCount %zu", frameCount, temp);
1449      }
1450      frameCount = temp;
1451  
1452      mAwaitBoost = false;
1453      if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
1454          if (trackFlags & IAudioFlinger::TRACK_FAST) {
1455              ALOGV("AUDIO_OUTPUT_FLAG_FAST successful; frameCount %zu", frameCount);
1456              if (!mThreadCanCallJava) {
1457                  mAwaitBoost = true;
1458              }
1459          } else {
1460              ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %zu", frameCount);
1461              mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_FAST);
1462          }
1463      }
1464  
1465      // Make sure that application is notified with sufficient margin before underrun.
1466      // The client can divide the AudioTrack buffer into sub-buffers,
1467      // and expresses its desire to server as the notification frame count.
1468      if (mSharedBuffer == 0 && audio_is_linear_pcm(mFormat)) {
1469          size_t maxNotificationFrames;
1470          if (trackFlags & IAudioFlinger::TRACK_FAST) {
1471              // notify every HAL buffer, regardless of the size of the track buffer
1472              maxNotificationFrames = afFrameCountHAL;
1473          } else {
1474              // For normal tracks, use at least double-buffering if no sample rate conversion,
1475              // or at least triple-buffering if there is sample rate conversion
1476              const int nBuffering = mOriginalSampleRate == mAfSampleRate ? 2 : 3;
1477              maxNotificationFrames = frameCount / nBuffering;
1478          }
1479          if (mNotificationFramesAct == 0 || mNotificationFramesAct > maxNotificationFrames) {
1480              if (mNotificationFramesAct == 0) {
1481                  ALOGD("Client defaulted notificationFrames to %zu for frameCount %zu",
1482                      maxNotificationFrames, frameCount);
1483              } else {
1484                  ALOGW("Client adjusted notificationFrames from %u to %zu for frameCount %zu",
1485                      mNotificationFramesAct, maxNotificationFrames, frameCount);
1486              }
1487              mNotificationFramesAct = (uint32_t) maxNotificationFrames;
1488          }
1489      }
1490  
1491      // We retain a copy of the I/O handle, but don't own the reference
1492      mOutput = output;
1493      mRefreshRemaining = true;
1494  
1495      // Starting address of buffers in shared memory.  If there is a shared buffer, buffers
1496      // is the value of pointer() for the shared buffer, otherwise buffers points
1497      // immediately after the control block.  This address is for the mapping within client
1498      // address space.  AudioFlinger::TrackBase::mBuffer is for the server address space.
1499      void* buffers;
1500      if (mSharedBuffer == 0) {
1501          buffers = cblk + 1;
1502      } else {
1503          buffers = mSharedBuffer->pointer();
1504          if (buffers == NULL) {
1505              ALOGE("Could not get buffer pointer");
1506              return NO_INIT;
1507          }
1508      }
1509  
1510      mAudioTrack->attachAuxEffect(mAuxEffectId);
1511      // FIXME doesn't take into account speed or future sample rate changes (until restoreTrack)
1512      // FIXME don't believe this lie
1513      mLatency = mAfLatency + (1000*frameCount) / mSampleRate;
1514  
1515      mFrameCount = frameCount;
1516      // If IAudioTrack is re-created, don't let the requested frameCount
1517      // decrease.  This can confuse clients that cache frameCount().
1518      if (frameCount > mReqFrameCount) {
1519          mReqFrameCount = frameCount;
1520      }
1521  
1522      // reset server position to 0 as we have new cblk.
1523      mServer = 0;
1524  
1525      // update proxy
1526      if (mSharedBuffer == 0) {
1527          mStaticProxy.clear();
1528          mProxy = new AudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize);
1529      } else {
1530          mStaticProxy = new StaticAudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize);
1531          mProxy = mStaticProxy;
1532      }
1533  
1534      mProxy->setVolumeLR(gain_minifloat_pack(
1535              gain_from_float(mVolume[AUDIO_INTERLEAVE_LEFT]),
1536              gain_from_float(mVolume[AUDIO_INTERLEAVE_RIGHT])));
1537  
1538      mProxy->setSendLevel(mSendLevel);
1539      const uint32_t effectiveSampleRate = adjustSampleRate(mSampleRate, mPlaybackRate.mPitch);
1540      const float effectiveSpeed = adjustSpeed(mPlaybackRate.mSpeed, mPlaybackRate.mPitch);
1541      const float effectivePitch = adjustPitch(mPlaybackRate.mPitch);
1542      mProxy->setSampleRate(effectiveSampleRate);
1543  
1544      AudioPlaybackRate playbackRateTemp = mPlaybackRate;
1545      playbackRateTemp.mSpeed = effectiveSpeed;
1546      playbackRateTemp.mPitch = effectivePitch;
1547      mProxy->setPlaybackRate(playbackRateTemp);
1548      mProxy->setMinimum(mNotificationFramesAct);
1549  
1550      mDeathNotifier = new DeathNotifier(this);
1551      IInterface::asBinder(mAudioTrack)->linkToDeath(mDeathNotifier, this);
1552  
1553      if (mDeviceCallback != 0) {
1554          AudioSystem::addAudioDeviceCallback(mDeviceCallback, mOutput);
1555      }
1556  
1557      return NO_ERROR;
1558      }
1559  
1560  release:
1561      AudioSystem::releaseOutput(output, streamType, mSessionId);
1562      if (status == NO_ERROR) {
1563          status = NO_INIT;
1564      }
1565      return status;
1566  }
1567  
obtainBuffer(Buffer * audioBuffer,int32_t waitCount,size_t * nonContig)1568  status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount, size_t *nonContig)
1569  {
1570      if (audioBuffer == NULL) {
1571          if (nonContig != NULL) {
1572              *nonContig = 0;
1573          }
1574          return BAD_VALUE;
1575      }
1576      if (mTransfer != TRANSFER_OBTAIN) {
1577          audioBuffer->frameCount = 0;
1578          audioBuffer->size = 0;
1579          audioBuffer->raw = NULL;
1580          if (nonContig != NULL) {
1581              *nonContig = 0;
1582          }
1583          return INVALID_OPERATION;
1584      }
1585  
1586      const struct timespec *requested;
1587      struct timespec timeout;
1588      if (waitCount == -1) {
1589          requested = &ClientProxy::kForever;
1590      } else if (waitCount == 0) {
1591          requested = &ClientProxy::kNonBlocking;
1592      } else if (waitCount > 0) {
1593          long long ms = WAIT_PERIOD_MS * (long long) waitCount;
1594          timeout.tv_sec = ms / 1000;
1595          timeout.tv_nsec = (int) (ms % 1000) * 1000000;
1596          requested = &timeout;
1597      } else {
1598          ALOGE("%s invalid waitCount %d", __func__, waitCount);
1599          requested = NULL;
1600      }
1601      return obtainBuffer(audioBuffer, requested, NULL /*elapsed*/, nonContig);
1602  }
1603  
obtainBuffer(Buffer * audioBuffer,const struct timespec * requested,struct timespec * elapsed,size_t * nonContig)1604  status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, const struct timespec *requested,
1605          struct timespec *elapsed, size_t *nonContig)
1606  {
1607      // previous and new IAudioTrack sequence numbers are used to detect track re-creation
1608      uint32_t oldSequence = 0;
1609      uint32_t newSequence;
1610  
1611      Proxy::Buffer buffer;
1612      status_t status = NO_ERROR;
1613  
1614      static const int32_t kMaxTries = 5;
1615      int32_t tryCounter = kMaxTries;
1616  
1617      do {
1618          // obtainBuffer() is called with mutex unlocked, so keep extra references to these fields to
1619          // keep them from going away if another thread re-creates the track during obtainBuffer()
1620          sp<AudioTrackClientProxy> proxy;
1621          sp<IMemory> iMem;
1622  
1623          {   // start of lock scope
1624              AutoMutex lock(mLock);
1625  
1626              newSequence = mSequence;
1627              // did previous obtainBuffer() fail due to media server death or voluntary invalidation?
1628              if (status == DEAD_OBJECT) {
1629                  // re-create track, unless someone else has already done so
1630                  if (newSequence == oldSequence) {
1631                      status = restoreTrack_l("obtainBuffer");
1632                      if (status != NO_ERROR) {
1633                          buffer.mFrameCount = 0;
1634                          buffer.mRaw = NULL;
1635                          buffer.mNonContig = 0;
1636                          break;
1637                      }
1638                  }
1639              }
1640              oldSequence = newSequence;
1641  
1642              if (status == NOT_ENOUGH_DATA) {
1643                  restartIfDisabled();
1644              }
1645  
1646              // Keep the extra references
1647              proxy = mProxy;
1648              iMem = mCblkMemory;
1649  
1650              if (mState == STATE_STOPPING) {
1651                  status = -EINTR;
1652                  buffer.mFrameCount = 0;
1653                  buffer.mRaw = NULL;
1654                  buffer.mNonContig = 0;
1655                  break;
1656              }
1657  
1658              // Non-blocking if track is stopped or paused
1659              if (mState != STATE_ACTIVE) {
1660                  requested = &ClientProxy::kNonBlocking;
1661              }
1662  
1663          }   // end of lock scope
1664  
1665          buffer.mFrameCount = audioBuffer->frameCount;
1666          // FIXME starts the requested timeout and elapsed over from scratch
1667          status = proxy->obtainBuffer(&buffer, requested, elapsed);
1668      } while (((status == DEAD_OBJECT) || (status == NOT_ENOUGH_DATA)) && (tryCounter-- > 0));
1669  
1670      audioBuffer->frameCount = buffer.mFrameCount;
1671      audioBuffer->size = buffer.mFrameCount * mFrameSize;
1672      audioBuffer->raw = buffer.mRaw;
1673      if (nonContig != NULL) {
1674          *nonContig = buffer.mNonContig;
1675      }
1676      return status;
1677  }
1678  
releaseBuffer(const Buffer * audioBuffer)1679  void AudioTrack::releaseBuffer(const Buffer* audioBuffer)
1680  {
1681      // FIXME add error checking on mode, by adding an internal version
1682      if (mTransfer == TRANSFER_SHARED) {
1683          return;
1684      }
1685  
1686      size_t stepCount = audioBuffer->size / mFrameSize;
1687      if (stepCount == 0) {
1688          return;
1689      }
1690  
1691      Proxy::Buffer buffer;
1692      buffer.mFrameCount = stepCount;
1693      buffer.mRaw = audioBuffer->raw;
1694  
1695      AutoMutex lock(mLock);
1696      mReleased += stepCount;
1697      mInUnderrun = false;
1698      mProxy->releaseBuffer(&buffer);
1699  
1700      // restart track if it was disabled by audioflinger due to previous underrun
1701      restartIfDisabled();
1702  }
1703  
restartIfDisabled()1704  void AudioTrack::restartIfDisabled()
1705  {
1706      int32_t flags = android_atomic_and(~CBLK_DISABLED, &mCblk->mFlags);
1707      if ((mState == STATE_ACTIVE) && (flags & CBLK_DISABLED)) {
1708          ALOGW("releaseBuffer() track %p disabled due to previous underrun, restarting", this);
1709          // FIXME ignoring status
1710          mAudioTrack->start();
1711      }
1712  }
1713  
1714  // -------------------------------------------------------------------------
1715  
write(const void * buffer,size_t userSize,bool blocking)1716  ssize_t AudioTrack::write(const void* buffer, size_t userSize, bool blocking)
1717  {
1718      if (mTransfer != TRANSFER_SYNC) {
1719          return INVALID_OPERATION;
1720      }
1721  
1722      if (isDirect()) {
1723          AutoMutex lock(mLock);
1724          int32_t flags = android_atomic_and(
1725                              ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END),
1726                              &mCblk->mFlags);
1727          if (flags & CBLK_INVALID) {
1728              return DEAD_OBJECT;
1729          }
1730      }
1731  
1732      if (ssize_t(userSize) < 0 || (buffer == NULL && userSize != 0)) {
1733          // Sanity-check: user is most-likely passing an error code, and it would
1734          // make the return value ambiguous (actualSize vs error).
1735          ALOGE("AudioTrack::write(buffer=%p, size=%zu (%zd)", buffer, userSize, userSize);
1736          return BAD_VALUE;
1737      }
1738  
1739      size_t written = 0;
1740      Buffer audioBuffer;
1741  
1742      while (userSize >= mFrameSize) {
1743          audioBuffer.frameCount = userSize / mFrameSize;
1744  
1745          status_t err = obtainBuffer(&audioBuffer,
1746                  blocking ? &ClientProxy::kForever : &ClientProxy::kNonBlocking);
1747          if (err < 0) {
1748              if (written > 0) {
1749                  break;
1750              }
1751              return ssize_t(err);
1752          }
1753  
1754          size_t toWrite = audioBuffer.size;
1755          memcpy(audioBuffer.i8, buffer, toWrite);
1756          buffer = ((const char *) buffer) + toWrite;
1757          userSize -= toWrite;
1758          written += toWrite;
1759  
1760          releaseBuffer(&audioBuffer);
1761      }
1762  
1763      if (written > 0) {
1764          mFramesWritten += written / mFrameSize;
1765      }
1766      return written;
1767  }
1768  
1769  // -------------------------------------------------------------------------
1770  
processAudioBuffer()1771  nsecs_t AudioTrack::processAudioBuffer()
1772  {
1773      // Currently the AudioTrack thread is not created if there are no callbacks.
1774      // Would it ever make sense to run the thread, even without callbacks?
1775      // If so, then replace this by checks at each use for mCbf != NULL.
1776      LOG_ALWAYS_FATAL_IF(mCblk == NULL);
1777  
1778      mLock.lock();
1779      if (mAwaitBoost) {
1780          mAwaitBoost = false;
1781          mLock.unlock();
1782          static const int32_t kMaxTries = 5;
1783          int32_t tryCounter = kMaxTries;
1784          uint32_t pollUs = 10000;
1785          do {
1786              int policy = sched_getscheduler(0);
1787              if (policy == SCHED_FIFO || policy == SCHED_RR) {
1788                  break;
1789              }
1790              usleep(pollUs);
1791              pollUs <<= 1;
1792          } while (tryCounter-- > 0);
1793          if (tryCounter < 0) {
1794              ALOGE("did not receive expected priority boost on time");
1795          }
1796          // Run again immediately
1797          return 0;
1798      }
1799  
1800      // Can only reference mCblk while locked
1801      int32_t flags = android_atomic_and(
1802          ~(CBLK_UNDERRUN | CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL | CBLK_BUFFER_END), &mCblk->mFlags);
1803  
1804      // Check for track invalidation
1805      if (flags & CBLK_INVALID) {
1806          // for offloaded tracks restoreTrack_l() will just update the sequence and clear
1807          // AudioSystem cache. We should not exit here but after calling the callback so
1808          // that the upper layers can recreate the track
1809          if (!isOffloadedOrDirect_l() || (mSequence == mObservedSequence)) {
1810              status_t status __unused = restoreTrack_l("processAudioBuffer");
1811              // FIXME unused status
1812              // after restoration, continue below to make sure that the loop and buffer events
1813              // are notified because they have been cleared from mCblk->mFlags above.
1814          }
1815      }
1816  
1817      bool waitStreamEnd = mState == STATE_STOPPING;
1818      bool active = mState == STATE_ACTIVE;
1819  
1820      // Manage underrun callback, must be done under lock to avoid race with releaseBuffer()
1821      bool newUnderrun = false;
1822      if (flags & CBLK_UNDERRUN) {
1823  #if 0
1824          // Currently in shared buffer mode, when the server reaches the end of buffer,
1825          // the track stays active in continuous underrun state.  It's up to the application
1826          // to pause or stop the track, or set the position to a new offset within buffer.
1827          // This was some experimental code to auto-pause on underrun.   Keeping it here
1828          // in "if 0" so we can re-visit this if we add a real sequencer for shared memory content.
1829          if (mTransfer == TRANSFER_SHARED) {
1830              mState = STATE_PAUSED;
1831              active = false;
1832          }
1833  #endif
1834          if (!mInUnderrun) {
1835              mInUnderrun = true;
1836              newUnderrun = true;
1837          }
1838      }
1839  
1840      // Get current position of server
1841      Modulo<uint32_t> position(updateAndGetPosition_l());
1842  
1843      // Manage marker callback
1844      bool markerReached = false;
1845      Modulo<uint32_t> markerPosition(mMarkerPosition);
1846      // uses 32 bit wraparound for comparison with position.
1847      if (!mMarkerReached && markerPosition.value() > 0 && position >= markerPosition) {
1848          mMarkerReached = markerReached = true;
1849      }
1850  
1851      // Determine number of new position callback(s) that will be needed, while locked
1852      size_t newPosCount = 0;
1853      Modulo<uint32_t> newPosition(mNewPosition);
1854      uint32_t updatePeriod = mUpdatePeriod;
1855      // FIXME fails for wraparound, need 64 bits
1856      if (updatePeriod > 0 && position >= newPosition) {
1857          newPosCount = ((position - newPosition).value() / updatePeriod) + 1;
1858          mNewPosition += updatePeriod * newPosCount;
1859      }
1860  
1861      // Cache other fields that will be needed soon
1862      uint32_t sampleRate = mSampleRate;
1863      float speed = mPlaybackRate.mSpeed;
1864      const uint32_t notificationFrames = mNotificationFramesAct;
1865      if (mRefreshRemaining) {
1866          mRefreshRemaining = false;
1867          mRemainingFrames = notificationFrames;
1868          mRetryOnPartialBuffer = false;
1869      }
1870      size_t misalignment = mProxy->getMisalignment();
1871      uint32_t sequence = mSequence;
1872      sp<AudioTrackClientProxy> proxy = mProxy;
1873  
1874      // Determine the number of new loop callback(s) that will be needed, while locked.
1875      int loopCountNotifications = 0;
1876      uint32_t loopPeriod = 0; // time in frames for next EVENT_LOOP_END or EVENT_BUFFER_END
1877  
1878      if (mLoopCount > 0) {
1879          int loopCount;
1880          size_t bufferPosition;
1881          mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount);
1882          loopPeriod = ((loopCount > 0) ? mLoopEnd : mFrameCount) - bufferPosition;
1883          loopCountNotifications = min(mLoopCountNotified - loopCount, kMaxLoopCountNotifications);
1884          mLoopCountNotified = loopCount; // discard any excess notifications
1885      } else if (mLoopCount < 0) {
1886          // FIXME: We're not accurate with notification count and position with infinite looping
1887          // since loopCount from server side will always return -1 (we could decrement it).
1888          size_t bufferPosition = mStaticProxy->getBufferPosition();
1889          loopCountNotifications = int((flags & (CBLK_LOOP_CYCLE | CBLK_LOOP_FINAL)) != 0);
1890          loopPeriod = mLoopEnd - bufferPosition;
1891      } else if (/* mLoopCount == 0 && */ mSharedBuffer != 0) {
1892          size_t bufferPosition = mStaticProxy->getBufferPosition();
1893          loopPeriod = mFrameCount - bufferPosition;
1894      }
1895  
1896      // These fields don't need to be cached, because they are assigned only by set():
1897      //     mTransfer, mCbf, mUserData, mFormat, mFrameSize, mFlags
1898      // mFlags is also assigned by createTrack_l(), but not the bit we care about.
1899  
1900      mLock.unlock();
1901  
1902      // get anchor time to account for callbacks.
1903      const nsecs_t timeBeforeCallbacks = systemTime();
1904  
1905      if (waitStreamEnd) {
1906          // FIXME:  Instead of blocking in proxy->waitStreamEndDone(), Callback thread
1907          // should wait on proxy futex and handle CBLK_STREAM_END_DONE within this function
1908          // (and make sure we don't callback for more data while we're stopping).
1909          // This helps with position, marker notifications, and track invalidation.
1910          struct timespec timeout;
1911          timeout.tv_sec = WAIT_STREAM_END_TIMEOUT_SEC;
1912          timeout.tv_nsec = 0;
1913  
1914          status_t status = proxy->waitStreamEndDone(&timeout);
1915          switch (status) {
1916          case NO_ERROR:
1917          case DEAD_OBJECT:
1918          case TIMED_OUT:
1919              if (status != DEAD_OBJECT) {
1920                  // for DEAD_OBJECT, we do not send a EVENT_STREAM_END after stop();
1921                  // instead, the application should handle the EVENT_NEW_IAUDIOTRACK.
1922                  mCbf(EVENT_STREAM_END, mUserData, NULL);
1923              }
1924              {
1925                  AutoMutex lock(mLock);
1926                  // The previously assigned value of waitStreamEnd is no longer valid,
1927                  // since the mutex has been unlocked and either the callback handler
1928                  // or another thread could have re-started the AudioTrack during that time.
1929                  waitStreamEnd = mState == STATE_STOPPING;
1930                  if (waitStreamEnd) {
1931                      mState = STATE_STOPPED;
1932                      mReleased = 0;
1933                  }
1934              }
1935              if (waitStreamEnd && status != DEAD_OBJECT) {
1936                 return NS_INACTIVE;
1937              }
1938              break;
1939          }
1940          return 0;
1941      }
1942  
1943      // perform callbacks while unlocked
1944      if (newUnderrun) {
1945          mCbf(EVENT_UNDERRUN, mUserData, NULL);
1946      }
1947      while (loopCountNotifications > 0) {
1948          mCbf(EVENT_LOOP_END, mUserData, NULL);
1949          --loopCountNotifications;
1950      }
1951      if (flags & CBLK_BUFFER_END) {
1952          mCbf(EVENT_BUFFER_END, mUserData, NULL);
1953      }
1954      if (markerReached) {
1955          mCbf(EVENT_MARKER, mUserData, &markerPosition);
1956      }
1957      while (newPosCount > 0) {
1958          size_t temp = newPosition.value(); // FIXME size_t != uint32_t
1959          mCbf(EVENT_NEW_POS, mUserData, &temp);
1960          newPosition += updatePeriod;
1961          newPosCount--;
1962      }
1963  
1964      if (mObservedSequence != sequence) {
1965          mObservedSequence = sequence;
1966          mCbf(EVENT_NEW_IAUDIOTRACK, mUserData, NULL);
1967          // for offloaded tracks, just wait for the upper layers to recreate the track
1968          if (isOffloadedOrDirect()) {
1969              return NS_INACTIVE;
1970          }
1971      }
1972  
1973      // if inactive, then don't run me again until re-started
1974      if (!active) {
1975          return NS_INACTIVE;
1976      }
1977  
1978      // Compute the estimated time until the next timed event (position, markers, loops)
1979      // FIXME only for non-compressed audio
1980      uint32_t minFrames = ~0;
1981      if (!markerReached && position < markerPosition) {
1982          minFrames = (markerPosition - position).value();
1983      }
1984      if (loopPeriod > 0 && loopPeriod < minFrames) {
1985          // loopPeriod is already adjusted for actual position.
1986          minFrames = loopPeriod;
1987      }
1988      if (updatePeriod > 0) {
1989          minFrames = min(minFrames, (newPosition - position).value());
1990      }
1991  
1992      // If > 0, poll periodically to recover from a stuck server.  A good value is 2.
1993      static const uint32_t kPoll = 0;
1994      if (kPoll > 0 && mTransfer == TRANSFER_CALLBACK && kPoll * notificationFrames < minFrames) {
1995          minFrames = kPoll * notificationFrames;
1996      }
1997  
1998      // This "fudge factor" avoids soaking CPU, and compensates for late progress by server
1999      static const nsecs_t kWaitPeriodNs = WAIT_PERIOD_MS * 1000000LL;
2000      const nsecs_t timeAfterCallbacks = systemTime();
2001  
2002      // Convert frame units to time units
2003      nsecs_t ns = NS_WHENEVER;
2004      if (minFrames != (uint32_t) ~0) {
2005          ns = framesToNanoseconds(minFrames, sampleRate, speed) + kWaitPeriodNs;
2006          ns -= (timeAfterCallbacks - timeBeforeCallbacks);  // account for callback time
2007          // TODO: Should we warn if the callback time is too long?
2008          if (ns < 0) ns = 0;
2009      }
2010  
2011      // If not supplying data by EVENT_MORE_DATA, then we're done
2012      if (mTransfer != TRANSFER_CALLBACK) {
2013          return ns;
2014      }
2015  
2016      // EVENT_MORE_DATA callback handling.
2017      // Timing for linear pcm audio data formats can be derived directly from the
2018      // buffer fill level.
2019      // Timing for compressed data is not directly available from the buffer fill level,
2020      // rather indirectly from waiting for blocking mode callbacks or waiting for obtain()
2021      // to return a certain fill level.
2022  
2023      struct timespec timeout;
2024      const struct timespec *requested = &ClientProxy::kForever;
2025      if (ns != NS_WHENEVER) {
2026          timeout.tv_sec = ns / 1000000000LL;
2027          timeout.tv_nsec = ns % 1000000000LL;
2028          ALOGV("timeout %ld.%03d", timeout.tv_sec, (int) timeout.tv_nsec / 1000000);
2029          requested = &timeout;
2030      }
2031  
2032      size_t writtenFrames = 0;
2033      while (mRemainingFrames > 0) {
2034  
2035          Buffer audioBuffer;
2036          audioBuffer.frameCount = mRemainingFrames;
2037          size_t nonContig;
2038          status_t err = obtainBuffer(&audioBuffer, requested, NULL, &nonContig);
2039          LOG_ALWAYS_FATAL_IF((err != NO_ERROR) != (audioBuffer.frameCount == 0),
2040                  "obtainBuffer() err=%d frameCount=%zu", err, audioBuffer.frameCount);
2041          requested = &ClientProxy::kNonBlocking;
2042          size_t avail = audioBuffer.frameCount + nonContig;
2043          ALOGV("obtainBuffer(%u) returned %zu = %zu + %zu err %d",
2044                  mRemainingFrames, avail, audioBuffer.frameCount, nonContig, err);
2045          if (err != NO_ERROR) {
2046              if (err == TIMED_OUT || err == WOULD_BLOCK || err == -EINTR ||
2047                      (isOffloaded() && (err == DEAD_OBJECT))) {
2048                  // FIXME bug 25195759
2049                  return 1000000;
2050              }
2051              ALOGE("Error %d obtaining an audio buffer, giving up.", err);
2052              return NS_NEVER;
2053          }
2054  
2055          if (mRetryOnPartialBuffer && audio_has_proportional_frames(mFormat)) {
2056              mRetryOnPartialBuffer = false;
2057              if (avail < mRemainingFrames) {
2058                  if (ns > 0) { // account for obtain time
2059                      const nsecs_t timeNow = systemTime();
2060                      ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks));
2061                  }
2062                  nsecs_t myns = framesToNanoseconds(mRemainingFrames - avail, sampleRate, speed);
2063                  if (ns < 0 /* NS_WHENEVER */ || myns < ns) {
2064                      ns = myns;
2065                  }
2066                  return ns;
2067              }
2068          }
2069  
2070          size_t reqSize = audioBuffer.size;
2071          mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);
2072          size_t writtenSize = audioBuffer.size;
2073  
2074          // Sanity check on returned size
2075          if (ssize_t(writtenSize) < 0 || writtenSize > reqSize) {
2076              ALOGE("EVENT_MORE_DATA requested %zu bytes but callback returned %zd bytes",
2077                      reqSize, ssize_t(writtenSize));
2078              return NS_NEVER;
2079          }
2080  
2081          if (writtenSize == 0) {
2082              // The callback is done filling buffers
2083              // Keep this thread going to handle timed events and
2084              // still try to get more data in intervals of WAIT_PERIOD_MS
2085              // but don't just loop and block the CPU, so wait
2086  
2087              // mCbf(EVENT_MORE_DATA, ...) might either
2088              // (1) Block until it can fill the buffer, returning 0 size on EOS.
2089              // (2) Block until it can fill the buffer, returning 0 data (silence) on EOS.
2090              // (3) Return 0 size when no data is available, does not wait for more data.
2091              //
2092              // (1) and (2) occurs with AudioPlayer/AwesomePlayer; (3) occurs with NuPlayer.
2093              // We try to compute the wait time to avoid a tight sleep-wait cycle,
2094              // especially for case (3).
2095              //
2096              // The decision to support (1) and (2) affect the sizing of mRemainingFrames
2097              // and this loop; whereas for case (3) we could simply check once with the full
2098              // buffer size and skip the loop entirely.
2099  
2100              nsecs_t myns;
2101              if (audio_has_proportional_frames(mFormat)) {
2102                  // time to wait based on buffer occupancy
2103                  const nsecs_t datans = mRemainingFrames <= avail ? 0 :
2104                          framesToNanoseconds(mRemainingFrames - avail, sampleRate, speed);
2105                  // audio flinger thread buffer size (TODO: adjust for fast tracks)
2106                  // FIXME: use mAfFrameCountHAL instead of mAfFrameCount below for fast tracks.
2107                  const nsecs_t afns = framesToNanoseconds(mAfFrameCount, mAfSampleRate, speed);
2108                  // add a half the AudioFlinger buffer time to avoid soaking CPU if datans is 0.
2109                  myns = datans + (afns / 2);
2110              } else {
2111                  // FIXME: This could ping quite a bit if the buffer isn't full.
2112                  // Note that when mState is stopping we waitStreamEnd, so it never gets here.
2113                  myns = kWaitPeriodNs;
2114              }
2115              if (ns > 0) { // account for obtain and callback time
2116                  const nsecs_t timeNow = systemTime();
2117                  ns = max((nsecs_t)0, ns - (timeNow - timeAfterCallbacks));
2118              }
2119              if (ns < 0 /* NS_WHENEVER */ || myns < ns) {
2120                  ns = myns;
2121              }
2122              return ns;
2123          }
2124  
2125          size_t releasedFrames = writtenSize / mFrameSize;
2126          audioBuffer.frameCount = releasedFrames;
2127          mRemainingFrames -= releasedFrames;
2128          if (misalignment >= releasedFrames) {
2129              misalignment -= releasedFrames;
2130          } else {
2131              misalignment = 0;
2132          }
2133  
2134          releaseBuffer(&audioBuffer);
2135          writtenFrames += releasedFrames;
2136  
2137          // FIXME here is where we would repeat EVENT_MORE_DATA again on same advanced buffer
2138          // if callback doesn't like to accept the full chunk
2139          if (writtenSize < reqSize) {
2140              continue;
2141          }
2142  
2143          // There could be enough non-contiguous frames available to satisfy the remaining request
2144          if (mRemainingFrames <= nonContig) {
2145              continue;
2146          }
2147  
2148  #if 0
2149          // This heuristic tries to collapse a series of EVENT_MORE_DATA that would total to a
2150          // sum <= notificationFrames.  It replaces that series by at most two EVENT_MORE_DATA
2151          // that total to a sum == notificationFrames.
2152          if (0 < misalignment && misalignment <= mRemainingFrames) {
2153              mRemainingFrames = misalignment;
2154              return ((double)mRemainingFrames * 1100000000) / ((double)sampleRate * speed);
2155          }
2156  #endif
2157  
2158      }
2159      if (writtenFrames > 0) {
2160          AutoMutex lock(mLock);
2161          mFramesWritten += writtenFrames;
2162      }
2163      mRemainingFrames = notificationFrames;
2164      mRetryOnPartialBuffer = true;
2165  
2166      // A lot has transpired since ns was calculated, so run again immediately and re-calculate
2167      return 0;
2168  }
2169  
restoreTrack_l(const char * from)2170  status_t AudioTrack::restoreTrack_l(const char *from)
2171  {
2172      ALOGW("dead IAudioTrack, %s, creating a new one from %s()",
2173            isOffloadedOrDirect_l() ? "Offloaded or Direct" : "PCM", from);
2174      ++mSequence;
2175  
2176      // refresh the audio configuration cache in this process to make sure we get new
2177      // output parameters and new IAudioFlinger in createTrack_l()
2178      AudioSystem::clearAudioConfigCache();
2179  
2180      if (isOffloadedOrDirect_l() || mDoNotReconnect) {
2181          // FIXME re-creation of offloaded and direct tracks is not yet implemented;
2182          // reconsider enabling for linear PCM encodings when position can be preserved.
2183          return DEAD_OBJECT;
2184      }
2185  
2186      // Save so we can return count since creation.
2187      mUnderrunCountOffset = getUnderrunCount_l();
2188  
2189      // save the old static buffer position
2190      size_t bufferPosition = 0;
2191      int loopCount = 0;
2192      if (mStaticProxy != 0) {
2193          mStaticProxy->getBufferPositionAndLoopCount(&bufferPosition, &loopCount);
2194      }
2195  
2196      mFlags = mOrigFlags;
2197  
2198      // If a new IAudioTrack is successfully created, createTrack_l() will modify the
2199      // following member variables: mAudioTrack, mCblkMemory and mCblk.
2200      // It will also delete the strong references on previous IAudioTrack and IMemory.
2201      // If a new IAudioTrack cannot be created, the previous (dead) instance will be left intact.
2202      status_t result = createTrack_l();
2203  
2204      if (result == NO_ERROR) {
2205          // take the frames that will be lost by track recreation into account in saved position
2206          // For streaming tracks, this is the amount we obtained from the user/client
2207          // (not the number actually consumed at the server - those are already lost).
2208          if (mStaticProxy == 0) {
2209              mPosition = mReleased;
2210          }
2211          // Continue playback from last known position and restore loop.
2212          if (mStaticProxy != 0) {
2213              if (loopCount != 0) {
2214                  mStaticProxy->setBufferPositionAndLoop(bufferPosition,
2215                          mLoopStart, mLoopEnd, loopCount);
2216              } else {
2217                  mStaticProxy->setBufferPosition(bufferPosition);
2218                  if (bufferPosition == mFrameCount) {
2219                      ALOGD("restoring track at end of static buffer");
2220                  }
2221              }
2222          }
2223          if (mState == STATE_ACTIVE) {
2224              result = mAudioTrack->start();
2225              mFramesWrittenServerOffset = mFramesWritten; // server resets to zero so we offset
2226          }
2227      }
2228      if (result != NO_ERROR) {
2229          ALOGW("restoreTrack_l() failed status %d", result);
2230          mState = STATE_STOPPED;
2231          mReleased = 0;
2232      }
2233  
2234      return result;
2235  }
2236  
updateAndGetPosition_l()2237  Modulo<uint32_t> AudioTrack::updateAndGetPosition_l()
2238  {
2239      // This is the sole place to read server consumed frames
2240      Modulo<uint32_t> newServer(mProxy->getPosition());
2241      const int32_t delta = (newServer - mServer).signedValue();
2242      // TODO There is controversy about whether there can be "negative jitter" in server position.
2243      //      This should be investigated further, and if possible, it should be addressed.
2244      //      A more definite failure mode is infrequent polling by client.
2245      //      One could call (void)getPosition_l() in releaseBuffer(),
2246      //      so mReleased and mPosition are always lock-step as best possible.
2247      //      That should ensure delta never goes negative for infrequent polling
2248      //      unless the server has more than 2^31 frames in its buffer,
2249      //      in which case the use of uint32_t for these counters has bigger issues.
2250      ALOGE_IF(delta < 0,
2251              "detected illegal retrograde motion by the server: mServer advanced by %d",
2252              delta);
2253      mServer = newServer;
2254      if (delta > 0) { // avoid retrograde
2255          mPosition += delta;
2256      }
2257      return mPosition;
2258  }
2259  
isSampleRateSpeedAllowed_l(uint32_t sampleRate,float speed) const2260  bool AudioTrack::isSampleRateSpeedAllowed_l(uint32_t sampleRate, float speed) const
2261  {
2262      // applicable for mixing tracks only (not offloaded or direct)
2263      if (mStaticProxy != 0) {
2264          return true; // static tracks do not have issues with buffer sizing.
2265      }
2266      const size_t minFrameCount =
2267              calculateMinFrameCount(mAfLatency, mAfFrameCount, mAfSampleRate, sampleRate, speed
2268                  /*, 0 mNotificationsPerBufferReq*/);
2269      ALOGV("isSampleRateSpeedAllowed_l mFrameCount %zu  minFrameCount %zu",
2270              mFrameCount, minFrameCount);
2271      return mFrameCount >= minFrameCount;
2272  }
2273  
setParameters(const String8 & keyValuePairs)2274  status_t AudioTrack::setParameters(const String8& keyValuePairs)
2275  {
2276      AutoMutex lock(mLock);
2277      return mAudioTrack->setParameters(keyValuePairs);
2278  }
2279  
getTimestamp(ExtendedTimestamp * timestamp)2280  status_t AudioTrack::getTimestamp(ExtendedTimestamp *timestamp)
2281  {
2282      if (timestamp == nullptr) {
2283          return BAD_VALUE;
2284      }
2285      AutoMutex lock(mLock);
2286      return getTimestamp_l(timestamp);
2287  }
2288  
getTimestamp_l(ExtendedTimestamp * timestamp)2289  status_t AudioTrack::getTimestamp_l(ExtendedTimestamp *timestamp)
2290  {
2291      if (mCblk->mFlags & CBLK_INVALID) {
2292          const status_t status = restoreTrack_l("getTimestampExtended");
2293          if (status != OK) {
2294              // per getTimestamp() API doc in header, we return DEAD_OBJECT here,
2295              // recommending that the track be recreated.
2296              return DEAD_OBJECT;
2297          }
2298      }
2299      // check for offloaded/direct here in case restoring somehow changed those flags.
2300      if (isOffloadedOrDirect_l()) {
2301          return INVALID_OPERATION; // not supported
2302      }
2303      status_t status = mProxy->getTimestamp(timestamp);
2304      LOG_ALWAYS_FATAL_IF(status != OK, "status %d not allowed from proxy getTimestamp", status);
2305      bool found = false;
2306      timestamp->mPosition[ExtendedTimestamp::LOCATION_CLIENT] = mFramesWritten;
2307      timestamp->mTimeNs[ExtendedTimestamp::LOCATION_CLIENT] = 0;
2308      // server side frame offset in case AudioTrack has been restored.
2309      for (int i = ExtendedTimestamp::LOCATION_SERVER;
2310              i < ExtendedTimestamp::LOCATION_MAX; ++i) {
2311          if (timestamp->mTimeNs[i] >= 0) {
2312              // apply server offset (frames flushed is ignored
2313              // so we don't report the jump when the flush occurs).
2314              timestamp->mPosition[i] += mFramesWrittenServerOffset;
2315              found = true;
2316          }
2317      }
2318      return found ? OK : WOULD_BLOCK;
2319  }
2320  
getTimestamp(AudioTimestamp & timestamp)2321  status_t AudioTrack::getTimestamp(AudioTimestamp& timestamp)
2322  {
2323      AutoMutex lock(mLock);
2324  
2325      bool previousTimestampValid = mPreviousTimestampValid;
2326      // Set false here to cover all the error return cases.
2327      mPreviousTimestampValid = false;
2328  
2329      switch (mState) {
2330      case STATE_ACTIVE:
2331      case STATE_PAUSED:
2332          break; // handle below
2333      case STATE_FLUSHED:
2334      case STATE_STOPPED:
2335          return WOULD_BLOCK;
2336      case STATE_STOPPING:
2337      case STATE_PAUSED_STOPPING:
2338          if (!isOffloaded_l()) {
2339              return INVALID_OPERATION;
2340          }
2341          break; // offloaded tracks handled below
2342      default:
2343          LOG_ALWAYS_FATAL("Invalid mState in getTimestamp(): %d", mState);
2344          break;
2345      }
2346  
2347      if (mCblk->mFlags & CBLK_INVALID) {
2348          const status_t status = restoreTrack_l("getTimestamp");
2349          if (status != OK) {
2350              // per getTimestamp() API doc in header, we return DEAD_OBJECT here,
2351              // recommending that the track be recreated.
2352              return DEAD_OBJECT;
2353          }
2354      }
2355  
2356      // The presented frame count must always lag behind the consumed frame count.
2357      // To avoid a race, read the presented frames first.  This ensures that presented <= consumed.
2358  
2359      status_t status;
2360      if (isOffloadedOrDirect_l()) {
2361          // use Binder to get timestamp
2362          status = mAudioTrack->getTimestamp(timestamp);
2363      } else {
2364          // read timestamp from shared memory
2365          ExtendedTimestamp ets;
2366          status = mProxy->getTimestamp(&ets);
2367          if (status == OK) {
2368              ExtendedTimestamp::Location location;
2369              status = ets.getBestTimestamp(&timestamp, &location);
2370  
2371              if (status == OK) {
2372                  // It is possible that the best location has moved from the kernel to the server.
2373                  // In this case we adjust the position from the previous computed latency.
2374                  if (location == ExtendedTimestamp::LOCATION_SERVER) {
2375                      ALOGW_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_KERNEL,
2376                              "getTimestamp() location moved from kernel to server");
2377                      // check that the last kernel OK time info exists and the positions
2378                      // are valid (if they predate the current track, the positions may
2379                      // be zero or negative).
2380                      const int64_t frames =
2381                              (ets.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] < 0 ||
2382                              ets.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] < 0 ||
2383                              ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] <= 0 ||
2384                              ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] <= 0)
2385                              ?
2386                              int64_t((double)mAfLatency * mSampleRate * mPlaybackRate.mSpeed
2387                                      / 1000)
2388                              :
2389                              (ets.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK]
2390                              - ets.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK]);
2391                      ALOGV("frame adjustment:%lld  timestamp:%s",
2392                              (long long)frames, ets.toString().c_str());
2393                      if (frames >= ets.mPosition[location]) {
2394                          timestamp.mPosition = 0;
2395                      } else {
2396                          timestamp.mPosition = (uint32_t)(ets.mPosition[location] - frames);
2397                      }
2398                  } else if (location == ExtendedTimestamp::LOCATION_KERNEL) {
2399                      ALOGV_IF(mPreviousLocation == ExtendedTimestamp::LOCATION_SERVER,
2400                              "getTimestamp() location moved from server to kernel");
2401                  }
2402                  mPreviousLocation = location;
2403              } else {
2404                  // right after AudioTrack is started, one may not find a timestamp
2405                  ALOGV("getBestTimestamp did not find timestamp");
2406              }
2407          }
2408          if (status == INVALID_OPERATION) {
2409              status = WOULD_BLOCK;
2410          }
2411      }
2412      if (status != NO_ERROR) {
2413          ALOGV_IF(status != WOULD_BLOCK, "getTimestamp error:%#x", status);
2414          return status;
2415      }
2416      if (isOffloadedOrDirect_l()) {
2417          if (isOffloaded_l() && (mState == STATE_PAUSED || mState == STATE_PAUSED_STOPPING)) {
2418              // use cached paused position in case another offloaded track is running.
2419              timestamp.mPosition = mPausedPosition;
2420              clock_gettime(CLOCK_MONOTONIC, &timestamp.mTime);
2421              return NO_ERROR;
2422          }
2423  
2424          // Check whether a pending flush or stop has completed, as those commands may
2425          // be asynchronous or return near finish or exhibit glitchy behavior.
2426          //
2427          // Originally this showed up as the first timestamp being a continuation of
2428          // the previous song under gapless playback.
2429          // However, we sometimes see zero timestamps, then a glitch of
2430          // the previous song's position, and then correct timestamps afterwards.
2431          if (mStartUs != 0 && mSampleRate != 0) {
2432              static const int kTimeJitterUs = 100000; // 100 ms
2433              static const int k1SecUs = 1000000;
2434  
2435              const int64_t timeNow = getNowUs();
2436  
2437              if (timeNow < mStartUs + k1SecUs) { // within first second of starting
2438                  const int64_t timestampTimeUs = convertTimespecToUs(timestamp.mTime);
2439                  if (timestampTimeUs < mStartUs) {
2440                      return WOULD_BLOCK;  // stale timestamp time, occurs before start.
2441                  }
2442                  const int64_t deltaTimeUs = timestampTimeUs - mStartUs;
2443                  const int64_t deltaPositionByUs = (double)timestamp.mPosition * 1000000
2444                          / ((double)mSampleRate * mPlaybackRate.mSpeed);
2445  
2446                  if (deltaPositionByUs > deltaTimeUs + kTimeJitterUs) {
2447                      // Verify that the counter can't count faster than the sample rate
2448                      // since the start time.  If greater, then that means we may have failed
2449                      // to completely flush or stop the previous playing track.
2450                      ALOGW_IF(!mTimestampStartupGlitchReported,
2451                              "getTimestamp startup glitch detected"
2452                              " deltaTimeUs(%lld) deltaPositionUs(%lld) tsmPosition(%u)",
2453                              (long long)deltaTimeUs, (long long)deltaPositionByUs,
2454                              timestamp.mPosition);
2455                      mTimestampStartupGlitchReported = true;
2456                      if (previousTimestampValid
2457                              && mPreviousTimestamp.mPosition == 0 /* should be true if valid */) {
2458                          timestamp = mPreviousTimestamp;
2459                          mPreviousTimestampValid = true;
2460                          return NO_ERROR;
2461                      }
2462                      return WOULD_BLOCK;
2463                  }
2464                  if (deltaPositionByUs != 0) {
2465                      mStartUs = 0; // don't check again, we got valid nonzero position.
2466                  }
2467              } else {
2468                  mStartUs = 0; // don't check again, start time expired.
2469              }
2470              mTimestampStartupGlitchReported = false;
2471          }
2472      } else {
2473          // Update the mapping between local consumed (mPosition) and server consumed (mServer)
2474          (void) updateAndGetPosition_l();
2475          // Server consumed (mServer) and presented both use the same server time base,
2476          // and server consumed is always >= presented.
2477          // The delta between these represents the number of frames in the buffer pipeline.
2478          // If this delta between these is greater than the client position, it means that
2479          // actually presented is still stuck at the starting line (figuratively speaking),
2480          // waiting for the first frame to go by.  So we can't report a valid timestamp yet.
2481          // Note: We explicitly use non-Modulo comparison here - potential wrap issue when
2482          // mPosition exceeds 32 bits.
2483          // TODO Remove when timestamp is updated to contain pipeline status info.
2484          const int32_t pipelineDepthInFrames = (mServer - timestamp.mPosition).signedValue();
2485          if (pipelineDepthInFrames > 0 /* should be true, but we check anyways */
2486                  && (uint32_t)pipelineDepthInFrames > mPosition.value()) {
2487              return INVALID_OPERATION;
2488          }
2489          // Convert timestamp position from server time base to client time base.
2490          // TODO The following code should work OK now because timestamp.mPosition is 32-bit.
2491          // But if we change it to 64-bit then this could fail.
2492          // Use Modulo computation here.
2493          timestamp.mPosition = (mPosition - mServer + timestamp.mPosition).value();
2494          // Immediately after a call to getPosition_l(), mPosition and
2495          // mServer both represent the same frame position.  mPosition is
2496          // in client's point of view, and mServer is in server's point of
2497          // view.  So the difference between them is the "fudge factor"
2498          // between client and server views due to stop() and/or new
2499          // IAudioTrack.  And timestamp.mPosition is initially in server's
2500          // point of view, so we need to apply the same fudge factor to it.
2501      }
2502  
2503      // Prevent retrograde motion in timestamp.
2504      // This is sometimes caused by erratic reports of the available space in the ALSA drivers.
2505      if (status == NO_ERROR) {
2506          if (previousTimestampValid) {
2507  #define TIME_TO_NANOS(time) ((int64_t)time.tv_sec * 1000000000 + time.tv_nsec)
2508              const int64_t previousTimeNanos = TIME_TO_NANOS(mPreviousTimestamp.mTime);
2509              const int64_t currentTimeNanos = TIME_TO_NANOS(timestamp.mTime);
2510  #undef TIME_TO_NANOS
2511              if (currentTimeNanos < previousTimeNanos) {
2512                  ALOGW("retrograde timestamp time");
2513                  // FIXME Consider blocking this from propagating upwards.
2514              }
2515  
2516              // Looking at signed delta will work even when the timestamps
2517              // are wrapping around.
2518              int32_t deltaPosition = (Modulo<uint32_t>(timestamp.mPosition)
2519                      - mPreviousTimestamp.mPosition).signedValue();
2520              // position can bobble slightly as an artifact; this hides the bobble
2521              static const int32_t MINIMUM_POSITION_DELTA = 8;
2522              if (deltaPosition < 0) {
2523                  // Only report once per position instead of spamming the log.
2524                  if (!mRetrogradeMotionReported) {
2525                      ALOGW("retrograde timestamp position corrected, %d = %u - %u",
2526                              deltaPosition,
2527                              timestamp.mPosition,
2528                              mPreviousTimestamp.mPosition);
2529                      mRetrogradeMotionReported = true;
2530                  }
2531              } else {
2532                  mRetrogradeMotionReported = false;
2533              }
2534              if (deltaPosition < MINIMUM_POSITION_DELTA) {
2535                  timestamp = mPreviousTimestamp;  // Use last valid timestamp.
2536              }
2537          }
2538          mPreviousTimestamp = timestamp;
2539          mPreviousTimestampValid = true;
2540      }
2541  
2542      return status;
2543  }
2544  
getParameters(const String8 & keys)2545  String8 AudioTrack::getParameters(const String8& keys)
2546  {
2547      audio_io_handle_t output = getOutput();
2548      if (output != AUDIO_IO_HANDLE_NONE) {
2549          return AudioSystem::getParameters(output, keys);
2550      } else {
2551          return String8::empty();
2552      }
2553  }
2554  
isOffloaded() const2555  bool AudioTrack::isOffloaded() const
2556  {
2557      AutoMutex lock(mLock);
2558      return isOffloaded_l();
2559  }
2560  
isDirect() const2561  bool AudioTrack::isDirect() const
2562  {
2563      AutoMutex lock(mLock);
2564      return isDirect_l();
2565  }
2566  
isOffloadedOrDirect() const2567  bool AudioTrack::isOffloadedOrDirect() const
2568  {
2569      AutoMutex lock(mLock);
2570      return isOffloadedOrDirect_l();
2571  }
2572  
2573  
dump(int fd,const Vector<String16> & args __unused) const2574  status_t AudioTrack::dump(int fd, const Vector<String16>& args __unused) const
2575  {
2576  
2577      const size_t SIZE = 256;
2578      char buffer[SIZE];
2579      String8 result;
2580  
2581      result.append(" AudioTrack::dump\n");
2582      snprintf(buffer, 255, "  stream type(%d), left - right volume(%f, %f)\n", mStreamType,
2583              mVolume[AUDIO_INTERLEAVE_LEFT], mVolume[AUDIO_INTERLEAVE_RIGHT]);
2584      result.append(buffer);
2585      snprintf(buffer, 255, "  format(%d), channel count(%d), frame count(%zu)\n", mFormat,
2586              mChannelCount, mFrameCount);
2587      result.append(buffer);
2588      snprintf(buffer, 255, "  sample rate(%u), speed(%f), status(%d)\n",
2589              mSampleRate, mPlaybackRate.mSpeed, mStatus);
2590      result.append(buffer);
2591      snprintf(buffer, 255, "  state(%d), latency (%d)\n", mState, mLatency);
2592      result.append(buffer);
2593      ::write(fd, result.string(), result.size());
2594      return NO_ERROR;
2595  }
2596  
getUnderrunCount() const2597  uint32_t AudioTrack::getUnderrunCount() const
2598  {
2599      AutoMutex lock(mLock);
2600      return getUnderrunCount_l();
2601  }
2602  
getUnderrunCount_l() const2603  uint32_t AudioTrack::getUnderrunCount_l() const
2604  {
2605      return mProxy->getUnderrunCount() + mUnderrunCountOffset;
2606  }
2607  
getUnderrunFrames() const2608  uint32_t AudioTrack::getUnderrunFrames() const
2609  {
2610      AutoMutex lock(mLock);
2611      return mProxy->getUnderrunFrames();
2612  }
2613  
addAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback> & callback)2614  status_t AudioTrack::addAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback)
2615  {
2616      if (callback == 0) {
2617          ALOGW("%s adding NULL callback!", __FUNCTION__);
2618          return BAD_VALUE;
2619      }
2620      AutoMutex lock(mLock);
2621      if (mDeviceCallback == callback) {
2622          ALOGW("%s adding same callback!", __FUNCTION__);
2623          return INVALID_OPERATION;
2624      }
2625      status_t status = NO_ERROR;
2626      if (mOutput != AUDIO_IO_HANDLE_NONE) {
2627          if (mDeviceCallback != 0) {
2628              ALOGW("%s callback already present!", __FUNCTION__);
2629              AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
2630          }
2631          status = AudioSystem::addAudioDeviceCallback(callback, mOutput);
2632      }
2633      mDeviceCallback = callback;
2634      return status;
2635  }
2636  
removeAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback> & callback)2637  status_t AudioTrack::removeAudioDeviceCallback(
2638          const sp<AudioSystem::AudioDeviceCallback>& callback)
2639  {
2640      if (callback == 0) {
2641          ALOGW("%s removing NULL callback!", __FUNCTION__);
2642          return BAD_VALUE;
2643      }
2644      AutoMutex lock(mLock);
2645      if (mDeviceCallback != callback) {
2646          ALOGW("%s removing different callback!", __FUNCTION__);
2647          return INVALID_OPERATION;
2648      }
2649      if (mOutput != AUDIO_IO_HANDLE_NONE) {
2650          AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
2651      }
2652      mDeviceCallback = 0;
2653      return NO_ERROR;
2654  }
2655  
pendingDuration(int32_t * msec,ExtendedTimestamp::Location location)2656  status_t AudioTrack::pendingDuration(int32_t *msec, ExtendedTimestamp::Location location)
2657  {
2658      if (msec == nullptr ||
2659              (location != ExtendedTimestamp::LOCATION_SERVER
2660                      && location != ExtendedTimestamp::LOCATION_KERNEL)) {
2661          return BAD_VALUE;
2662      }
2663      AutoMutex lock(mLock);
2664      // inclusive of offloaded and direct tracks.
2665      //
2666      // It is possible, but not enabled, to allow duration computation for non-pcm
2667      // audio_has_proportional_frames() formats because currently they have
2668      // the drain rate equivalent to the pcm sample rate * framesize.
2669      if (!isPurePcmData_l()) {
2670          return INVALID_OPERATION;
2671      }
2672      ExtendedTimestamp ets;
2673      if (getTimestamp_l(&ets) == OK
2674              && ets.mTimeNs[location] > 0) {
2675          int64_t diff = ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT]
2676                  - ets.mPosition[location];
2677          if (diff < 0) {
2678              *msec = 0;
2679          } else {
2680              // ms is the playback time by frames
2681              int64_t ms = (int64_t)((double)diff * 1000 /
2682                      ((double)mSampleRate * mPlaybackRate.mSpeed));
2683              // clockdiff is the timestamp age (negative)
2684              int64_t clockdiff = (mState != STATE_ACTIVE) ? 0 :
2685                      ets.mTimeNs[location]
2686                      + ets.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_MONOTONIC]
2687                      - systemTime(SYSTEM_TIME_MONOTONIC);
2688  
2689              //ALOGV("ms: %lld  clockdiff: %lld", (long long)ms, (long long)clockdiff);
2690              static const int NANOS_PER_MILLIS = 1000000;
2691              *msec = (int32_t)(ms + clockdiff / NANOS_PER_MILLIS);
2692          }
2693          return NO_ERROR;
2694      }
2695      if (location != ExtendedTimestamp::LOCATION_SERVER) {
2696          return INVALID_OPERATION; // LOCATION_KERNEL is not available
2697      }
2698      // use server position directly (offloaded and direct arrive here)
2699      updateAndGetPosition_l();
2700      int32_t diff = (Modulo<uint32_t>(mFramesWritten) - mPosition).signedValue();
2701      *msec = (diff <= 0) ? 0
2702              : (int32_t)((double)diff * 1000 / ((double)mSampleRate * mPlaybackRate.mSpeed));
2703      return NO_ERROR;
2704  }
2705  
2706  // =========================================================================
2707  
binderDied(const wp<IBinder> & who __unused)2708  void AudioTrack::DeathNotifier::binderDied(const wp<IBinder>& who __unused)
2709  {
2710      sp<AudioTrack> audioTrack = mAudioTrack.promote();
2711      if (audioTrack != 0) {
2712          AutoMutex lock(audioTrack->mLock);
2713          audioTrack->mProxy->binderDied();
2714      }
2715  }
2716  
2717  // =========================================================================
2718  
AudioTrackThread(AudioTrack & receiver,bool bCanCallJava)2719  AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver, bool bCanCallJava)
2720      : Thread(bCanCallJava), mReceiver(receiver), mPaused(true), mPausedInt(false), mPausedNs(0LL),
2721        mIgnoreNextPausedInt(false)
2722  {
2723  }
2724  
~AudioTrackThread()2725  AudioTrack::AudioTrackThread::~AudioTrackThread()
2726  {
2727  }
2728  
threadLoop()2729  bool AudioTrack::AudioTrackThread::threadLoop()
2730  {
2731      {
2732          AutoMutex _l(mMyLock);
2733          if (mPaused) {
2734              mMyCond.wait(mMyLock);
2735              // caller will check for exitPending()
2736              return true;
2737          }
2738          if (mIgnoreNextPausedInt) {
2739              mIgnoreNextPausedInt = false;
2740              mPausedInt = false;
2741          }
2742          if (mPausedInt) {
2743              if (mPausedNs > 0) {
2744                  (void) mMyCond.waitRelative(mMyLock, mPausedNs);
2745              } else {
2746                  mMyCond.wait(mMyLock);
2747              }
2748              mPausedInt = false;
2749              return true;
2750          }
2751      }
2752      if (exitPending()) {
2753          return false;
2754      }
2755      nsecs_t ns = mReceiver.processAudioBuffer();
2756      switch (ns) {
2757      case 0:
2758          return true;
2759      case NS_INACTIVE:
2760          pauseInternal();
2761          return true;
2762      case NS_NEVER:
2763          return false;
2764      case NS_WHENEVER:
2765          // Event driven: call wake() when callback notifications conditions change.
2766          ns = INT64_MAX;
2767          // fall through
2768      default:
2769          LOG_ALWAYS_FATAL_IF(ns < 0, "processAudioBuffer() returned %" PRId64, ns);
2770          pauseInternal(ns);
2771          return true;
2772      }
2773  }
2774  
requestExit()2775  void AudioTrack::AudioTrackThread::requestExit()
2776  {
2777      // must be in this order to avoid a race condition
2778      Thread::requestExit();
2779      resume();
2780  }
2781  
pause()2782  void AudioTrack::AudioTrackThread::pause()
2783  {
2784      AutoMutex _l(mMyLock);
2785      mPaused = true;
2786  }
2787  
resume()2788  void AudioTrack::AudioTrackThread::resume()
2789  {
2790      AutoMutex _l(mMyLock);
2791      mIgnoreNextPausedInt = true;
2792      if (mPaused || mPausedInt) {
2793          mPaused = false;
2794          mPausedInt = false;
2795          mMyCond.signal();
2796      }
2797  }
2798  
wake()2799  void AudioTrack::AudioTrackThread::wake()
2800  {
2801      AutoMutex _l(mMyLock);
2802      if (!mPaused) {
2803          // wake() might be called while servicing a callback - ignore the next
2804          // pause time and call processAudioBuffer.
2805          mIgnoreNextPausedInt = true;
2806          if (mPausedInt && mPausedNs > 0) {
2807              // audio track is active and internally paused with timeout.
2808              mPausedInt = false;
2809              mMyCond.signal();
2810          }
2811      }
2812  }
2813  
pauseInternal(nsecs_t ns)2814  void AudioTrack::AudioTrackThread::pauseInternal(nsecs_t ns)
2815  {
2816      AutoMutex _l(mMyLock);
2817      mPausedInt = true;
2818      mPausedNs = ns;
2819  }
2820  
2821  } // namespace android
2822