Tracks.cpp revision 6181ffd90a436f333c43a7f812391eee2c35005a
1326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams/* 2a04e30dbb5ab11592b03666bb3d102070759c58eAlex Sakhartchouk** 3326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** Copyright 2012, The Android Open Source Project 4326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** 5326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** Licensed under the Apache License, Version 2.0 (the "License"); 6326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** you may not use this file except in compliance with the License. 7326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** You may obtain a copy of the License at 8326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** 9326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** http://www.apache.org/licenses/LICENSE-2.0 10326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** 11326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** Unless required by applicable law or agreed to in writing, software 12326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** distributed under the License is distributed on an "AS IS" BASIS, 13326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** See the License for the specific language governing permissions and 15326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams** limitations under the License. 16326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams*/ 17326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 18326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 19326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#define LOG_TAG "AudioFlinger" 205ae678f2e68e25bd74cdc408df354c3b6fe481bfMathias Agopian//#define LOG_NDEBUG 0 21326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 22158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams#include "Configuration.h" 23158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams#include <math.h> 247bf29ddc35450d8064541c42c99a1f48be6cf0ddJason Sams#include <sys/syscall.h> 25158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams#include <utils/Log.h> 2676371fff76412fd020e24ddb8bf1ddb5c75f0ed1Joe Onorato 2776371fff76412fd020e24ddb8bf1ddb5c75f0ed1Joe Onorato#include <private/media/AudioTrackShared.h> 28158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams 298d957fa762eff6c03a93ddea9405d9575665f1ecJason Sams#include <common_time/cc_helper.h> 308d957fa762eff6c03a93ddea9405d9575665f1ecJason Sams#include <common_time/local_clock.h> 31158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams 32326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#include "AudioMixer.h" 33326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#include "AudioFlinger.h" 34326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#include "ServiceUtilities.h" 35fb03a22ad2adadc1ff50a8b50d43ad7fcc3fa6edJason Sams 36ca3f09c0924e9515901dfd47fa5f95385d53cf80Stephen Hines#include <media/nbaio/Pipe.h> 37326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#include <media/nbaio/PipeReader.h> 38afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk#include <audio_utils/minifloat.h> 396b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams 406b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams// ---------------------------------------------------------------------------- 414b3de47071d875faaa7d419d050a464b09538797Jason Sams 425c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams// Note: the following macro is used for extremely verbose logging message. In 4386d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to 445c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams// 0; but one side effect of this is to turn all LOGV's as well. Some messages 456b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams// are so verbose that we want to suppress them even when we have ALOG_ASSERT 466b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams// turned on. Do not uncomment the #def below unless you really know what you 476b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams// are doing and want to see all of the extremely verbose messages. 485c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams//#define VERY_VERY_VERBOSE_LOGGING 49326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#ifdef VERY_VERY_VERBOSE_LOGGING 50326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#define ALOGVV ALOGV 51afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk#else 524b3de47071d875faaa7d419d050a464b09538797Jason Sams#define ALOGVV(a...) do { } while(0) 5333b6e3b91329080e5cdd0b8fdbcd3e6a906032aeJason Sams#endif 5433b6e3b91329080e5cdd0b8fdbcd3e6a906032aeJason Sams 5560709257bbdeb0c50f39b9c8969dc76264d6e142Jason Samsnamespace android { 5660709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams 57c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams// ---------------------------------------------------------------------------- 58c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams// TrackBase 59c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams// ---------------------------------------------------------------------------- 60c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams 61c946b614ee6c983215cc3de7834a7a334f860d68Jason Samsstatic volatile int32_t nextTrackId = 55; 62c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams 63c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams// TrackBase constructor must be called with AudioFlinger::mLock held 6460709257bbdeb0c50f39b9c8969dc76264d6e142Jason SamsAudioFlinger::ThreadBase::TrackBase::TrackBase( 6560709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams ThreadBase *thread, 6660709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams const sp<Client>& client, 67c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams uint32_t sampleRate, 68c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams audio_format_t format, 69c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams audio_channel_mask_t channelMask, 70c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams size_t frameCount, 71c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams const sp<IMemory>& sharedBuffer, 72c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams int sessionId, 73c946b614ee6c983215cc3de7834a7a334f860d68Jason Sams int clientUid, 7460709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams IAudioFlinger::track_flags_t flags, 7560709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams bool isOut, 7633b6e3b91329080e5cdd0b8fdbcd3e6a906032aeJason Sams alloc_type alloc) 77afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk : RefBase(), 7860709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams mThread(thread), 791030893d9b99b72468034da13df025bda479bb97Jason Sams mClient(client), 80c61346b91434307c5003029017b54ce9c49112beJason Sams mCblk(NULL), 81c9d43db4d216b01b13aebfdb31d5615909591b33Jason Sams // mBuffer 821030893d9b99b72468034da13df025bda479bb97Jason Sams mState(IDLE), 831030893d9b99b72468034da13df025bda479bb97Jason Sams mSampleRate(sampleRate), 84afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk mFormat(format), 852dca84dd6c07992f78ad050177975f16486dd77eJason Sams mChannelMask(channelMask), 868c401effb0837155fc39ca0364f57a882d127d38Jason Sams mChannelCount(isOut ? 872382aba4a55c6ae74789c478eead8fbd96593321Jason Sams audio_channel_count_from_out_mask(channelMask) : 88c61346b91434307c5003029017b54ce9c49112beJason Sams audio_channel_count_from_in_mask(channelMask)), 892382aba4a55c6ae74789c478eead8fbd96593321Jason Sams mFrameSize(audio_is_linear_pcm(format) ? 908cfdd24fec22080b72266d33f61befc4a98b77c6Jason Sams mChannelCount * audio_bytes_per_sample(format) : sizeof(int8_t)), 9124371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams mFrameCount(frameCount), 9224371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams mSessionId(sessionId), 93cfb1d11ce6826fce7241d316d8b7dcab661f63a6Jason Sams mFlags(flags), 94afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk mIsOut(isOut), 95b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk mServerProxy(NULL), 9624371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams mId(android_atomic_inc(&nextTrackId)), 9724371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams mTerminated(false) 9824371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams{ 99b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // if the caller is us, trust the specified uid 100b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk if (IPCThreadState::self()->getCallingPid() != getpid_cached || clientUid == -1) { 101b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk int newclientUid = IPCThreadState::self()->getCallingUid(); 10224371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams if (clientUid != -1 && clientUid != newclientUid) { 103cfb1d11ce6826fce7241d316d8b7dcab661f63a6Jason Sams ALOGW("uid %d tried to pass itself off as %d", newclientUid, clientUid); 104afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 10524371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams clientUid = newclientUid; 10624371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams } 10724371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams // clientUid contains the uid of the app that is responsible for this track, so we can blame 10824371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams // battery usage on it. 109cfb1d11ce6826fce7241d316d8b7dcab661f63a6Jason Sams mUid = clientUid; 110afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk 11124371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams // client == 0 implies sharedBuffer == 0 1121d54f10f3c23e0d7ec57e52ec3b0701a2a5ed24eJason Sams ALOG_ASSERT(!(client == 0 && sharedBuffer != 0)); 1131d54f10f3c23e0d7ec57e52ec3b0701a2a5ed24eJason Sams 11424371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), 115c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk sharedBuffer->size()); 116c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk 117c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk // ALOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize); 11824371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams size_t size = sizeof(audio_track_cblk_t); 11924371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams size_t bufferSize = (sharedBuffer == 0 ? roundup(frameCount) : frameCount) * mFrameSize; 12024371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams if (sharedBuffer == 0 && alloc == ALLOC_CBLK) { 121afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk size += bufferSize; 1221d54f10f3c23e0d7ec57e52ec3b0701a2a5ed24eJason Sams } 1231d54f10f3c23e0d7ec57e52ec3b0701a2a5ed24eJason Sams 124c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk if (client != 0) { 125c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk mCblkMemory = client->heap()->allocate(size); 126c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk if (mCblkMemory == 0 || 127c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer())) == NULL) { 128afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk ALOGE("not enough memory for AudioTrack size=%u", size); 129c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk client->heap()->dump("AudioTrack"); 130c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk mCblkMemory.clear(); 131c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk return; 132c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk } 133c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk } else { 1341d54f10f3c23e0d7ec57e52ec3b0701a2a5ed24eJason Sams // this syntax avoids calling the audio_track_cblk_t constructor twice 1351d54f10f3c23e0d7ec57e52ec3b0701a2a5ed24eJason Sams mCblk = (audio_track_cblk_t *) new uint8_t[size]; 136afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk // assume mCblk != NULL 13724371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams } 13824371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams 13924371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams // construct the shared structure in-place. 14024371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams if (mCblk != NULL) { 14124371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams new(mCblk) audio_track_cblk_t(); 14224371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams switch (alloc) { 143afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk case ALLOC_READONLY: { 14424371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams const sp<MemoryDealer> roHeap(thread->readOnlyHeap()); 14524371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams if (roHeap == 0 || 14624371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams (mBufferMemory = roHeap->allocate(bufferSize)) == 0 || 14724371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams (mBuffer = mBufferMemory->pointer()) == NULL) { 1481d54f10f3c23e0d7ec57e52ec3b0701a2a5ed24eJason Sams ALOGE("not enough memory for read-only buffer size=%zu", bufferSize); 1492dca84dd6c07992f78ad050177975f16486dd77eJason Sams if (roHeap != 0) { 1502dca84dd6c07992f78ad050177975f16486dd77eJason Sams roHeap->dump("buffer"); 1512dca84dd6c07992f78ad050177975f16486dd77eJason Sams } 15224371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams mCblkMemory.clear(); 1532dca84dd6c07992f78ad050177975f16486dd77eJason Sams mBufferMemory.clear(); 1542dca84dd6c07992f78ad050177975f16486dd77eJason Sams return; 15564cd98e83d33011950b88f229d013e06c62b36e9Alex Sakhartchouk } 1562dca84dd6c07992f78ad050177975f16486dd77eJason Sams memset(mBuffer, 0, bufferSize); 1572dca84dd6c07992f78ad050177975f16486dd77eJason Sams } break; 1582dca84dd6c07992f78ad050177975f16486dd77eJason Sams case ALLOC_PIPE: 1592dca84dd6c07992f78ad050177975f16486dd77eJason Sams mBufferMemory = thread->pipeMemory(); 160c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk // mBuffer is the virtual address as seen from current process (mediaserver), 161c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk // and should normally be coming from mBufferMemory->pointer(). 1622dca84dd6c07992f78ad050177975f16486dd77eJason Sams // However in this case the TrackBase does not reference the buffer directly. 163326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // It should references the buffer via the pipe. 164326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // Therefore, to detect incorrect usage of the buffer, we set mBuffer to NULL. 165afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk mBuffer = NULL; 166900f1616bf33c7ba13cf2a737832a95bcd176388Jason Sams break; 167721acc495b859c6d884725a4f9b5523583dd11c7Jason Sams case ALLOC_CBLK: 168c19ff0177a7a0dadfc01b1990f822354fdc95991Alex Sakhartchouk // clear all buffers 169721acc495b859c6d884725a4f9b5523583dd11c7Jason Sams if (sharedBuffer == 0) { 170c19ff0177a7a0dadfc01b1990f822354fdc95991Alex Sakhartchouk mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); 171c19ff0177a7a0dadfc01b1990f822354fdc95991Alex Sakhartchouk memset(mBuffer, 0, bufferSize); 172a2cf755a28a1e7ffff2955df656d714f40e4d715Jason Sams } else { 173326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams mBuffer = sharedBuffer->pointer(); 174326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams#if 0 175889fe50e7aaebed8cb8284b16a0e51e64e8a3a9cAlex Sakhartchouk mCblk->mFlags = CBLK_FORCEREADY; // FIXME hack, need to fix the track ready logic 176721acc495b859c6d884725a4f9b5523583dd11c7Jason Sams#endif 177889fe50e7aaebed8cb8284b16a0e51e64e8a3a9cAlex Sakhartchouk } 178889fe50e7aaebed8cb8284b16a0e51e64e8a3a9cAlex Sakhartchouk break; 179afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 18076371fff76412fd020e24ddb8bf1ddb5c75f0ed1Joe Onorato 1811fddd90849deaae89b546ff492c345d485bbce42Jason Sams#ifdef TEE_SINK 18276371fff76412fd020e24ddb8bf1ddb5c75f0ed1Joe Onorato if (mTeeSinkTrackEnabled) { 18376371fff76412fd020e24ddb8bf1ddb5c75f0ed1Joe Onorato NBAIO_Format pipeFormat = Format_from_SR_C(mSampleRate, mChannelCount); 184326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams if (Format_isValid(pipeFormat)) { 185afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk Pipe *pipe = new Pipe(mTeeSinkTrackFrames, pipeFormat); 1860cae59f7d8dd63d1bf0ca4abedecb4cfa3ab1921Alex Sakhartchouk size_t numCounterOffers = 0; 187c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk const NBAIO_Format offers[1] = {pipeFormat}; 188ca5a454e022caec6c6d3cbb404cc09ea095ba97aAlex Sakhartchouk ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers); 189ca5a454e022caec6c6d3cbb404cc09ea095ba97aAlex Sakhartchouk ALOG_ASSERT(index == 0); 19009c67356bbeee0a97a20a06c95b66756838cb541Alex Sakhartchouk PipeReader *pipeReader = new PipeReader(*pipe); 1910cae59f7d8dd63d1bf0ca4abedecb4cfa3ab1921Alex Sakhartchouk numCounterOffers = 0; 1921809bde133e0d66f06cea65887d9ceb3c70f8b95Alex Sakhartchouk index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers); 1931809bde133e0d66f06cea65887d9ceb3c70f8b95Alex Sakhartchouk ALOG_ASSERT(index == 0); 19409c67356bbeee0a97a20a06c95b66756838cb541Alex Sakhartchouk mTeeSink = pipe; 195ca5a454e022caec6c6d3cbb404cc09ea095ba97aAlex Sakhartchouk mTeeSource = pipeReader; 196c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk } 1970cae59f7d8dd63d1bf0ca4abedecb4cfa3ab1921Alex Sakhartchouk } 19809c67356bbeee0a97a20a06c95b66756838cb541Alex Sakhartchouk#endif 199c8fb69e4a3e01501a3d38a6d3ea185e583d3f493Alex Sakhartchouk 2000cae59f7d8dd63d1bf0ca4abedecb4cfa3ab1921Alex Sakhartchouk } 2011809bde133e0d66f06cea65887d9ceb3c70f8b95Alex Sakhartchouk} 202ca5a454e022caec6c6d3cbb404cc09ea095ba97aAlex Sakhartchouk 2030cae59f7d8dd63d1bf0ca4abedecb4cfa3ab1921Alex SakhartchoukAudioFlinger::ThreadBase::TrackBase::~TrackBase() 2040cae59f7d8dd63d1bf0ca4abedecb4cfa3ab1921Alex Sakhartchouk{ 205afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk#ifdef TEE_SINK 20683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams dumpTee(-1, mTeeSource, mId); 207b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk#endif 20883c451a4ef4388e002482e383d488ca9b7b7600dJason Sams // delete the proxy before deleting the shared memory it refers to, to avoid dangling reference 20983c451a4ef4388e002482e383d488ca9b7b7600dJason Sams delete mServerProxy; 21083c451a4ef4388e002482e383d488ca9b7b7600dJason Sams if (mCblk != NULL) { 211b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk if (mClient == 0) { 21283c451a4ef4388e002482e383d488ca9b7b7600dJason Sams delete mCblk; 21383c451a4ef4388e002482e383d488ca9b7b7600dJason Sams } else { 21483c451a4ef4388e002482e383d488ca9b7b7600dJason Sams mCblk->~audio_track_cblk_t(); // destroy our shared-structure. 21583c451a4ef4388e002482e383d488ca9b7b7600dJason Sams } 21683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams } 21783c451a4ef4388e002482e383d488ca9b7b7600dJason Sams mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to 21883c451a4ef4388e002482e383d488ca9b7b7600dJason Sams if (mClient != 0) { 21983c451a4ef4388e002482e383d488ca9b7b7600dJason Sams // Client destructor must run with AudioFlinger client mutex locked 22083c451a4ef4388e002482e383d488ca9b7b7600dJason Sams Mutex::Autolock _l(mClient->audioFlinger()->mClientLock); 221d3e7107c60ce06d637d83fa0db783ecdd0ad534cJason Sams // If the client's reference count drops to zero, the associated destructor 22283c451a4ef4388e002482e383d488ca9b7b7600dJason Sams // must run with AudioFlinger lock held. Thus the explicit clear() rather than 22383c451a4ef4388e002482e383d488ca9b7b7600dJason Sams // relying on the automatic clear() at end of scope. 22483c451a4ef4388e002482e383d488ca9b7b7600dJason Sams mClient.clear(); 22583c451a4ef4388e002482e383d488ca9b7b7600dJason Sams } 22683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams} 22783c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 228d3e7107c60ce06d637d83fa0db783ecdd0ad534cJason Sams// AudioBufferProvider interface 229d3e7107c60ce06d637d83fa0db783ecdd0ad534cJason Sams// getNextBuffer() = 0; 230d3e7107c60ce06d637d83fa0db783ecdd0ad534cJason Sams// This implementation of releaseBuffer() is used by Track and RecordTrack, but not TimedTrack 231d3e7107c60ce06d637d83fa0db783ecdd0ad534cJason Samsvoid AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer) 232d3e7107c60ce06d637d83fa0db783ecdd0ad534cJason Sams{ 23383c451a4ef4388e002482e383d488ca9b7b7600dJason Sams#ifdef TEE_SINK 23483c451a4ef4388e002482e383d488ca9b7b7600dJason Sams if (mTeeSink != 0) { 23583c451a4ef4388e002482e383d488ca9b7b7600dJason Sams (void) mTeeSink->write(buffer->raw, buffer->frameCount); 23683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams } 23783c451a4ef4388e002482e383d488ca9b7b7600dJason Sams#endif 23883c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 23983c451a4ef4388e002482e383d488ca9b7b7600dJason Sams ServerProxy::Buffer buf; 24083c451a4ef4388e002482e383d488ca9b7b7600dJason Sams buf.mFrameCount = buffer->frameCount; 24183c451a4ef4388e002482e383d488ca9b7b7600dJason Sams buf.mRaw = buffer->raw; 24283c451a4ef4388e002482e383d488ca9b7b7600dJason Sams buffer->frameCount = 0; 243c700e649ca44d0dcff8b271e42d949ea72fe3c63Alex Sakhartchouk buffer->raw = NULL; 244da6d34a5a6ece8c30d20673b9b6ff07d8c91768bAlex Sakhartchouk mServerProxy->releaseBuffer(&buf); 24583c451a4ef4388e002482e383d488ca9b7b7600dJason Sams} 24683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 24783c451a4ef4388e002482e383d488ca9b7b7600dJason Samsstatus_t AudioFlinger::ThreadBase::TrackBase::setSyncEvent(const sp<SyncEvent>& event) 24883c451a4ef4388e002482e383d488ca9b7b7600dJason Sams{ 249e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams mSyncEvents.add(event); 250e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams return NO_ERROR; 251e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams} 25283c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 253e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams// ---------------------------------------------------------------------------- 254e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams// Playback 255dc314a172d48479053f258b485d7d0284b5b5b1fJason Sams// ---------------------------------------------------------------------------- 256dc314a172d48479053f258b485d7d0284b5b5b1fJason Sams 257dc314a172d48479053f258b485d7d0284b5b5b1fJason SamsAudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track) 258dc314a172d48479053f258b485d7d0284b5b5b1fJason Sams : BnAudioTrack(), 259dc314a172d48479053f258b485d7d0284b5b5b1fJason Sams mTrack(track) 260e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams{ 261e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams} 262e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams 26383c451a4ef4388e002482e383d488ca9b7b7600dJason SamsAudioFlinger::TrackHandle::~TrackHandle() { 2647257c7ee4b66f00c43d9235f3ac600061ae79968Alex Sakhartchouk // just stop the track on deletion, associated resources 26583c451a4ef4388e002482e383d488ca9b7b7600dJason Sams // will be freed from the main thread once all pending buffers have 26683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams // been played. Unless it's not in the active track list, in which 267e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams // case we free everything now... 268e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Sams mTrack->destroy(); 269dc314a172d48479053f258b485d7d0284b5b5b1fJason Sams} 27083c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 27183c451a4ef4388e002482e383d488ca9b7b7600dJason Samssp<IMemory> AudioFlinger::TrackHandle::getCblk() const { 27283c451a4ef4388e002482e383d488ca9b7b7600dJason Sams return mTrack->getCblk(); 27383c451a4ef4388e002482e383d488ca9b7b7600dJason Sams} 27483c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 275e0aab4a8ff1cffd8cfaedc2623db94072549e0e5Jason Samsstatus_t AudioFlinger::TrackHandle::start() { 27683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams return mTrack->start(); 27783c451a4ef4388e002482e383d488ca9b7b7600dJason Sams} 27883c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 27983c451a4ef4388e002482e383d488ca9b7b7600dJason Samsvoid AudioFlinger::TrackHandle::stop() { 28083c451a4ef4388e002482e383d488ca9b7b7600dJason Sams mTrack->stop(); 28183c451a4ef4388e002482e383d488ca9b7b7600dJason Sams} 28283c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 28383c451a4ef4388e002482e383d488ca9b7b7600dJason Samsvoid AudioFlinger::TrackHandle::flush() { 28483c451a4ef4388e002482e383d488ca9b7b7600dJason Sams mTrack->flush(); 28586d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams} 28683c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 28783c451a4ef4388e002482e383d488ca9b7b7600dJason Samsvoid AudioFlinger::TrackHandle::pause() { 28883c451a4ef4388e002482e383d488ca9b7b7600dJason Sams mTrack->pause(); 28983c451a4ef4388e002482e383d488ca9b7b7600dJason Sams} 29083c451a4ef4388e002482e383d488ca9b7b7600dJason Sams 29183c451a4ef4388e002482e383d488ca9b7b7600dJason Samsstatus_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId) 29283c451a4ef4388e002482e383d488ca9b7b7600dJason Sams{ 29386d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams return mTrack->attachAuxEffect(EffectId); 29483c451a4ef4388e002482e383d488ca9b7b7600dJason Sams} 295326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 296326e0ddf89e8df2837752fbfd7a014814b32082cJason Samsstatus_t AudioFlinger::TrackHandle::allocateTimedBuffer(size_t size, 297741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams sp<IMemory>* buffer) { 298249d453869cca82dcb57123f6d1c8df3ca9f4372Jason Sams if (!mTrack->isTimedTrack()) 2992e8665de7c0eb4514c67baf8693d61c892e5303dJason Sams return INVALID_OPERATION; 300741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams 301741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams PlaybackThread::TimedTrack* tt = 302741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get()); 303741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams return tt->allocateTimedBuffer(size, buffer); 304741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams} 305741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams 306741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Samsstatus_t AudioFlinger::TrackHandle::queueTimedBuffer(const sp<IMemory>& buffer, 307741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams int64_t pts) { 308741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams if (!mTrack->isTimedTrack()) 309741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams return INVALID_OPERATION; 310741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams 311741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams if (buffer == 0 || buffer->pointer() == NULL) { 312c700e649ca44d0dcff8b271e42d949ea72fe3c63Alex Sakhartchouk ALOGE("queueTimedBuffer() buffer is 0 or has NULL pointer()"); 313da6d34a5a6ece8c30d20673b9b6ff07d8c91768bAlex Sakhartchouk return BAD_VALUE; 314741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams } 315c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams 316249d453869cca82dcb57123f6d1c8df3ca9f4372Jason Sams PlaybackThread::TimedTrack* tt = 317cf912de17f1e086ccea707d8607a3d2eda56b98fJason Sams reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get()); 318741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams return tt->queueTimedBuffer(buffer, pts); 319741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams} 3202382aba4a55c6ae74789c478eead8fbd96593321Jason Sams 3212382aba4a55c6ae74789c478eead8fbd96593321Jason Samsstatus_t AudioFlinger::TrackHandle::setMediaTimeTransform( 322ee803446857b14d97f3e90a4f530604b6be9c867Jason Sams const LinearTransform& xform, int target) { 323ee803446857b14d97f3e90a4f530604b6be9c867Jason Sams 324ee803446857b14d97f3e90a4f530604b6be9c867Jason Sams if (!mTrack->isTimedTrack()) 325ee803446857b14d97f3e90a4f530604b6be9c867Jason Sams return INVALID_OPERATION; 326ee803446857b14d97f3e90a4f530604b6be9c867Jason Sams 327ee803446857b14d97f3e90a4f530604b6be9c867Jason Sams PlaybackThread::TimedTrack* tt = 3282382aba4a55c6ae74789c478eead8fbd96593321Jason Sams reinterpret_cast<PlaybackThread::TimedTrack*>(mTrack.get()); 3292382aba4a55c6ae74789c478eead8fbd96593321Jason Sams return tt->setMediaTimeTransform( 3302382aba4a55c6ae74789c478eead8fbd96593321Jason Sams xform, static_cast<TimedAudioTrack::TargetTimeline>(target)); 331afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk} 332158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams 333158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Samsstatus_t AudioFlinger::TrackHandle::setParameters(const String8& keyValuePairs) { 334158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams return mTrack->setParameters(keyValuePairs); 335158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams} 3362dca84dd6c07992f78ad050177975f16486dd77eJason Sams 337158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Samsstatus_t AudioFlinger::TrackHandle::getTimestamp(AudioTimestamp& timestamp) 338158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams{ 339158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams return mTrack->getTimestamp(timestamp); 340158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams} 341158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams 342158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams 343158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Samsvoid AudioFlinger::TrackHandle::signal() 344158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams{ 345158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams return mTrack->signal(); 3467bf29ddc35450d8064541c42c99a1f48be6cf0ddJason Sams} 347158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams 348158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Samsstatus_t AudioFlinger::TrackHandle::onTransact( 349158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 350afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk{ 3515c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams return BnAudioTrack::onTransact(code, data, reply, flags); 352326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 353326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 35486f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams// ---------------------------------------------------------------------------- 355e514b45de8561fbc6ef6770845102ca10b0a69d7Jason Sams 356a2cf755a28a1e7ffff2955df656d714f40e4d715Jason Sams// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held 357cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen HinesAudioFlinger::PlaybackThread::Track::Track( 3587b3e9bd825901e33661e3c385e3e7c6f40ca6000Alex Sakhartchouk PlaybackThread *thread, 359b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk const sp<Client>& client, 3605c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams audio_stream_type_t streamType, 3615c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams uint32_t sampleRate, 362afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk audio_format_t format, 3635c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams audio_channel_mask_t channelMask, 364b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk size_t frameCount, 3655c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams const sp<IMemory>& sharedBuffer, 3665c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams int sessionId, 3675c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams int uid, 3685c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams IAudioFlinger::track_flags_t flags) 3695c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams : TrackBase(thread, client, sampleRate, format, channelMask, frameCount, sharedBuffer, 3705c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams sessionId, uid, flags, true /*isOut*/), 3715c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams mFillingUpStatus(FS_INVALID), 372b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // mRetryCount initialized later when needed 373b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk mSharedBuffer(sharedBuffer), 374b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk mStreamType(streamType), 375b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk mName(-1), // see note below 376b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk mMainBuffer(thread->mixBuffer()), 377b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk mAuxBuffer(NULL), 378afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk mAuxEffectId(0), mHasVolumeController(false), 3795c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams mPresentationCompleteFrames(0), 3805c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams mFastIndex(-1), 3811a4efa363916977ef9aeab756725b3bdc880a15bJason Sams mCachedVolume(1.0), 3822382aba4a55c6ae74789c478eead8fbd96593321Jason Sams mIsInvalid(false), 3831a4efa363916977ef9aeab756725b3bdc880a15bJason Sams mAudioTrackServerProxy(NULL), 3845c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams mResumeToStopping(false), 3855c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams mFlushHwPending(false) 3866b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams{ 3876b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams if (mCblk == NULL) { 3886b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams return; 3896b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams } 3906b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams 391a2cf755a28a1e7ffff2955df656d714f40e4d715Jason Sams if (sharedBuffer == 0) { 3926b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount, 393326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams mFrameSize); 394a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams } else { 395a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount, 396a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams mFrameSize); 397fb03a22ad2adadc1ff50a8b50d43ad7fcc3fa6edJason Sams } 398fb03a22ad2adadc1ff50a8b50d43ad7fcc3fa6edJason Sams mServerProxy = mAudioTrackServerProxy; 399fb03a22ad2adadc1ff50a8b50d43ad7fcc3fa6edJason Sams 400e57691037aea219562ac686429b4b98202aab7bcJason Sams mName = thread->getTrackName_l(channelMask, sessionId); 401a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams if (mName < 0) { 402a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams ALOGE("no more track names available"); 403a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams return; 4045c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams } 405a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams // only allocate a fast track index if we were able to allocate a normal track name 406a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams if (flags & IAudioFlinger::TRACK_FAST) { 4077257c7ee4b66f00c43d9235f3ac600061ae79968Alex Sakhartchouk mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads(); 408992a0b70d8fd7a14f0c57bc3c7e16c1f269a6609Jason Sams ALOG_ASSERT(thread->mFastTrackAvailMask != 0); 40924371d93cdb6999971c4058f78974da3c3d5fc64Jason Sams int i = __builtin_ctz(thread->mFastTrackAvailMask); 410a891933b4c5ab1b63103add167269cfc404c2adfJason Sams ALOG_ASSERT(0 < i && i < (int)FastMixerState::kMaxFastTracks); 4115086938044e0a9b6b1138f915d0d252fe046e102Jason Sams // FIXME This is too eager. We allocate a fast track index before the 412a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams // fast track becomes active. Since fast tracks are a scarce resource, 413326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // this means we are potentially denying other more important fast tracks from 414326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // being created. It would be better to allocate the index dynamically. 4155c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams mFastIndex = i; 4167bf29ddc35450d8064541c42c99a1f48be6cf0ddJason Sams // Read the initial underruns because this field is never cleared by the fast mixer 417afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk mObservedUnderruns = thread->getFastTrackUnderruns(i); 418181334092f78273d0da2d854ebbe7b24508d3bfcJason Sams thread->mFastTrackAvailMask &= ~(1 << i); 419181334092f78273d0da2d854ebbe7b24508d3bfcJason Sams } 420181334092f78273d0da2d854ebbe7b24508d3bfcJason Sams} 4215c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams 4222cfe51e7a9eef3dec091ce7c15d2a5a2216e9d3eJason SamsAudioFlinger::PlaybackThread::Track::~Track() 4235c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams{ 4245c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams ALOGV("PlaybackThread::Track destructor"); 4255c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams 426a658e905f14fe500bfee3812b213a73cb37ef6f2Jason Sams // The destructor would clear mSharedBuffer, 4275c1c79a54c63b9de8c391f7ed890c02f280ec17fJason Sams // but it will not push the decremented reference count, 428326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // leaving the client's IMemory dangling indefinitely. 429326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // This prevents that leak. 430afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk if (mSharedBuffer != 0) { 43186d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams mSharedBuffer.clear(); 432cf912de17f1e086ccea707d8607a3d2eda56b98fJason Sams // flush the binder command buffer 433b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk IPCThreadState::self()->flushCommands(); 434b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk } 435b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk} 436b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk 437b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchoukstatus_t AudioFlinger::PlaybackThread::Track::initCheck() const 438b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk{ 439326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams status_t status = TrackBase::initCheck(); 440b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk if (status == NO_ERROR && mName < 0) { 441b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk status = NO_MEMORY; 442326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams } 443b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk return status; 444b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk} 445b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk 446249d453869cca82dcb57123f6d1c8df3ca9f4372Jason Samsvoid AudioFlinger::PlaybackThread::Track::destroy() 447b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk{ 448b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // NOTE: destroyTrack_l() can remove a strong reference to this Track 449b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // by removing it from mTracks vector, so there is a risk that this Tracks's 450b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // destructor is called. As the destructor needs to lock mLock, 451b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // we must acquire a strong reference on this Track before locking mLock 452b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // here so that the destructor is called only when exiting this function. 453b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk // On the other hand, as long as Track::destroy() is only called by 454326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // TrackHandle destructor, the TrackHandle still holds a strong ref on 45586d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams // this Track with its member mTrack. 456326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams sp<Track> keep(this); 457326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams { // scope for mLock 4587257c7ee4b66f00c43d9235f3ac600061ae79968Alex Sakhartchouk sp<ThreadBase> thread = mThread.promote(); 4594820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams if (thread != 0) { 4604b3de47071d875faaa7d419d050a464b09538797Jason Sams Mutex::Autolock _l(thread->mLock); 461458f2dc26b7d34c2138c7bfbd95914240084e6bdJason Sams PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 4627257c7ee4b66f00c43d9235f3ac600061ae79968Alex Sakhartchouk bool wasActive = playbackThread->destroyTrack_l(this); 4634b3de47071d875faaa7d419d050a464b09538797Jason Sams if (!isOutputTrack() && !wasActive) { 4644b3de47071d875faaa7d419d050a464b09538797Jason Sams AudioSystem::releaseOutput(thread->id()); 465613cad1702dbb76eb2a6ba0cfcb43b9fe207cebcJason Sams } 4664b3de47071d875faaa7d419d050a464b09538797Jason Sams } 467771565f47fc44608444c00aa8fa3bda769ceaeceJason Sams } 468a544b6368d7ddae47985da92d6bcf86798b376c6Alex Sakhartchouk} 469458f2dc26b7d34c2138c7bfbd95914240084e6bdJason Sams 470458f2dc26b7d34c2138c7bfbd95914240084e6bdJason Sams/*static*/ void AudioFlinger::PlaybackThread::Track::appendDumpHeader(String8& result) 471458f2dc26b7d34c2138c7bfbd95914240084e6bdJason Sams{ 472afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk result.append(" Name Active Client Type Fmt Chn mask Session fCount S F SRate " 4734820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams "L dB R dB Server Main buf Aux Buf Flags UndFrmCnt\n"); 47486f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams} 47586f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams 47686f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Samsvoid AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size, bool active) 477afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk{ 4784820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR(); 47986f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams if (isFastTrack()) { 48086f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams sprintf(buffer, " F %2d", mFastIndex); 48186f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams } else if (mName >= AudioMixer::TRACK0) { 482afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk sprintf(buffer, " %4d", mName - AudioMixer::TRACK0); 4834820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams } else { 484326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams sprintf(buffer, " none"); 485326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams } 486326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams track_state state = mState; 48760709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams char stateChar; 4884820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams if (isTerminated()) { 4898ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams stateChar = 'T'; 4908ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams } else { 4918ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams switch (state) { 4928ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams case IDLE: 4938ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams stateChar = 'I'; 494326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams break; 495326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams case STOPPING_1: 49660709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams stateChar = 's'; 4974820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams break; 4988ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams case STOPPING_2: 4998ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams stateChar = '5'; 5008ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams break; 5018ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams case STOPPED: 5028ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams stateChar = 'S'; 503cfb1d11ce6826fce7241d316d8b7dcab661f63a6Jason Sams break; 504cfb1d11ce6826fce7241d316d8b7dcab661f63a6Jason Sams case RESUMING: 50560709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams stateChar = 'R'; 5064820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams break; 5075fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams case ACTIVE: 5085fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams stateChar = 'A'; 5095fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams break; 5105fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams case PAUSING: 5115fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams stateChar = 'p'; 5125fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams break; 5135fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams case PAUSED: 51460709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams stateChar = 'P'; 5154820e8bb83b1f78e6232ebe853221f737da2a1eaJason Sams break; 5168ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams case FLUSHED: 5178ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams stateChar = 'F'; 5188ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams break; 5198ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams default: 5208ce125be69531dbf3a7e856d5e59d1b8e2789db0Jason Sams stateChar = '?'; 521326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams break; 522326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams } 523afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 524d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk char nowInUnderrun; 525d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk switch (mObservedUnderruns.mBitFields.mMostRecent) { 526d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk case UNDERRUN_FULL: 527d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk nowInUnderrun = ' '; 528d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk break; 529d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk case UNDERRUN_PARTIAL: 530d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk nowInUnderrun = '<'; 531d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk break; 532afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk case UNDERRUN_EMPTY: 533a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams nowInUnderrun = '*'; 534a4a54e42fc710a62b47cbcb9d64c34a190429d9eJason Sams break; 535a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams default: 536a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams nowInUnderrun = '?'; 537a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams break; 538afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 539afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk snprintf(&buffer[8], size-8, " %6s %6u %4u %08X %08X %7u %6zu %1c %1d %5u %5.2g %5.2g " 540a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams "%08X %p %p 0x%03X %9u%c\n", 541a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams active ? "yes" : "no", 542a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams (mClient == 0) ? getpid_cached : mClient->pid(), 543a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams mStreamType, 544a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams mFormat, 545a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams mChannelMask, 546a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams mSessionId, 5471a4efa363916977ef9aeab756725b3bdc880a15bJason Sams mFrameCount, 5481a4efa363916977ef9aeab756725b3bdc880a15bJason Sams stateChar, 549aad4bc5231dd7059fc5148b34a951117d9b5f4adJason Sams mFillingUpStatus, 550aad4bc5231dd7059fc5148b34a951117d9b5f4adJason Sams mAudioTrackServerProxy->getSampleRate(), 5511a4efa363916977ef9aeab756725b3bdc880a15bJason Sams 20.0 * log10(float_from_gain(gain_minifloat_unpack_left(vlr))), 5521a4efa363916977ef9aeab756725b3bdc880a15bJason Sams 20.0 * log10(float_from_gain(gain_minifloat_unpack_right(vlr))), 5538c401effb0837155fc39ca0364f57a882d127d38Jason Sams mCblk->mServer, 5548c401effb0837155fc39ca0364f57a882d127d38Jason Sams mMainBuffer, 55587319de2b16a185cf360827c96a42cf1fcaae744Jason Sams mAuxBuffer, 55687319de2b16a185cf360827c96a42cf1fcaae744Jason Sams mCblk->mFlags, 5571a4efa363916977ef9aeab756725b3bdc880a15bJason Sams mAudioTrackServerProxy->getUnderrunFrames(), 5581a4efa363916977ef9aeab756725b3bdc880a15bJason Sams nowInUnderrun); 5598c401effb0837155fc39ca0364f57a882d127d38Jason Sams} 5608c401effb0837155fc39ca0364f57a882d127d38Jason Sams 561afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukuint32_t AudioFlinger::PlaybackThread::Track::sampleRate() const { 562afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk return mAudioTrackServerProxy->getSampleRate(); 5638c401effb0837155fc39ca0364f57a882d127d38Jason Sams} 5648c401effb0837155fc39ca0364f57a882d127d38Jason Sams 5658c401effb0837155fc39ca0364f57a882d127d38Jason Sams// AudioBufferProvider interface 5668c401effb0837155fc39ca0364f57a882d127d38Jason Samsstatus_t AudioFlinger::PlaybackThread::Track::getNextBuffer( 567afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk AudioBufferProvider::Buffer* buffer, int64_t pts __unused) 5681a4efa363916977ef9aeab756725b3bdc880a15bJason Sams{ 5698c401effb0837155fc39ca0364f57a882d127d38Jason Sams ServerProxy::Buffer buf; 5705086938044e0a9b6b1138f915d0d252fe046e102Jason Sams size_t desiredFrames = buffer->frameCount; 57187319de2b16a185cf360827c96a42cf1fcaae744Jason Sams buf.mFrameCount = desiredFrames; 572a2cf755a28a1e7ffff2955df656d714f40e4d715Jason Sams status_t status = mServerProxy->obtainBuffer(&buf); 573aad4bc5231dd7059fc5148b34a951117d9b5f4adJason Sams buffer->frameCount = buf.mFrameCount; 574a2cf755a28a1e7ffff2955df656d714f40e4d715Jason Sams buffer->raw = buf.mRaw; 575a2cf755a28a1e7ffff2955df656d714f40e4d715Jason Sams if (buf.mFrameCount == 0) { 576a2cf755a28a1e7ffff2955df656d714f40e4d715Jason Sams mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames); 577afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 57813e2634a71a30d289ed8d821aef61c7d1687460eJason Sams return status; 57913e2634a71a30d289ed8d821aef61c7d1687460eJason Sams} 58013e2634a71a30d289ed8d821aef61c7d1687460eJason Sams 58113e2634a71a30d289ed8d821aef61c7d1687460eJason Sams// releaseBuffer() is not overridden 5826b8552a4f6a44848255d77222e66aa92dd21b1b5Jason Sams 583b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk// ExtendedAudioBufferProvider interface 58413e2634a71a30d289ed8d821aef61c7d1687460eJason Sams 585a4a54e42fc710a62b47cbcb9d64c34a190429d9eJason Sams// Note that framesReady() takes a mutex on the control block using tryLock(). 586326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams// This could result in priority inversion if framesReady() is called by the normal mixer, 587a44cb29164726cd9d812117819abdd7b60dfdd93Jason Sams// as the normal mixer thread runs at lower 588326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams// priority than the client's callback thread: there is a short window within framesReady() 589326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams// during which the normal mixer could be preempted, and the client callback would block. 590326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams// Another problem can occur if framesReady() is called by the fast mixer: 591326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams// the tryLock() could block for up to 1 ms, and a sequence of these could delay fast mixer. 592afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk// FIXME Replace AudioTrackShared control block implementation by a non-blocking FIFO queue. 5938c88090e8cccab103eebe2ff569e116e9f5fb208Jason Samssize_t AudioFlinger::PlaybackThread::Track::framesReady() const { 594326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams return mAudioTrackServerProxy->framesReady(); 595afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk} 596326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 597326e0ddf89e8df2837752fbfd7a014814b32082cJason Samssize_t AudioFlinger::PlaybackThread::Track::framesReleased() const 598326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams{ 599326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams return mAudioTrackServerProxy->framesReleased(); 600afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk} 601326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 602326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams// Don't call for fast tracks; the framesReady() could result in priority inversion 603326e0ddf89e8df2837752fbfd7a014814b32082cJason Samsbool AudioFlinger::PlaybackThread::Track::isReady() const { 604326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) { 605326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams return true; 606326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams } 607326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 608326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams if (isStopping()) { 609326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams if (framesReady() > 0) { 610326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams mFillingUpStatus = FS_FILLED; 611afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 612ccc010bb7c0f89e162bf60033968a20be90a903aJason Sams return true; 61360709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams } 614326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 615326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams if (framesReady() >= mFrameCount || 616afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk (mCblk->mFlags & CBLK_FORCEREADY)) { 617326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams mFillingUpStatus = FS_FILLED; 61860709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags); 619326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams return true; 620326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams } 621afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk return false; 6225fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams} 62360709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams 6245fd09d847586f9680b4f495413b6ca5fbb69af6eJason Samsstatus_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused, 6255fd09d847586f9680b4f495413b6ca5fbb69af6eJason Sams int triggerSession __unused) 626afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk{ 627326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams status_t status = NO_ERROR; 62860709257bbdeb0c50f39b9c8969dc76264d6e142Jason Sams ALOGV("start(%d), calling pid %d session %d", 629326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams mName, IPCThreadState::self()->getCallingPid(), mSessionId); 630326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 631afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk sp<ThreadBase> thread = mThread.promote(); 632d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk if (thread != 0) { 633d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk if (isOffloaded()) { 634d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk Mutex::Autolock _laf(thread->mAudioFlinger->mLock); 635d3e0ad43dc758c409fc23d1893dab67b18520c24Alex Sakhartchouk Mutex::Autolock _lth(thread->mLock); 636b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk sp<EffectChain> ec = thread->getEffectChain_l(mSessionId); 637a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() || 63870b83c111beceaf8fbb700580833e7fec99272cfAlex Sakhartchouk (ec != 0 && ec->isNonOffloadableEnabled())) { 639a0a1b6fbece2eb8d72d788422ab3e5f58d5a9216Jason Sams invalidate(); 640326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams return PERMISSION_DENIED; 641afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 6422353ae303868d04e3a26002b2f2dc456c15e8170Jason Sams } 643707aaf341a4b068e6ccadf923af85acdd85fd775Jason Sams Mutex::Autolock _lth(thread->mLock); 6449397e30ce5fe3f6af9212a93b490836b04fdfffaJason Sams track_state state = mState; 645707aaf341a4b068e6ccadf923af85acdd85fd775Jason Sams // here the track could be either new, or restarted 646707aaf341a4b068e6ccadf923af85acdd85fd775Jason Sams // in both cases "unstop" the track 647afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk 64886f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams // initial state-stopping. next state-pausing. 64986f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams // What if resume is called ? 65086f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams 651afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk if (state == PAUSED || state == PAUSING) { 65286f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams if (mResumeToStopping) { 65386f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams // happened we need to resume to STOPPING_1 65486f1b23aaaf9b8822a009d8c3e585e46768abb6aJason Sams mState = TrackBase::STOPPING_1; 6557257c7ee4b66f00c43d9235f3ac600061ae79968Alex Sakhartchouk ALOGV("PAUSED => STOPPING_1 (%d) on thread %p", mName, this); 656fa4028663712dbb1a3d13c507c3bc13c6e4be80dMathias Agopian } else { 657613cad1702dbb76eb2a6ba0cfcb43b9fe207cebcJason Sams mState = TrackBase::RESUMING; 658613cad1702dbb76eb2a6ba0cfcb43b9fe207cebcJason Sams ALOGV("PAUSED => RESUMING (%d) on thread %p", mName, this); 659afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 660158324456b8dbf40f684dd0a4af3493b9549f3f5Jason Sams } else { 661458f2dc26b7d34c2138c7bfbd95914240084e6bdJason Sams mState = TrackBase::ACTIVE; 662458f2dc26b7d34c2138c7bfbd95914240084e6bdJason Sams ALOGV("? => ACTIVE (%d) on thread %p", mName, this); 663afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk } 664c21cf40f6ae69091bf24f87b5eeabc95e73dd271Jason Sams 665c21cf40f6ae69091bf24f87b5eeabc95e73dd271Jason Sams PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 666c21cf40f6ae69091bf24f87b5eeabc95e73dd271Jason Sams status = playbackThread->addTrack_l(this); 667741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams if (status == INVALID_OPERATION || status == PERMISSION_DENIED) { 668b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE); 6691dcefab7178f0644b0e0a6998007b1acae5261cfJason Sams // restore previous state if start was rejected by policy manager 6701dcefab7178f0644b0e0a6998007b1acae5261cfJason Sams if (status == PERMISSION_DENIED) { 671c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams mState = state; 67286d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams } 673741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams } 674741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams // track was already in the active list, not a problem 67586d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams if (status == ALREADY_EXISTS) { 676741aac95b777b2e6cb90f484a05e489a79a6ef05Jason Sams status = NO_ERROR; 677326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams } else { 678326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams // Acknowledge any pending flush(), so that subsequent new data isn't discarded. 679c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams // It is usually unsafe to access the server proxy from a binder thread. 680186e59154a0fb86e05e283e9c083b69878c06720Jason Sams // But in this case we know the mixer thread (whether normal mixer or fast mixer) 6811a4efa363916977ef9aeab756725b3bdc880a15bJason Sams // isn't looking at this track yet: we still hold the normal mixer thread lock, 6821a4efa363916977ef9aeab756725b3bdc880a15bJason Sams // and for fast tracks the track is not yet in the fast mixer thread's active set. 683aad4bc5231dd7059fc5148b34a951117d9b5f4adJason Sams ServerProxy::Buffer buffer; 684aad4bc5231dd7059fc5148b34a951117d9b5f4adJason Sams buffer.mFrameCount = 1; 685c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams (void) mAudioTrackServerProxy->obtainBuffer(&buffer, true /*ackFlush*/); 686186e59154a0fb86e05e283e9c083b69878c06720Jason Sams } 6871a4efa363916977ef9aeab756725b3bdc880a15bJason Sams } else { 688186e59154a0fb86e05e283e9c083b69878c06720Jason Sams status = BAD_VALUE; 689186e59154a0fb86e05e283e9c083b69878c06720Jason Sams } 6901a4efa363916977ef9aeab756725b3bdc880a15bJason Sams return status; 6918c401effb0837155fc39ca0364f57a882d127d38Jason Sams} 6928c401effb0837155fc39ca0364f57a882d127d38Jason Sams 693c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Samsvoid AudioFlinger::PlaybackThread::Track::stop() 6948c401effb0837155fc39ca0364f57a882d127d38Jason Sams{ 6958c401effb0837155fc39ca0364f57a882d127d38Jason Sams ALOGV("stop(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid()); 6968c401effb0837155fc39ca0364f57a882d127d38Jason Sams sp<ThreadBase> thread = mThread.promote(); 697c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams if (thread != 0) { 6988c401effb0837155fc39ca0364f57a882d127d38Jason Sams Mutex::Autolock _l(thread->mLock); 6998c401effb0837155fc39ca0364f57a882d127d38Jason Sams track_state state = mState; 7008c401effb0837155fc39ca0364f57a882d127d38Jason Sams if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) { 701c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams // If the track is not active (PAUSED and buffers full), flush buffers 702c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 703c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams if (playbackThread->mActiveTracks.indexOf(this) < 0) { 704cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines reset(); 705cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines mState = STOPPED; 70686d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams } else if (!isFastTrack() && !isOffloaded()) { 707789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams mState = STOPPED; 708789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams } else { 709cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines // For fast tracks prepareTracks_l() will set state to STOPPING_2 710cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines // presentation is complete 711cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines // For an offloaded track this starts a drain and state will 712789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams // move to STOPPING_2 when drain completes and then STOPPED 713789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams mState = STOPPING_1; 714789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams } 715789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams ALOGV("not stopping/stopped => stopping/stopped (%d) on thread %p", mName, 716cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines playbackThread); 717cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines } 71886d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams } 719789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams} 720789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams 7219544f76195de22f655fd7a1894934667e7e55f6aJason Samsvoid AudioFlinger::PlaybackThread::Track::pause() 722cbb0b8aceedb9146ba901cba1fbd6d1e9ca88f51Stephen Hines{ 7239544f76195de22f655fd7a1894934667e7e55f6aJason Sams ALOGV("pause(%d), calling pid %d", mName, IPCThreadState::self()->getCallingPid()); 7249544f76195de22f655fd7a1894934667e7e55f6aJason Sams sp<ThreadBase> thread = mThread.promote(); 72586d842a703da80b40eae5a482d4e26d8b2aae048Jason Sams if (thread != 0) { 726789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams Mutex::Autolock _l(thread->mLock); 727789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 728789ca83c794cb7196c9bac97d39eaf1f7947af2aJason Sams switch (mState) { 729dc763f345db3e796efc28dc4b4d8edffda5a803eAlex Sakhartchouk case STOPPING_1: 730dc763f345db3e796efc28dc4b4d8edffda5a803eAlex Sakhartchouk case STOPPING_2: 731afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk if (!isOffloaded()) { 732dc763f345db3e796efc28dc4b4d8edffda5a803eAlex Sakhartchouk /* nothing to do if track is not offloaded */ 733dc763f345db3e796efc28dc4b4d8edffda5a803eAlex Sakhartchouk break; 734dc763f345db3e796efc28dc4b4d8edffda5a803eAlex Sakhartchouk } 735 736 // Offloaded track was draining, we need to carry on draining when resumed 737 mResumeToStopping = true; 738 // fall through... 739 case ACTIVE: 740 case RESUMING: 741 mState = PAUSING; 742 ALOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get()); 743 playbackThread->broadcast_l(); 744 break; 745 746 default: 747 break; 748 } 749 } 750} 751 752void AudioFlinger::PlaybackThread::Track::flush() 753{ 754 ALOGV("flush(%d)", mName); 755 sp<ThreadBase> thread = mThread.promote(); 756 if (thread != 0) { 757 Mutex::Autolock _l(thread->mLock); 758 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 759 760 if (isOffloaded()) { 761 // If offloaded we allow flush during any state except terminated 762 // and keep the track active to avoid problems if user is seeking 763 // rapidly and underlying hardware has a significant delay handling 764 // a pause 765 if (isTerminated()) { 766 return; 767 } 768 769 ALOGV("flush: offload flush"); 770 reset(); 771 772 if (mState == STOPPING_1 || mState == STOPPING_2) { 773 ALOGV("flushed in STOPPING_1 or 2 state, change state to ACTIVE"); 774 mState = ACTIVE; 775 } 776 777 if (mState == ACTIVE) { 778 ALOGV("flush called in active state, resetting buffer time out retry count"); 779 mRetryCount = PlaybackThread::kMaxTrackRetriesOffload; 780 } 781 782 mFlushHwPending = true; 783 mResumeToStopping = false; 784 } else { 785 if (mState != STOPPING_1 && mState != STOPPING_2 && mState != STOPPED && 786 mState != PAUSED && mState != PAUSING && mState != IDLE && mState != FLUSHED) { 787 return; 788 } 789 // No point remaining in PAUSED state after a flush => go to 790 // FLUSHED state 791 mState = FLUSHED; 792 // do not reset the track if it is still in the process of being stopped or paused. 793 // this will be done by prepareTracks_l() when the track is stopped. 794 // prepareTracks_l() will see mState == FLUSHED, then 795 // remove from active track list, reset(), and trigger presentation complete 796 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 797 reset(); 798 } 799 } 800 // Prevent flush being lost if the track is flushed and then resumed 801 // before mixer thread can run. This is important when offloading 802 // because the hardware buffer could hold a large amount of audio 803 playbackThread->broadcast_l(); 804 } 805} 806 807// must be called with thread lock held 808void AudioFlinger::PlaybackThread::Track::flushAck() 809{ 810 if (!isOffloaded()) 811 return; 812 813 mFlushHwPending = false; 814} 815 816void AudioFlinger::PlaybackThread::Track::reset() 817{ 818 // Do not reset twice to avoid discarding data written just after a flush and before 819 // the audioflinger thread detects the track is stopped. 820 if (!mResetDone) { 821 // Force underrun condition to avoid false underrun callback until first data is 822 // written to buffer 823 android_atomic_and(~CBLK_FORCEREADY, &mCblk->mFlags); 824 mFillingUpStatus = FS_FILLING; 825 mResetDone = true; 826 if (mState == FLUSHED) { 827 mState = IDLE; 828 } 829 } 830} 831 832status_t AudioFlinger::PlaybackThread::Track::setParameters(const String8& keyValuePairs) 833{ 834 sp<ThreadBase> thread = mThread.promote(); 835 if (thread == 0) { 836 ALOGE("thread is dead"); 837 return FAILED_TRANSACTION; 838 } else if ((thread->type() == ThreadBase::DIRECT) || 839 (thread->type() == ThreadBase::OFFLOAD)) { 840 return thread->setParameters(keyValuePairs); 841 } else { 842 return PERMISSION_DENIED; 843 } 844} 845 846status_t AudioFlinger::PlaybackThread::Track::getTimestamp(AudioTimestamp& timestamp) 847{ 848 // Client should implement this using SSQ; the unpresented frame count in latch is irrelevant 849 if (isFastTrack()) { 850 return INVALID_OPERATION; 851 } 852 sp<ThreadBase> thread = mThread.promote(); 853 if (thread == 0) { 854 return INVALID_OPERATION; 855 } 856 Mutex::Autolock _l(thread->mLock); 857 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 858 if (!isOffloaded()) { 859 if (!playbackThread->mLatchQValid) { 860 return INVALID_OPERATION; 861 } 862 uint32_t unpresentedFrames = 863 ((int64_t) playbackThread->mLatchQ.mUnpresentedFrames * mSampleRate) / 864 playbackThread->mSampleRate; 865 uint32_t framesWritten = mAudioTrackServerProxy->framesReleased(); 866 if (framesWritten < unpresentedFrames) { 867 return INVALID_OPERATION; 868 } 869 timestamp.mPosition = framesWritten - unpresentedFrames; 870 timestamp.mTime = playbackThread->mLatchQ.mTimestamp.mTime; 871 return NO_ERROR; 872 } 873 874 return playbackThread->getTimestamp_l(timestamp); 875} 876 877status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId) 878{ 879 status_t status = DEAD_OBJECT; 880 sp<ThreadBase> thread = mThread.promote(); 881 if (thread != 0) { 882 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 883 sp<AudioFlinger> af = mClient->audioFlinger(); 884 885 Mutex::Autolock _l(af->mLock); 886 887 sp<PlaybackThread> srcThread = af->getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId); 888 889 if (EffectId != 0 && srcThread != 0 && playbackThread != srcThread.get()) { 890 Mutex::Autolock _dl(playbackThread->mLock); 891 Mutex::Autolock _sl(srcThread->mLock); 892 sp<EffectChain> chain = srcThread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX); 893 if (chain == 0) { 894 return INVALID_OPERATION; 895 } 896 897 sp<EffectModule> effect = chain->getEffectFromId_l(EffectId); 898 if (effect == 0) { 899 return INVALID_OPERATION; 900 } 901 srcThread->removeEffect_l(effect); 902 status = playbackThread->addEffect_l(effect); 903 if (status != NO_ERROR) { 904 srcThread->addEffect_l(effect); 905 return INVALID_OPERATION; 906 } 907 // removeEffect_l() has stopped the effect if it was active so it must be restarted 908 if (effect->state() == EffectModule::ACTIVE || 909 effect->state() == EffectModule::STOPPING) { 910 effect->start(); 911 } 912 913 sp<EffectChain> dstChain = effect->chain().promote(); 914 if (dstChain == 0) { 915 srcThread->addEffect_l(effect); 916 return INVALID_OPERATION; 917 } 918 AudioSystem::unregisterEffect(effect->id()); 919 AudioSystem::registerEffect(&effect->desc(), 920 srcThread->id(), 921 dstChain->strategy(), 922 AUDIO_SESSION_OUTPUT_MIX, 923 effect->id()); 924 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled()); 925 } 926 status = playbackThread->attachAuxEffect(this, EffectId); 927 } 928 return status; 929} 930 931void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer) 932{ 933 mAuxEffectId = EffectId; 934 mAuxBuffer = buffer; 935} 936 937bool AudioFlinger::PlaybackThread::Track::presentationComplete(size_t framesWritten, 938 size_t audioHalFrames) 939{ 940 // a track is considered presented when the total number of frames written to audio HAL 941 // corresponds to the number of frames written when presentationComplete() is called for the 942 // first time (mPresentationCompleteFrames == 0) plus the buffer filling status at that time. 943 // For an offloaded track the HAL+h/w delay is variable so a HAL drain() is used 944 // to detect when all frames have been played. In this case framesWritten isn't 945 // useful because it doesn't always reflect whether there is data in the h/w 946 // buffers, particularly if a track has been paused and resumed during draining 947 ALOGV("presentationComplete() mPresentationCompleteFrames %d framesWritten %d", 948 mPresentationCompleteFrames, framesWritten); 949 if (mPresentationCompleteFrames == 0) { 950 mPresentationCompleteFrames = framesWritten + audioHalFrames; 951 ALOGV("presentationComplete() reset: mPresentationCompleteFrames %d audioHalFrames %d", 952 mPresentationCompleteFrames, audioHalFrames); 953 } 954 955 if (framesWritten >= mPresentationCompleteFrames || isOffloaded()) { 956 ALOGV("presentationComplete() session %d complete: framesWritten %d", 957 mSessionId, framesWritten); 958 triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE); 959 mAudioTrackServerProxy->setStreamEndDone(); 960 return true; 961 } 962 return false; 963} 964 965void AudioFlinger::PlaybackThread::Track::triggerEvents(AudioSystem::sync_event_t type) 966{ 967 for (size_t i = 0; i < mSyncEvents.size(); i++) { 968 if (mSyncEvents[i]->type() == type) { 969 mSyncEvents[i]->trigger(); 970 mSyncEvents.removeAt(i); 971 i--; 972 } 973 } 974} 975 976// implement VolumeBufferProvider interface 977 978gain_minifloat_packed_t AudioFlinger::PlaybackThread::Track::getVolumeLR() 979{ 980 // called by FastMixer, so not allowed to take any locks, block, or do I/O including logs 981 ALOG_ASSERT(isFastTrack() && (mCblk != NULL)); 982 gain_minifloat_packed_t vlr = mAudioTrackServerProxy->getVolumeLR(); 983 float vl = float_from_gain(gain_minifloat_unpack_left(vlr)); 984 float vr = float_from_gain(gain_minifloat_unpack_right(vlr)); 985 // track volumes come from shared memory, so can't be trusted and must be clamped 986 if (vl > GAIN_FLOAT_UNITY) { 987 vl = GAIN_FLOAT_UNITY; 988 } 989 if (vr > GAIN_FLOAT_UNITY) { 990 vr = GAIN_FLOAT_UNITY; 991 } 992 // now apply the cached master volume and stream type volume; 993 // this is trusted but lacks any synchronization or barrier so may be stale 994 float v = mCachedVolume; 995 vl *= v; 996 vr *= v; 997 // re-combine into packed minifloat 998 vlr = gain_minifloat_pack(gain_from_float(vl), gain_from_float(vr)); 999 // FIXME look at mute, pause, and stop flags 1000 return vlr; 1001} 1002 1003status_t AudioFlinger::PlaybackThread::Track::setSyncEvent(const sp<SyncEvent>& event) 1004{ 1005 if (isTerminated() || mState == PAUSED || 1006 ((framesReady() == 0) && ((mSharedBuffer != 0) || 1007 (mState == STOPPED)))) { 1008 ALOGW("Track::setSyncEvent() in invalid state %d on session %d %s mode, framesReady %d ", 1009 mState, mSessionId, (mSharedBuffer != 0) ? "static" : "stream", framesReady()); 1010 event->cancel(); 1011 return INVALID_OPERATION; 1012 } 1013 (void) TrackBase::setSyncEvent(event); 1014 return NO_ERROR; 1015} 1016 1017void AudioFlinger::PlaybackThread::Track::invalidate() 1018{ 1019 // FIXME should use proxy, and needs work 1020 audio_track_cblk_t* cblk = mCblk; 1021 android_atomic_or(CBLK_INVALID, &cblk->mFlags); 1022 android_atomic_release_store(0x40000000, &cblk->mFutex); 1023 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE 1024 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX); 1025 mIsInvalid = true; 1026} 1027 1028void AudioFlinger::PlaybackThread::Track::signal() 1029{ 1030 sp<ThreadBase> thread = mThread.promote(); 1031 if (thread != 0) { 1032 PlaybackThread *t = (PlaybackThread *)thread.get(); 1033 Mutex::Autolock _l(t->mLock); 1034 t->broadcast_l(); 1035 } 1036} 1037 1038//To be called with thread lock held 1039bool AudioFlinger::PlaybackThread::Track::isResumePending() { 1040 1041 if (mState == RESUMING) 1042 return true; 1043 /* Resume is pending if track was stopping before pause was called */ 1044 if (mState == STOPPING_1 && 1045 mResumeToStopping) 1046 return true; 1047 1048 return false; 1049} 1050 1051//To be called with thread lock held 1052void AudioFlinger::PlaybackThread::Track::resumeAck() { 1053 1054 1055 if (mState == RESUMING) 1056 mState = ACTIVE; 1057 1058 // Other possibility of pending resume is stopping_1 state 1059 // Do not update the state from stopping as this prevents 1060 // drain being called. 1061 if (mState == STOPPING_1) { 1062 mResumeToStopping = false; 1063 } 1064} 1065// ---------------------------------------------------------------------------- 1066 1067sp<AudioFlinger::PlaybackThread::TimedTrack> 1068AudioFlinger::PlaybackThread::TimedTrack::create( 1069 PlaybackThread *thread, 1070 const sp<Client>& client, 1071 audio_stream_type_t streamType, 1072 uint32_t sampleRate, 1073 audio_format_t format, 1074 audio_channel_mask_t channelMask, 1075 size_t frameCount, 1076 const sp<IMemory>& sharedBuffer, 1077 int sessionId, 1078 int uid) 1079{ 1080 if (!client->reserveTimedTrack()) 1081 return 0; 1082 1083 return new TimedTrack( 1084 thread, client, streamType, sampleRate, format, channelMask, frameCount, 1085 sharedBuffer, sessionId, uid); 1086} 1087 1088AudioFlinger::PlaybackThread::TimedTrack::TimedTrack( 1089 PlaybackThread *thread, 1090 const sp<Client>& client, 1091 audio_stream_type_t streamType, 1092 uint32_t sampleRate, 1093 audio_format_t format, 1094 audio_channel_mask_t channelMask, 1095 size_t frameCount, 1096 const sp<IMemory>& sharedBuffer, 1097 int sessionId, 1098 int uid) 1099 : Track(thread, client, streamType, sampleRate, format, channelMask, 1100 frameCount, sharedBuffer, sessionId, uid, IAudioFlinger::TRACK_TIMED), 1101 mQueueHeadInFlight(false), 1102 mTrimQueueHeadOnRelease(false), 1103 mFramesPendingInQueue(0), 1104 mTimedSilenceBuffer(NULL), 1105 mTimedSilenceBufferSize(0), 1106 mTimedAudioOutputOnTime(false), 1107 mMediaTimeTransformValid(false) 1108{ 1109 LocalClock lc; 1110 mLocalTimeFreq = lc.getLocalFreq(); 1111 1112 mLocalTimeToSampleTransform.a_zero = 0; 1113 mLocalTimeToSampleTransform.b_zero = 0; 1114 mLocalTimeToSampleTransform.a_to_b_numer = sampleRate; 1115 mLocalTimeToSampleTransform.a_to_b_denom = mLocalTimeFreq; 1116 LinearTransform::reduce(&mLocalTimeToSampleTransform.a_to_b_numer, 1117 &mLocalTimeToSampleTransform.a_to_b_denom); 1118 1119 mMediaTimeToSampleTransform.a_zero = 0; 1120 mMediaTimeToSampleTransform.b_zero = 0; 1121 mMediaTimeToSampleTransform.a_to_b_numer = sampleRate; 1122 mMediaTimeToSampleTransform.a_to_b_denom = 1000000; 1123 LinearTransform::reduce(&mMediaTimeToSampleTransform.a_to_b_numer, 1124 &mMediaTimeToSampleTransform.a_to_b_denom); 1125} 1126 1127AudioFlinger::PlaybackThread::TimedTrack::~TimedTrack() { 1128 mClient->releaseTimedTrack(); 1129 delete [] mTimedSilenceBuffer; 1130} 1131 1132status_t AudioFlinger::PlaybackThread::TimedTrack::allocateTimedBuffer( 1133 size_t size, sp<IMemory>* buffer) { 1134 1135 Mutex::Autolock _l(mTimedBufferQueueLock); 1136 1137 trimTimedBufferQueue_l(); 1138 1139 // lazily initialize the shared memory heap for timed buffers 1140 if (mTimedMemoryDealer == NULL) { 1141 const int kTimedBufferHeapSize = 512 << 10; 1142 1143 mTimedMemoryDealer = new MemoryDealer(kTimedBufferHeapSize, 1144 "AudioFlingerTimed"); 1145 if (mTimedMemoryDealer == NULL) { 1146 return NO_MEMORY; 1147 } 1148 } 1149 1150 sp<IMemory> newBuffer = mTimedMemoryDealer->allocate(size); 1151 if (newBuffer == 0 || newBuffer->pointer() == NULL) { 1152 return NO_MEMORY; 1153 } 1154 1155 *buffer = newBuffer; 1156 return NO_ERROR; 1157} 1158 1159// caller must hold mTimedBufferQueueLock 1160void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueue_l() { 1161 int64_t mediaTimeNow; 1162 { 1163 Mutex::Autolock mttLock(mMediaTimeTransformLock); 1164 if (!mMediaTimeTransformValid) 1165 return; 1166 1167 int64_t targetTimeNow; 1168 status_t res = (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME) 1169 ? mCCHelper.getCommonTime(&targetTimeNow) 1170 : mCCHelper.getLocalTime(&targetTimeNow); 1171 1172 if (OK != res) 1173 return; 1174 1175 if (!mMediaTimeTransform.doReverseTransform(targetTimeNow, 1176 &mediaTimeNow)) { 1177 return; 1178 } 1179 } 1180 1181 size_t trimEnd; 1182 for (trimEnd = 0; trimEnd < mTimedBufferQueue.size(); trimEnd++) { 1183 int64_t bufEnd; 1184 1185 if ((trimEnd + 1) < mTimedBufferQueue.size()) { 1186 // We have a next buffer. Just use its PTS as the PTS of the frame 1187 // following the last frame in this buffer. If the stream is sparse 1188 // (ie, there are deliberate gaps left in the stream which should be 1189 // filled with silence by the TimedAudioTrack), then this can result 1190 // in one extra buffer being left un-trimmed when it could have 1191 // been. In general, this is not typical, and we would rather 1192 // optimized away the TS calculation below for the more common case 1193 // where PTSes are contiguous. 1194 bufEnd = mTimedBufferQueue[trimEnd + 1].pts(); 1195 } else { 1196 // We have no next buffer. Compute the PTS of the frame following 1197 // the last frame in this buffer by computing the duration of of 1198 // this frame in media time units and adding it to the PTS of the 1199 // buffer. 1200 int64_t frameCount = mTimedBufferQueue[trimEnd].buffer()->size() 1201 / mFrameSize; 1202 1203 if (!mMediaTimeToSampleTransform.doReverseTransform(frameCount, 1204 &bufEnd)) { 1205 ALOGE("Failed to convert frame count of %lld to media time" 1206 " duration" " (scale factor %d/%u) in %s", 1207 frameCount, 1208 mMediaTimeToSampleTransform.a_to_b_numer, 1209 mMediaTimeToSampleTransform.a_to_b_denom, 1210 __PRETTY_FUNCTION__); 1211 break; 1212 } 1213 bufEnd += mTimedBufferQueue[trimEnd].pts(); 1214 } 1215 1216 if (bufEnd > mediaTimeNow) 1217 break; 1218 1219 // Is the buffer we want to use in the middle of a mix operation right 1220 // now? If so, don't actually trim it. Just wait for the releaseBuffer 1221 // from the mixer which should be coming back shortly. 1222 if (!trimEnd && mQueueHeadInFlight) { 1223 mTrimQueueHeadOnRelease = true; 1224 } 1225 } 1226 1227 size_t trimStart = mTrimQueueHeadOnRelease ? 1 : 0; 1228 if (trimStart < trimEnd) { 1229 // Update the bookkeeping for framesReady() 1230 for (size_t i = trimStart; i < trimEnd; ++i) { 1231 updateFramesPendingAfterTrim_l(mTimedBufferQueue[i], "trim"); 1232 } 1233 1234 // Now actually remove the buffers from the queue. 1235 mTimedBufferQueue.removeItemsAt(trimStart, trimEnd); 1236 } 1237} 1238 1239void AudioFlinger::PlaybackThread::TimedTrack::trimTimedBufferQueueHead_l( 1240 const char* logTag) { 1241 ALOG_ASSERT(mTimedBufferQueue.size() > 0, 1242 "%s called (reason \"%s\"), but timed buffer queue has no" 1243 " elements to trim.", __FUNCTION__, logTag); 1244 1245 updateFramesPendingAfterTrim_l(mTimedBufferQueue[0], logTag); 1246 mTimedBufferQueue.removeAt(0); 1247} 1248 1249void AudioFlinger::PlaybackThread::TimedTrack::updateFramesPendingAfterTrim_l( 1250 const TimedBuffer& buf, 1251 const char* logTag __unused) { 1252 uint32_t bufBytes = buf.buffer()->size(); 1253 uint32_t consumedAlready = buf.position(); 1254 1255 ALOG_ASSERT(consumedAlready <= bufBytes, 1256 "Bad bookkeeping while updating frames pending. Timed buffer is" 1257 " only %u bytes long, but claims to have consumed %u" 1258 " bytes. (update reason: \"%s\")", 1259 bufBytes, consumedAlready, logTag); 1260 1261 uint32_t bufFrames = (bufBytes - consumedAlready) / mFrameSize; 1262 ALOG_ASSERT(mFramesPendingInQueue >= bufFrames, 1263 "Bad bookkeeping while updating frames pending. Should have at" 1264 " least %u queued frames, but we think we have only %u. (update" 1265 " reason: \"%s\")", 1266 bufFrames, mFramesPendingInQueue, logTag); 1267 1268 mFramesPendingInQueue -= bufFrames; 1269} 1270 1271status_t AudioFlinger::PlaybackThread::TimedTrack::queueTimedBuffer( 1272 const sp<IMemory>& buffer, int64_t pts) { 1273 1274 { 1275 Mutex::Autolock mttLock(mMediaTimeTransformLock); 1276 if (!mMediaTimeTransformValid) 1277 return INVALID_OPERATION; 1278 } 1279 1280 Mutex::Autolock _l(mTimedBufferQueueLock); 1281 1282 uint32_t bufFrames = buffer->size() / mFrameSize; 1283 mFramesPendingInQueue += bufFrames; 1284 mTimedBufferQueue.add(TimedBuffer(buffer, pts)); 1285 1286 return NO_ERROR; 1287} 1288 1289status_t AudioFlinger::PlaybackThread::TimedTrack::setMediaTimeTransform( 1290 const LinearTransform& xform, TimedAudioTrack::TargetTimeline target) { 1291 1292 ALOGVV("setMediaTimeTransform az=%lld bz=%lld n=%d d=%u tgt=%d", 1293 xform.a_zero, xform.b_zero, xform.a_to_b_numer, xform.a_to_b_denom, 1294 target); 1295 1296 if (!(target == TimedAudioTrack::LOCAL_TIME || 1297 target == TimedAudioTrack::COMMON_TIME)) { 1298 return BAD_VALUE; 1299 } 1300 1301 Mutex::Autolock lock(mMediaTimeTransformLock); 1302 mMediaTimeTransform = xform; 1303 mMediaTimeTransformTarget = target; 1304 mMediaTimeTransformValid = true; 1305 1306 return NO_ERROR; 1307} 1308 1309#define min(a, b) ((a) < (b) ? (a) : (b)) 1310 1311// implementation of getNextBuffer for tracks whose buffers have timestamps 1312status_t AudioFlinger::PlaybackThread::TimedTrack::getNextBuffer( 1313 AudioBufferProvider::Buffer* buffer, int64_t pts) 1314{ 1315 if (pts == AudioBufferProvider::kInvalidPTS) { 1316 buffer->raw = NULL; 1317 buffer->frameCount = 0; 1318 mTimedAudioOutputOnTime = false; 1319 return INVALID_OPERATION; 1320 } 1321 1322 Mutex::Autolock _l(mTimedBufferQueueLock); 1323 1324 ALOG_ASSERT(!mQueueHeadInFlight, 1325 "getNextBuffer called without releaseBuffer!"); 1326 1327 while (true) { 1328 1329 // if we have no timed buffers, then fail 1330 if (mTimedBufferQueue.isEmpty()) { 1331 buffer->raw = NULL; 1332 buffer->frameCount = 0; 1333 return NOT_ENOUGH_DATA; 1334 } 1335 1336 TimedBuffer& head = mTimedBufferQueue.editItemAt(0); 1337 1338 // calculate the PTS of the head of the timed buffer queue expressed in 1339 // local time 1340 int64_t headLocalPTS; 1341 { 1342 Mutex::Autolock mttLock(mMediaTimeTransformLock); 1343 1344 ALOG_ASSERT(mMediaTimeTransformValid, "media time transform invalid"); 1345 1346 if (mMediaTimeTransform.a_to_b_denom == 0) { 1347 // the transform represents a pause, so yield silence 1348 timedYieldSilence_l(buffer->frameCount, buffer); 1349 return NO_ERROR; 1350 } 1351 1352 int64_t transformedPTS; 1353 if (!mMediaTimeTransform.doForwardTransform(head.pts(), 1354 &transformedPTS)) { 1355 // the transform failed. this shouldn't happen, but if it does 1356 // then just drop this buffer 1357 ALOGW("timedGetNextBuffer transform failed"); 1358 buffer->raw = NULL; 1359 buffer->frameCount = 0; 1360 trimTimedBufferQueueHead_l("getNextBuffer; no transform"); 1361 return NO_ERROR; 1362 } 1363 1364 if (mMediaTimeTransformTarget == TimedAudioTrack::COMMON_TIME) { 1365 if (OK != mCCHelper.commonTimeToLocalTime(transformedPTS, 1366 &headLocalPTS)) { 1367 buffer->raw = NULL; 1368 buffer->frameCount = 0; 1369 return INVALID_OPERATION; 1370 } 1371 } else { 1372 headLocalPTS = transformedPTS; 1373 } 1374 } 1375 1376 uint32_t sr = sampleRate(); 1377 1378 // adjust the head buffer's PTS to reflect the portion of the head buffer 1379 // that has already been consumed 1380 int64_t effectivePTS = headLocalPTS + 1381 ((head.position() / mFrameSize) * mLocalTimeFreq / sr); 1382 1383 // Calculate the delta in samples between the head of the input buffer 1384 // queue and the start of the next output buffer that will be written. 1385 // If the transformation fails because of over or underflow, it means 1386 // that the sample's position in the output stream is so far out of 1387 // whack that it should just be dropped. 1388 int64_t sampleDelta; 1389 if (llabs(effectivePTS - pts) >= (static_cast<int64_t>(1) << 31)) { 1390 ALOGV("*** head buffer is too far from PTS: dropped buffer"); 1391 trimTimedBufferQueueHead_l("getNextBuffer, buf pts too far from" 1392 " mix"); 1393 continue; 1394 } 1395 if (!mLocalTimeToSampleTransform.doForwardTransform( 1396 (effectivePTS - pts) << 32, &sampleDelta)) { 1397 ALOGV("*** too late during sample rate transform: dropped buffer"); 1398 trimTimedBufferQueueHead_l("getNextBuffer, bad local to sample"); 1399 continue; 1400 } 1401 1402 ALOGVV("*** getNextBuffer head.pts=%lld head.pos=%d pts=%lld" 1403 " sampleDelta=[%d.%08x]", 1404 head.pts(), head.position(), pts, 1405 static_cast<int32_t>((sampleDelta >= 0 ? 0 : 1) 1406 + (sampleDelta >> 32)), 1407 static_cast<uint32_t>(sampleDelta & 0xFFFFFFFF)); 1408 1409 // if the delta between the ideal placement for the next input sample and 1410 // the current output position is within this threshold, then we will 1411 // concatenate the next input samples to the previous output 1412 const int64_t kSampleContinuityThreshold = 1413 (static_cast<int64_t>(sr) << 32) / 250; 1414 1415 // if this is the first buffer of audio that we're emitting from this track 1416 // then it should be almost exactly on time. 1417 const int64_t kSampleStartupThreshold = 1LL << 32; 1418 1419 if ((mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleContinuityThreshold) || 1420 (!mTimedAudioOutputOnTime && llabs(sampleDelta) <= kSampleStartupThreshold)) { 1421 // the next input is close enough to being on time, so concatenate it 1422 // with the last output 1423 timedYieldSamples_l(buffer); 1424 1425 ALOGVV("*** on time: head.pos=%d frameCount=%u", 1426 head.position(), buffer->frameCount); 1427 return NO_ERROR; 1428 } 1429 1430 // Looks like our output is not on time. Reset our on timed status. 1431 // Next time we mix samples from our input queue, then should be within 1432 // the StartupThreshold. 1433 mTimedAudioOutputOnTime = false; 1434 if (sampleDelta > 0) { 1435 // the gap between the current output position and the proper start of 1436 // the next input sample is too big, so fill it with silence 1437 uint32_t framesUntilNextInput = (sampleDelta + 0x80000000) >> 32; 1438 1439 timedYieldSilence_l(framesUntilNextInput, buffer); 1440 ALOGV("*** silence: frameCount=%u", buffer->frameCount); 1441 return NO_ERROR; 1442 } else { 1443 // the next input sample is late 1444 uint32_t lateFrames = static_cast<uint32_t>(-((sampleDelta + 0x80000000) >> 32)); 1445 size_t onTimeSamplePosition = 1446 head.position() + lateFrames * mFrameSize; 1447 1448 if (onTimeSamplePosition > head.buffer()->size()) { 1449 // all the remaining samples in the head are too late, so 1450 // drop it and move on 1451 ALOGV("*** too late: dropped buffer"); 1452 trimTimedBufferQueueHead_l("getNextBuffer, dropped late buffer"); 1453 continue; 1454 } else { 1455 // skip over the late samples 1456 head.setPosition(onTimeSamplePosition); 1457 1458 // yield the available samples 1459 timedYieldSamples_l(buffer); 1460 1461 ALOGV("*** late: head.pos=%d frameCount=%u", head.position(), buffer->frameCount); 1462 return NO_ERROR; 1463 } 1464 } 1465 } 1466} 1467 1468// Yield samples from the timed buffer queue head up to the given output 1469// buffer's capacity. 1470// 1471// Caller must hold mTimedBufferQueueLock 1472void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSamples_l( 1473 AudioBufferProvider::Buffer* buffer) { 1474 1475 const TimedBuffer& head = mTimedBufferQueue[0]; 1476 1477 buffer->raw = (static_cast<uint8_t*>(head.buffer()->pointer()) + 1478 head.position()); 1479 1480 uint32_t framesLeftInHead = ((head.buffer()->size() - head.position()) / 1481 mFrameSize); 1482 size_t framesRequested = buffer->frameCount; 1483 buffer->frameCount = min(framesLeftInHead, framesRequested); 1484 1485 mQueueHeadInFlight = true; 1486 mTimedAudioOutputOnTime = true; 1487} 1488 1489// Yield samples of silence up to the given output buffer's capacity 1490// 1491// Caller must hold mTimedBufferQueueLock 1492void AudioFlinger::PlaybackThread::TimedTrack::timedYieldSilence_l( 1493 uint32_t numFrames, AudioBufferProvider::Buffer* buffer) { 1494 1495 // lazily allocate a buffer filled with silence 1496 if (mTimedSilenceBufferSize < numFrames * mFrameSize) { 1497 delete [] mTimedSilenceBuffer; 1498 mTimedSilenceBufferSize = numFrames * mFrameSize; 1499 mTimedSilenceBuffer = new uint8_t[mTimedSilenceBufferSize]; 1500 memset(mTimedSilenceBuffer, 0, mTimedSilenceBufferSize); 1501 } 1502 1503 buffer->raw = mTimedSilenceBuffer; 1504 size_t framesRequested = buffer->frameCount; 1505 buffer->frameCount = min(numFrames, framesRequested); 1506 1507 mTimedAudioOutputOnTime = false; 1508} 1509 1510// AudioBufferProvider interface 1511void AudioFlinger::PlaybackThread::TimedTrack::releaseBuffer( 1512 AudioBufferProvider::Buffer* buffer) { 1513 1514 Mutex::Autolock _l(mTimedBufferQueueLock); 1515 1516 // If the buffer which was just released is part of the buffer at the head 1517 // of the queue, be sure to update the amt of the buffer which has been 1518 // consumed. If the buffer being returned is not part of the head of the 1519 // queue, its either because the buffer is part of the silence buffer, or 1520 // because the head of the timed queue was trimmed after the mixer called 1521 // getNextBuffer but before the mixer called releaseBuffer. 1522 if (buffer->raw == mTimedSilenceBuffer) { 1523 ALOG_ASSERT(!mQueueHeadInFlight, 1524 "Queue head in flight during release of silence buffer!"); 1525 goto done; 1526 } 1527 1528 ALOG_ASSERT(mQueueHeadInFlight, 1529 "TimedTrack::releaseBuffer of non-silence buffer, but no queue" 1530 " head in flight."); 1531 1532 if (mTimedBufferQueue.size()) { 1533 TimedBuffer& head = mTimedBufferQueue.editItemAt(0); 1534 1535 void* start = head.buffer()->pointer(); 1536 void* end = reinterpret_cast<void*>( 1537 reinterpret_cast<uint8_t*>(head.buffer()->pointer()) 1538 + head.buffer()->size()); 1539 1540 ALOG_ASSERT((buffer->raw >= start) && (buffer->raw < end), 1541 "released buffer not within the head of the timed buffer" 1542 " queue; qHead = [%p, %p], released buffer = %p", 1543 start, end, buffer->raw); 1544 1545 head.setPosition(head.position() + 1546 (buffer->frameCount * mFrameSize)); 1547 mQueueHeadInFlight = false; 1548 1549 ALOG_ASSERT(mFramesPendingInQueue >= buffer->frameCount, 1550 "Bad bookkeeping during releaseBuffer! Should have at" 1551 " least %u queued frames, but we think we have only %u", 1552 buffer->frameCount, mFramesPendingInQueue); 1553 1554 mFramesPendingInQueue -= buffer->frameCount; 1555 1556 if ((static_cast<size_t>(head.position()) >= head.buffer()->size()) 1557 || mTrimQueueHeadOnRelease) { 1558 trimTimedBufferQueueHead_l("releaseBuffer"); 1559 mTrimQueueHeadOnRelease = false; 1560 } 1561 } else { 1562 LOG_ALWAYS_FATAL("TimedTrack::releaseBuffer of non-silence buffer with no" 1563 " buffers in the timed buffer queue"); 1564 } 1565 1566done: 1567 buffer->raw = 0; 1568 buffer->frameCount = 0; 1569} 1570 1571size_t AudioFlinger::PlaybackThread::TimedTrack::framesReady() const { 1572 Mutex::Autolock _l(mTimedBufferQueueLock); 1573 return mFramesPendingInQueue; 1574} 1575 1576AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer() 1577 : mPTS(0), mPosition(0) {} 1578 1579AudioFlinger::PlaybackThread::TimedTrack::TimedBuffer::TimedBuffer( 1580 const sp<IMemory>& buffer, int64_t pts) 1581 : mBuffer(buffer), mPTS(pts), mPosition(0) {} 1582 1583 1584// ---------------------------------------------------------------------------- 1585 1586AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( 1587 PlaybackThread *playbackThread, 1588 DuplicatingThread *sourceThread, 1589 uint32_t sampleRate, 1590 audio_format_t format, 1591 audio_channel_mask_t channelMask, 1592 size_t frameCount, 1593 int uid) 1594 : Track(playbackThread, NULL, AUDIO_STREAM_CNT, sampleRate, format, channelMask, frameCount, 1595 NULL, 0, uid, IAudioFlinger::TRACK_DEFAULT), 1596 mActive(false), mSourceThread(sourceThread), mClientProxy(NULL) 1597{ 1598 1599 if (mCblk != NULL) { 1600 mOutBuffer.frameCount = 0; 1601 playbackThread->mTracks.add(this); 1602 ALOGV("OutputTrack constructor mCblk %p, mBuffer %p, " 1603 "frameCount %u, mChannelMask 0x%08x", 1604 mCblk, mBuffer, 1605 frameCount, mChannelMask); 1606 // since client and server are in the same process, 1607 // the buffer has the same virtual address on both sides 1608 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize); 1609 mClientProxy->setVolumeLR(GAIN_MINIFLOAT_PACKED_UNITY); 1610 mClientProxy->setSendLevel(0.0); 1611 mClientProxy->setSampleRate(sampleRate); 1612 mClientProxy = new AudioTrackClientProxy(mCblk, mBuffer, mFrameCount, mFrameSize, 1613 true /*clientInServer*/); 1614 } else { 1615 ALOGW("Error creating output track on thread %p", playbackThread); 1616 } 1617} 1618 1619AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack() 1620{ 1621 clearBufferQueue(); 1622 delete mClientProxy; 1623 // superclass destructor will now delete the server proxy and shared memory both refer to 1624} 1625 1626status_t AudioFlinger::PlaybackThread::OutputTrack::start(AudioSystem::sync_event_t event, 1627 int triggerSession) 1628{ 1629 status_t status = Track::start(event, triggerSession); 1630 if (status != NO_ERROR) { 1631 return status; 1632 } 1633 1634 mActive = true; 1635 mRetryCount = 127; 1636 return status; 1637} 1638 1639void AudioFlinger::PlaybackThread::OutputTrack::stop() 1640{ 1641 Track::stop(); 1642 clearBufferQueue(); 1643 mOutBuffer.frameCount = 0; 1644 mActive = false; 1645} 1646 1647bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames) 1648{ 1649 Buffer *pInBuffer; 1650 Buffer inBuffer; 1651 uint32_t channelCount = mChannelCount; 1652 bool outputBufferFull = false; 1653 inBuffer.frameCount = frames; 1654 inBuffer.i16 = data; 1655 1656 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs(); 1657 1658 if (!mActive && frames != 0) { 1659 start(); 1660 sp<ThreadBase> thread = mThread.promote(); 1661 if (thread != 0) { 1662 MixerThread *mixerThread = (MixerThread *)thread.get(); 1663 if (mFrameCount > frames) { 1664 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 1665 uint32_t startFrames = (mFrameCount - frames); 1666 pInBuffer = new Buffer; 1667 pInBuffer->mBuffer = new int16_t[startFrames * channelCount]; 1668 pInBuffer->frameCount = startFrames; 1669 pInBuffer->i16 = pInBuffer->mBuffer; 1670 memset(pInBuffer->raw, 0, startFrames * channelCount * sizeof(int16_t)); 1671 mBufferQueue.add(pInBuffer); 1672 } else { 1673 ALOGW("OutputTrack::write() %p no more buffers in queue", this); 1674 } 1675 } 1676 } 1677 } 1678 1679 while (waitTimeLeftMs) { 1680 // First write pending buffers, then new data 1681 if (mBufferQueue.size()) { 1682 pInBuffer = mBufferQueue.itemAt(0); 1683 } else { 1684 pInBuffer = &inBuffer; 1685 } 1686 1687 if (pInBuffer->frameCount == 0) { 1688 break; 1689 } 1690 1691 if (mOutBuffer.frameCount == 0) { 1692 mOutBuffer.frameCount = pInBuffer->frameCount; 1693 nsecs_t startTime = systemTime(); 1694 status_t status = obtainBuffer(&mOutBuffer, waitTimeLeftMs); 1695 if (status != NO_ERROR) { 1696 ALOGV("OutputTrack::write() %p thread %p no more output buffers; status %d", this, 1697 mThread.unsafe_get(), status); 1698 outputBufferFull = true; 1699 break; 1700 } 1701 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime); 1702 if (waitTimeLeftMs >= waitTimeMs) { 1703 waitTimeLeftMs -= waitTimeMs; 1704 } else { 1705 waitTimeLeftMs = 0; 1706 } 1707 } 1708 1709 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : 1710 pInBuffer->frameCount; 1711 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channelCount * sizeof(int16_t)); 1712 Proxy::Buffer buf; 1713 buf.mFrameCount = outFrames; 1714 buf.mRaw = NULL; 1715 mClientProxy->releaseBuffer(&buf); 1716 pInBuffer->frameCount -= outFrames; 1717 pInBuffer->i16 += outFrames * channelCount; 1718 mOutBuffer.frameCount -= outFrames; 1719 mOutBuffer.i16 += outFrames * channelCount; 1720 1721 if (pInBuffer->frameCount == 0) { 1722 if (mBufferQueue.size()) { 1723 mBufferQueue.removeAt(0); 1724 delete [] pInBuffer->mBuffer; 1725 delete pInBuffer; 1726 ALOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this, 1727 mThread.unsafe_get(), mBufferQueue.size()); 1728 } else { 1729 break; 1730 } 1731 } 1732 } 1733 1734 // If we could not write all frames, allocate a buffer and queue it for next time. 1735 if (inBuffer.frameCount) { 1736 sp<ThreadBase> thread = mThread.promote(); 1737 if (thread != 0 && !thread->standby()) { 1738 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 1739 pInBuffer = new Buffer; 1740 pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channelCount]; 1741 pInBuffer->frameCount = inBuffer.frameCount; 1742 pInBuffer->i16 = pInBuffer->mBuffer; 1743 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channelCount * 1744 sizeof(int16_t)); 1745 mBufferQueue.add(pInBuffer); 1746 ALOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this, 1747 mThread.unsafe_get(), mBufferQueue.size()); 1748 } else { 1749 ALOGW("OutputTrack::write() %p thread %p no more overflow buffers", 1750 mThread.unsafe_get(), this); 1751 } 1752 } 1753 } 1754 1755 // Calling write() with a 0 length buffer, means that no more data will be written: 1756 // If no more buffers are pending, fill output track buffer to make sure it is started 1757 // by output mixer. 1758 if (frames == 0 && mBufferQueue.size() == 0) { 1759 // FIXME borken, replace by getting framesReady() from proxy 1760 size_t user = 0; // was mCblk->user 1761 if (user < mFrameCount) { 1762 frames = mFrameCount - user; 1763 pInBuffer = new Buffer; 1764 pInBuffer->mBuffer = new int16_t[frames * channelCount]; 1765 pInBuffer->frameCount = frames; 1766 pInBuffer->i16 = pInBuffer->mBuffer; 1767 memset(pInBuffer->raw, 0, frames * channelCount * sizeof(int16_t)); 1768 mBufferQueue.add(pInBuffer); 1769 } else if (mActive) { 1770 stop(); 1771 } 1772 } 1773 1774 return outputBufferFull; 1775} 1776 1777status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer( 1778 AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs) 1779{ 1780 ClientProxy::Buffer buf; 1781 buf.mFrameCount = buffer->frameCount; 1782 struct timespec timeout; 1783 timeout.tv_sec = waitTimeMs / 1000; 1784 timeout.tv_nsec = (int) (waitTimeMs % 1000) * 1000000; 1785 status_t status = mClientProxy->obtainBuffer(&buf, &timeout); 1786 buffer->frameCount = buf.mFrameCount; 1787 buffer->raw = buf.mRaw; 1788 return status; 1789} 1790 1791void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue() 1792{ 1793 size_t size = mBufferQueue.size(); 1794 1795 for (size_t i = 0; i < size; i++) { 1796 Buffer *pBuffer = mBufferQueue.itemAt(i); 1797 delete [] pBuffer->mBuffer; 1798 delete pBuffer; 1799 } 1800 mBufferQueue.clear(); 1801} 1802 1803 1804// ---------------------------------------------------------------------------- 1805// Record 1806// ---------------------------------------------------------------------------- 1807 1808AudioFlinger::RecordHandle::RecordHandle( 1809 const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack) 1810 : BnAudioRecord(), 1811 mRecordTrack(recordTrack) 1812{ 1813} 1814 1815AudioFlinger::RecordHandle::~RecordHandle() { 1816 stop_nonvirtual(); 1817 mRecordTrack->destroy(); 1818} 1819 1820status_t AudioFlinger::RecordHandle::start(int /*AudioSystem::sync_event_t*/ event, 1821 int triggerSession) { 1822 ALOGV("RecordHandle::start()"); 1823 return mRecordTrack->start((AudioSystem::sync_event_t)event, triggerSession); 1824} 1825 1826void AudioFlinger::RecordHandle::stop() { 1827 stop_nonvirtual(); 1828} 1829 1830void AudioFlinger::RecordHandle::stop_nonvirtual() { 1831 ALOGV("RecordHandle::stop()"); 1832 mRecordTrack->stop(); 1833} 1834 1835status_t AudioFlinger::RecordHandle::onTransact( 1836 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 1837{ 1838 return BnAudioRecord::onTransact(code, data, reply, flags); 1839} 1840 1841// ---------------------------------------------------------------------------- 1842 1843// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held 1844AudioFlinger::RecordThread::RecordTrack::RecordTrack( 1845 RecordThread *thread, 1846 const sp<Client>& client, 1847 uint32_t sampleRate, 1848 audio_format_t format, 1849 audio_channel_mask_t channelMask, 1850 size_t frameCount, 1851 int sessionId, 1852 int uid, 1853 IAudioFlinger::track_flags_t flags) 1854 : TrackBase(thread, client, sampleRate, format, 1855 channelMask, frameCount, 0 /*sharedBuffer*/, sessionId, uid, 1856 flags, false /*isOut*/, 1857 (flags & IAudioFlinger::TRACK_FAST) != 0 ? ALLOC_READONLY : ALLOC_CBLK), 1858 mOverflow(false), mResampler(NULL), mRsmpOutBuffer(NULL), mRsmpOutFrameCount(0), 1859 // See real initialization of mRsmpInFront at RecordThread::start() 1860 mRsmpInUnrel(0), mRsmpInFront(0), mFramesToDrop(0), mResamplerBufferProvider(NULL) 1861{ 1862 if (mCblk == NULL) { 1863 return; 1864 } 1865 1866 mServerProxy = new AudioRecordServerProxy(mCblk, mBuffer, frameCount, mFrameSize); 1867 1868 uint32_t channelCount = audio_channel_count_from_in_mask(channelMask); 1869 // FIXME I don't understand either of the channel count checks 1870 if (thread->mSampleRate != sampleRate && thread->mChannelCount <= FCC_2 && 1871 channelCount <= FCC_2) { 1872 // sink SR 1873 mResampler = AudioResampler::create(16, thread->mChannelCount, sampleRate); 1874 // source SR 1875 mResampler->setSampleRate(thread->mSampleRate); 1876 mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN); 1877 mResamplerBufferProvider = new ResamplerBufferProvider(this); 1878 } 1879} 1880 1881AudioFlinger::RecordThread::RecordTrack::~RecordTrack() 1882{ 1883 ALOGV("%s", __func__); 1884 delete mResampler; 1885 delete[] mRsmpOutBuffer; 1886 delete mResamplerBufferProvider; 1887} 1888 1889// AudioBufferProvider interface 1890status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer, 1891 int64_t pts __unused) 1892{ 1893 ServerProxy::Buffer buf; 1894 buf.mFrameCount = buffer->frameCount; 1895 status_t status = mServerProxy->obtainBuffer(&buf); 1896 buffer->frameCount = buf.mFrameCount; 1897 buffer->raw = buf.mRaw; 1898 if (buf.mFrameCount == 0) { 1899 // FIXME also wake futex so that overrun is noticed more quickly 1900 (void) android_atomic_or(CBLK_OVERRUN, &mCblk->mFlags); 1901 } 1902 return status; 1903} 1904 1905status_t AudioFlinger::RecordThread::RecordTrack::start(AudioSystem::sync_event_t event, 1906 int triggerSession) 1907{ 1908 sp<ThreadBase> thread = mThread.promote(); 1909 if (thread != 0) { 1910 RecordThread *recordThread = (RecordThread *)thread.get(); 1911 return recordThread->start(this, event, triggerSession); 1912 } else { 1913 return BAD_VALUE; 1914 } 1915} 1916 1917void AudioFlinger::RecordThread::RecordTrack::stop() 1918{ 1919 sp<ThreadBase> thread = mThread.promote(); 1920 if (thread != 0) { 1921 RecordThread *recordThread = (RecordThread *)thread.get(); 1922 if (recordThread->stop(this)) { 1923 AudioSystem::stopInput(recordThread->id()); 1924 } 1925 } 1926} 1927 1928void AudioFlinger::RecordThread::RecordTrack::destroy() 1929{ 1930 // see comments at AudioFlinger::PlaybackThread::Track::destroy() 1931 sp<RecordTrack> keep(this); 1932 { 1933 sp<ThreadBase> thread = mThread.promote(); 1934 if (thread != 0) { 1935 if (mState == ACTIVE || mState == RESUMING) { 1936 AudioSystem::stopInput(thread->id()); 1937 } 1938 AudioSystem::releaseInput(thread->id()); 1939 Mutex::Autolock _l(thread->mLock); 1940 RecordThread *recordThread = (RecordThread *) thread.get(); 1941 recordThread->destroyTrack_l(this); 1942 } 1943 } 1944} 1945 1946void AudioFlinger::RecordThread::RecordTrack::invalidate() 1947{ 1948 // FIXME should use proxy, and needs work 1949 audio_track_cblk_t* cblk = mCblk; 1950 android_atomic_or(CBLK_INVALID, &cblk->mFlags); 1951 android_atomic_release_store(0x40000000, &cblk->mFutex); 1952 // client is not in server, so FUTEX_WAKE is needed instead of FUTEX_WAKE_PRIVATE 1953 (void) syscall(__NR_futex, &cblk->mFutex, FUTEX_WAKE, INT_MAX); 1954} 1955 1956 1957/*static*/ void AudioFlinger::RecordThread::RecordTrack::appendDumpHeader(String8& result) 1958{ 1959 result.append(" Active Client Fmt Chn mask Session S Server fCount Resampling\n"); 1960} 1961 1962void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size, bool active) 1963{ 1964 snprintf(buffer, size, " %6s %6u %3u %08X %7u %1d %08X %6zu %10d\n", 1965 active ? "yes" : "no", 1966 (mClient == 0) ? getpid_cached : mClient->pid(), 1967 mFormat, 1968 mChannelMask, 1969 mSessionId, 1970 mState, 1971 mCblk->mServer, 1972 mFrameCount, 1973 mResampler != NULL); 1974 1975} 1976 1977void AudioFlinger::RecordThread::RecordTrack::handleSyncStartEvent(const sp<SyncEvent>& event) 1978{ 1979 if (event == mSyncStartEvent) { 1980 ssize_t framesToDrop = 0; 1981 sp<ThreadBase> threadBase = mThread.promote(); 1982 if (threadBase != 0) { 1983 // TODO: use actual buffer filling status instead of 2 buffers when info is available 1984 // from audio HAL 1985 framesToDrop = threadBase->mFrameCount * 2; 1986 } 1987 mFramesToDrop = framesToDrop; 1988 } 1989} 1990 1991void AudioFlinger::RecordThread::RecordTrack::clearSyncStartEvent() 1992{ 1993 if (mSyncStartEvent != 0) { 1994 mSyncStartEvent->cancel(); 1995 mSyncStartEvent.clear(); 1996 } 1997 mFramesToDrop = 0; 1998} 1999 2000}; // namespace android 2001